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 1040f4b3ec61Sdh155122 static int 1041f4b3ec61Sdh155122 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. 10880679f794S * If we are mounting the zone, then we must always use the native 10890679f794S * brand device mounts. 10900679f794S */ 10910679f794S if (ALT_MOUNT(mount_cmd)) { 10920679f794S (void) strlcpy(brand, NATIVE_BRAND_NAME, sizeof (brand)); 10930679f794S } else { 10940679f794S if (zone_get_brand(zone_name, brand, sizeof (brand)) != Z_OK) { 10950679f794S zerror(zlogp, B_FALSE, 10960679f794S "unable to determine zone brand"); 10970679f794S goto cleanup; 10980679f794S } 10990679f794S } 11000679f794S 11010679f794S if ((bh = brand_open(brand)) == NULL) { 11029acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 11039acbbeafSnn35248 goto cleanup; 11049acbbeafSnn35248 } 11059acbbeafSnn35248 1106f4b3ec61Sdh155122 if (get_iptype(zlogp, &iptype) < 0) { 1107f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 1108f4b3ec61Sdh155122 goto cleanup; 1109f4b3ec61Sdh155122 } 1110f4b3ec61Sdh155122 switch (iptype) { 1111f4b3ec61Sdh155122 case ZS_SHARED: 1112f4b3ec61Sdh155122 curr_iptype = "shared"; 1113f4b3ec61Sdh155122 break; 1114f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 1115f4b3ec61Sdh155122 curr_iptype = "exclusive"; 1116f4b3ec61Sdh155122 break; 1117f4b3ec61Sdh155122 } 1118f4b3ec61Sdh155122 1119123807fbSedp if (brand_platform_iter_devices(bh, zone_name, 1120f4b3ec61Sdh155122 mount_one_dev_device_cb, prof, curr_iptype) != 0) { 11219acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to add standard device"); 11229acbbeafSnn35248 goto cleanup; 11239acbbeafSnn35248 } 11249acbbeafSnn35248 1125123807fbSedp if (brand_platform_iter_link(bh, 11269acbbeafSnn35248 mount_one_dev_symlink_cb, prof) != 0) { 11279acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to add standard symlink"); 11289acbbeafSnn35248 goto cleanup; 11299acbbeafSnn35248 } 11309acbbeafSnn35248 11319acbbeafSnn35248 /* Add user-specified devices and directories */ 11329acbbeafSnn35248 if ((handle = zonecfg_init_handle()) == NULL) { 11339acbbeafSnn35248 zerror(zlogp, B_FALSE, "can't initialize zone handle"); 11349acbbeafSnn35248 goto cleanup; 11359acbbeafSnn35248 } 11369acbbeafSnn35248 if (err = zonecfg_get_handle(zone_name, handle)) { 11379acbbeafSnn35248 zerror(zlogp, B_FALSE, "can't get handle for zone " 11389acbbeafSnn35248 "%s: %s", zone_name, zonecfg_strerror(err)); 11399acbbeafSnn35248 goto cleanup; 11409acbbeafSnn35248 } 11419acbbeafSnn35248 if (err = zonecfg_setdevent(handle)) { 11429acbbeafSnn35248 zerror(zlogp, B_FALSE, "%s: %s", zone_name, 11439acbbeafSnn35248 zonecfg_strerror(err)); 11449acbbeafSnn35248 goto cleanup; 11459acbbeafSnn35248 } 11469acbbeafSnn35248 while (zonecfg_getdevent(handle, &ztab) == Z_OK) { 11479acbbeafSnn35248 if (di_prof_add_dev(prof, ztab.zone_dev_match)) { 11489acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to add " 11499acbbeafSnn35248 "user-specified device"); 11509acbbeafSnn35248 goto cleanup; 11519acbbeafSnn35248 } 11529acbbeafSnn35248 } 11539acbbeafSnn35248 (void) zonecfg_enddevent(handle); 11549acbbeafSnn35248 11559acbbeafSnn35248 /* Send profile to kernel */ 11569acbbeafSnn35248 if (di_prof_commit(prof)) { 11579acbbeafSnn35248 zerror(zlogp, B_TRUE, "failed to commit profile"); 11589acbbeafSnn35248 goto cleanup; 11599acbbeafSnn35248 } 11609acbbeafSnn35248 11619acbbeafSnn35248 retval = 0; 11629acbbeafSnn35248 11639acbbeafSnn35248 cleanup: 1164123807fbSedp if (bh != NULL) 1165123807fbSedp brand_close(bh); 1166e767a340Sgjelinek if (handle != NULL) 11679acbbeafSnn35248 zonecfg_fini_handle(handle); 11689acbbeafSnn35248 if (prof) 11699acbbeafSnn35248 di_prof_fini(prof); 11709acbbeafSnn35248 return (retval); 11719acbbeafSnn35248 } 11729acbbeafSnn35248 11739acbbeafSnn35248 static int 11740679f794S mount_one(zlog_t *zlogp, struct zone_fstab *fsptr, const char *rootpath, 11750679f794S zone_mnt_t mount_cmd) 11767c478bd9Sstevel@tonic-gate { 11777c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 1178108322fbScarlsonj char specpath[MAXPATHLEN]; 11797c478bd9Sstevel@tonic-gate char optstr[MAX_MNTOPT_STR]; 11807c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 11819acbbeafSnn35248 int rv; 11827c478bd9Sstevel@tonic-gate 1183d314f035Sedp if ((rv = valid_mount_path(zlogp, rootpath, fsptr->zone_fs_special, 1184d314f035Sedp fsptr->zone_fs_dir, fsptr->zone_fs_type)) < 0) { 11857c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s%s is not a valid mount point", 11867c478bd9Sstevel@tonic-gate rootpath, fsptr->zone_fs_dir); 11877c478bd9Sstevel@tonic-gate return (-1); 1188d314f035Sedp } else if (rv > 0) { 1189d314f035Sedp /* The mount point path doesn't exist, create it now. */ 1190d314f035Sedp if (make_one_dir(zlogp, rootpath, fsptr->zone_fs_dir, 1191d314f035Sedp DEFAULT_DIR_MODE, DEFAULT_DIR_USER, 1192d314f035Sedp DEFAULT_DIR_GROUP) != 0) { 1193d314f035Sedp zerror(zlogp, B_FALSE, "failed to create mount point"); 1194d314f035Sedp return (-1); 11957c478bd9Sstevel@tonic-gate } 11967c478bd9Sstevel@tonic-gate 1197d314f035Sedp /* 1198d314f035Sedp * Now this might seem weird, but we need to invoke 1199d314f035Sedp * valid_mount_path() again. Why? Because it checks 1200d314f035Sedp * to make sure that the mount point path is canonical, 1201d314f035Sedp * which it can only do if the path exists, so now that 1202d314f035Sedp * we've created the path we have to verify it again. 1203d314f035Sedp */ 1204d314f035Sedp if ((rv = valid_mount_path(zlogp, rootpath, 1205d314f035Sedp fsptr->zone_fs_special, fsptr->zone_fs_dir, 1206d314f035Sedp fsptr->zone_fs_type)) < 0) { 1207d314f035Sedp zerror(zlogp, B_FALSE, 1208d314f035Sedp "%s%s is not a valid mount point", 1209d314f035Sedp rootpath, fsptr->zone_fs_dir); 12107c478bd9Sstevel@tonic-gate return (-1); 1211d314f035Sedp } 1212d314f035Sedp } 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "%s%s", rootpath, 12157c478bd9Sstevel@tonic-gate fsptr->zone_fs_dir); 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate if (strlen(fsptr->zone_fs_special) == 0) { 12187c478bd9Sstevel@tonic-gate /* 12197c478bd9Sstevel@tonic-gate * A zero-length special is how we distinguish IPDs from 1220108322fbScarlsonj * general-purpose FSs. Make sure it mounts from a place that 1221108322fbScarlsonj * can be seen via the alternate zone's root. 12227c478bd9Sstevel@tonic-gate */ 1223108322fbScarlsonj if (snprintf(specpath, sizeof (specpath), "%s%s", 1224108322fbScarlsonj zonecfg_get_root(), fsptr->zone_fs_dir) >= 1225108322fbScarlsonj sizeof (specpath)) { 1226108322fbScarlsonj zerror(zlogp, B_FALSE, "cannot mount %s: path too " 1227108322fbScarlsonj "long in alternate root", fsptr->zone_fs_dir); 1228108322fbScarlsonj return (-1); 1229108322fbScarlsonj } 1230108322fbScarlsonj if (zonecfg_in_alt_root()) 1231108322fbScarlsonj resolve_lofs(zlogp, specpath, sizeof (specpath)); 12327c478bd9Sstevel@tonic-gate if (domount(zlogp, MNTTYPE_LOFS, IPD_DEFAULT_OPTS, 1233108322fbScarlsonj specpath, path) != 0) { 12347c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to loopback mount %s", 1235108322fbScarlsonj specpath); 12367c478bd9Sstevel@tonic-gate return (-1); 12377c478bd9Sstevel@tonic-gate } 12387c478bd9Sstevel@tonic-gate return (0); 12397c478bd9Sstevel@tonic-gate } 12407c478bd9Sstevel@tonic-gate 12417c478bd9Sstevel@tonic-gate /* 12427c478bd9Sstevel@tonic-gate * In general the strategy here is to do just as much verification as 12437c478bd9Sstevel@tonic-gate * necessary to avoid crashing or otherwise doing something bad; if the 12447c478bd9Sstevel@tonic-gate * administrator initiated the operation via zoneadm(1m), he'll get 12457c478bd9Sstevel@tonic-gate * auto-verification which will let him know what's wrong. If he 12467c478bd9Sstevel@tonic-gate * modifies the zone configuration of a running zone and doesn't attempt 12477c478bd9Sstevel@tonic-gate * to verify that it's OK we won't crash but won't bother trying to be 12487c478bd9Sstevel@tonic-gate * too helpful either. zoneadm verify is only a couple keystrokes away. 12497c478bd9Sstevel@tonic-gate */ 12507c478bd9Sstevel@tonic-gate if (!zonecfg_valid_fs_type(fsptr->zone_fs_type)) { 12517c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "cannot mount %s on %s: " 12527c478bd9Sstevel@tonic-gate "invalid file-system type %s", fsptr->zone_fs_special, 12537c478bd9Sstevel@tonic-gate fsptr->zone_fs_dir, fsptr->zone_fs_type); 12547c478bd9Sstevel@tonic-gate return (-1); 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate /* 1258108322fbScarlsonj * If we're looking at an alternate root environment, then construct 1259fa3d7ae1Sedp * read-only loopback mounts as necessary. Note that any special 1260fa3d7ae1Sedp * paths for lofs zone mounts in an alternate root must have 1261fa3d7ae1Sedp * already been pre-pended with any alternate root path by the 1262fa3d7ae1Sedp * time we get here. 1263108322fbScarlsonj */ 1264108322fbScarlsonj if (zonecfg_in_alt_root()) { 1265108322fbScarlsonj struct stat64 st; 1266108322fbScarlsonj 1267108322fbScarlsonj if (stat64(fsptr->zone_fs_special, &st) != -1 && 126868eeb376Scarlsonj S_ISBLK(st.st_mode)) { 1269fa3d7ae1Sedp /* 1270fa3d7ae1Sedp * If we're going to mount a block device we need 1271fa3d7ae1Sedp * to check if that device is already mounted 1272fa3d7ae1Sedp * somewhere else, and if so, do a lofs mount 1273fa3d7ae1Sedp * of the device instead of a direct mount 1274fa3d7ae1Sedp */ 127568eeb376Scarlsonj if (check_lofs_needed(zlogp, fsptr) == -1) 1276108322fbScarlsonj return (-1); 127768eeb376Scarlsonj } else if (strcmp(fsptr->zone_fs_type, MNTTYPE_LOFS) == 0) { 1278fa3d7ae1Sedp /* 1279fa3d7ae1Sedp * For lofs mounts, the special node is inside the 1280fa3d7ae1Sedp * alternate root. We need lofs resolution for 1281fa3d7ae1Sedp * this case in order to get at the underlying 1282fa3d7ae1Sedp * read-write path. 1283fa3d7ae1Sedp */ 1284fa3d7ae1Sedp resolve_lofs(zlogp, fsptr->zone_fs_special, 1285108322fbScarlsonj sizeof (fsptr->zone_fs_special)); 1286108322fbScarlsonj } 1287108322fbScarlsonj } 1288108322fbScarlsonj 1289108322fbScarlsonj /* 12907c478bd9Sstevel@tonic-gate * Run 'fsck -m' if there's a device to fsck. 12917c478bd9Sstevel@tonic-gate */ 12927c478bd9Sstevel@tonic-gate if (fsptr->zone_fs_raw[0] != '\0' && 129393239addSjohnlev dofsck(zlogp, fsptr->zone_fs_type, fsptr->zone_fs_raw) != 0) { 12947c478bd9Sstevel@tonic-gate return (-1); 129593239addSjohnlev } else if (isregfile(fsptr->zone_fs_special) == 1 && 129693239addSjohnlev dofsck(zlogp, fsptr->zone_fs_type, fsptr->zone_fs_special) != 0) { 129793239addSjohnlev return (-1); 129893239addSjohnlev } 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate /* 13017c478bd9Sstevel@tonic-gate * Build up mount option string. 13027c478bd9Sstevel@tonic-gate */ 13037c478bd9Sstevel@tonic-gate optstr[0] = '\0'; 13047c478bd9Sstevel@tonic-gate if (fsptr->zone_fs_options != NULL) { 13057c478bd9Sstevel@tonic-gate (void) strlcpy(optstr, fsptr->zone_fs_options->zone_fsopt_opt, 13067c478bd9Sstevel@tonic-gate sizeof (optstr)); 13077c478bd9Sstevel@tonic-gate for (optptr = fsptr->zone_fs_options->zone_fsopt_next; 13087c478bd9Sstevel@tonic-gate optptr != NULL; optptr = optptr->zone_fsopt_next) { 13097c478bd9Sstevel@tonic-gate (void) strlcat(optstr, ",", sizeof (optstr)); 13107c478bd9Sstevel@tonic-gate (void) strlcat(optstr, optptr->zone_fsopt_opt, 13117c478bd9Sstevel@tonic-gate sizeof (optstr)); 13127c478bd9Sstevel@tonic-gate } 13137c478bd9Sstevel@tonic-gate } 13149acbbeafSnn35248 13159acbbeafSnn35248 if ((rv = domount(zlogp, fsptr->zone_fs_type, optstr, 13169acbbeafSnn35248 fsptr->zone_fs_special, path)) != 0) 13179acbbeafSnn35248 return (rv); 13189acbbeafSnn35248 13199acbbeafSnn35248 /* 13209acbbeafSnn35248 * The mount succeeded. If this was not a mount of /dev then 13219acbbeafSnn35248 * we're done. 13229acbbeafSnn35248 */ 13239acbbeafSnn35248 if (strcmp(fsptr->zone_fs_type, MNTTYPE_DEV) != 0) 13249acbbeafSnn35248 return (0); 13259acbbeafSnn35248 13269acbbeafSnn35248 /* 13279acbbeafSnn35248 * We just mounted an instance of a /dev filesystem, so now we 13289acbbeafSnn35248 * need to configure it. 13299acbbeafSnn35248 */ 13300679f794S return (mount_one_dev(zlogp, path, mount_cmd)); 13317c478bd9Sstevel@tonic-gate } 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate static void 13347c478bd9Sstevel@tonic-gate free_fs_data(struct zone_fstab *fsarray, uint_t nelem) 13357c478bd9Sstevel@tonic-gate { 13367c478bd9Sstevel@tonic-gate uint_t i; 13377c478bd9Sstevel@tonic-gate 13387c478bd9Sstevel@tonic-gate if (fsarray == NULL) 13397c478bd9Sstevel@tonic-gate return; 13407c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) 13417c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fsarray[i].zone_fs_options); 13427c478bd9Sstevel@tonic-gate free(fsarray); 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate 1345108322fbScarlsonj /* 1346f4368d3dSvp157776 * This function initiates the creation of a small Solaris Environment for 1347f4368d3dSvp157776 * scratch zone. The Environment creation process is split up into two 1348f4368d3dSvp157776 * functions(build_mounted_pre_var() and build_mounted_post_var()). It 1349f4368d3dSvp157776 * is done this way because: 1350f4368d3dSvp157776 * We need to have both /etc and /var in the root of the scratchzone. 1351f4368d3dSvp157776 * We loopback mount zone's own /etc and /var into the root of the 1352f4368d3dSvp157776 * scratch zone. Unlike /etc, /var can be a seperate filesystem. So we 1353f4368d3dSvp157776 * need to delay the mount of /var till the zone's root gets populated. 1354f4368d3dSvp157776 * So mounting of localdirs[](/etc and /var) have been moved to the 1355f4368d3dSvp157776 * build_mounted_post_var() which gets called only after the zone 1356f4368d3dSvp157776 * specific filesystems are mounted. 13576cfd72c6Sgjelinek * 13586cfd72c6Sgjelinek * Note that the scratch zone we set up for updating the zone (Z_MNT_UPDATE) 13596cfd72c6Sgjelinek * does not loopback mount the zone's own /etc and /var into the root of the 13606cfd72c6Sgjelinek * scratch zone. 1361108322fbScarlsonj */ 1362108322fbScarlsonj static boolean_t 1363f4368d3dSvp157776 build_mounted_pre_var(zlog_t *zlogp, char *rootpath, 136416bca938Svp157776 size_t rootlen, const char *zonepath, char *luroot, size_t lurootlen) 1365108322fbScarlsonj { 1366108322fbScarlsonj char tmp[MAXPATHLEN], fromdir[MAXPATHLEN]; 1367108322fbScarlsonj const char **cpp; 1368108322fbScarlsonj static const char *mkdirs[] = { 13693f604e0fSdp "/system", "/system/contract", "/system/object", "/proc", 13703f604e0fSdp "/dev", "/tmp", "/a", NULL 1371108322fbScarlsonj }; 1372108322fbScarlsonj char *altstr; 1373f4368d3dSvp157776 FILE *fp; 1374108322fbScarlsonj uuid_t uuid; 1375108322fbScarlsonj 1376108322fbScarlsonj resolve_lofs(zlogp, rootpath, rootlen); 137716bca938Svp157776 (void) snprintf(luroot, lurootlen, "%s/lu", zonepath); 137816bca938Svp157776 resolve_lofs(zlogp, luroot, lurootlen); 1379108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s/bin", luroot); 1380108322fbScarlsonj (void) symlink("./usr/bin", tmp); 1381108322fbScarlsonj 1382108322fbScarlsonj /* 1383108322fbScarlsonj * These are mostly special mount points; not handled here. (See 1384108322fbScarlsonj * zone_mount_early.) 1385108322fbScarlsonj */ 1386108322fbScarlsonj for (cpp = mkdirs; *cpp != NULL; cpp++) { 1387108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 1388108322fbScarlsonj if (mkdir(tmp, 0755) != 0) { 1389108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1390108322fbScarlsonj return (B_FALSE); 1391108322fbScarlsonj } 1392108322fbScarlsonj } 1393f4368d3dSvp157776 /* 1394f4368d3dSvp157776 * This is here to support lucopy. If there's an instance of this same 1395f4368d3dSvp157776 * zone on the current running system, then we mount its root up as 1396f4368d3dSvp157776 * read-only inside the scratch zone. 1397f4368d3dSvp157776 */ 1398f4368d3dSvp157776 (void) zonecfg_get_uuid(zone_name, uuid); 1399f4368d3dSvp157776 altstr = strdup(zonecfg_get_root()); 1400f4368d3dSvp157776 if (altstr == NULL) { 1401f4368d3dSvp157776 zerror(zlogp, B_TRUE, "memory allocation failed"); 1402f4368d3dSvp157776 return (B_FALSE); 1403f4368d3dSvp157776 } 1404f4368d3dSvp157776 zonecfg_set_root(""); 1405f4368d3dSvp157776 (void) strlcpy(tmp, zone_name, sizeof (tmp)); 1406f4368d3dSvp157776 (void) zonecfg_get_name_by_uuid(uuid, tmp, sizeof (tmp)); 1407f4368d3dSvp157776 if (zone_get_rootpath(tmp, fromdir, sizeof (fromdir)) == Z_OK && 1408f4368d3dSvp157776 strcmp(fromdir, rootpath) != 0) { 1409f4368d3dSvp157776 (void) snprintf(tmp, sizeof (tmp), "%s/b", luroot); 1410f4368d3dSvp157776 if (mkdir(tmp, 0755) != 0) { 1411f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1412f4368d3dSvp157776 return (B_FALSE); 1413f4368d3dSvp157776 } 1414f4368d3dSvp157776 if (domount(zlogp, MNTTYPE_LOFS, IPD_DEFAULT_OPTS, fromdir, 1415f4368d3dSvp157776 tmp) != 0) { 1416f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot mount %s on %s", tmp, 1417f4368d3dSvp157776 fromdir); 1418f4368d3dSvp157776 return (B_FALSE); 1419f4368d3dSvp157776 } 1420f4368d3dSvp157776 } 1421f4368d3dSvp157776 zonecfg_set_root(altstr); 1422f4368d3dSvp157776 free(altstr); 1423f4368d3dSvp157776 1424f4368d3dSvp157776 if ((fp = zonecfg_open_scratch(luroot, B_TRUE)) == NULL) { 1425f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot open zone mapfile"); 1426f4368d3dSvp157776 return (B_FALSE); 1427f4368d3dSvp157776 } 1428f4368d3dSvp157776 (void) ftruncate(fileno(fp), 0); 1429f4368d3dSvp157776 if (zonecfg_add_scratch(fp, zone_name, kernzone, "/") == -1) { 1430f4368d3dSvp157776 zerror(zlogp, B_TRUE, "cannot add zone mapfile entry"); 1431f4368d3dSvp157776 } 1432f4368d3dSvp157776 zonecfg_close_scratch(fp); 1433f4368d3dSvp157776 (void) snprintf(tmp, sizeof (tmp), "%s/a", luroot); 1434f4368d3dSvp157776 if (domount(zlogp, MNTTYPE_LOFS, "", rootpath, tmp) != 0) 1435f4368d3dSvp157776 return (B_FALSE); 1436f4368d3dSvp157776 (void) strlcpy(rootpath, tmp, rootlen); 1437f4368d3dSvp157776 return (B_TRUE); 1438f4368d3dSvp157776 } 1439f4368d3dSvp157776 1440f4368d3dSvp157776 1441f4368d3dSvp157776 static boolean_t 14426cfd72c6Sgjelinek build_mounted_post_var(zlog_t *zlogp, zone_mnt_t mount_cmd, char *rootpath, 14436cfd72c6Sgjelinek const char *luroot) 1444f4368d3dSvp157776 { 1445f4368d3dSvp157776 char tmp[MAXPATHLEN], fromdir[MAXPATHLEN]; 1446f4368d3dSvp157776 const char **cpp; 14476cfd72c6Sgjelinek const char **loopdirs; 14486cfd72c6Sgjelinek const char **tmpdirs; 1449f4368d3dSvp157776 static const char *localdirs[] = { 1450f4368d3dSvp157776 "/etc", "/var", NULL 1451f4368d3dSvp157776 }; 14526cfd72c6Sgjelinek static const char *scr_loopdirs[] = { 1453f4368d3dSvp157776 "/etc/lib", "/etc/fs", "/lib", "/sbin", "/platform", 1454f4368d3dSvp157776 "/usr", NULL 1455f4368d3dSvp157776 }; 14566cfd72c6Sgjelinek static const char *upd_loopdirs[] = { 14576cfd72c6Sgjelinek "/etc", "/kernel", "/lib", "/opt", "/platform", "/sbin", 14586cfd72c6Sgjelinek "/usr", "/var", NULL 14596cfd72c6Sgjelinek }; 14606cfd72c6Sgjelinek static const char *scr_tmpdirs[] = { 1461f4368d3dSvp157776 "/tmp", "/var/run", NULL 1462f4368d3dSvp157776 }; 14636cfd72c6Sgjelinek static const char *upd_tmpdirs[] = { 14646cfd72c6Sgjelinek "/tmp", "/var/run", "/var/tmp", NULL 14656cfd72c6Sgjelinek }; 1466f4368d3dSvp157776 struct stat st; 1467f4368d3dSvp157776 14686cfd72c6Sgjelinek if (mount_cmd == Z_MNT_SCRATCH) { 1469108322fbScarlsonj /* 14706cfd72c6Sgjelinek * These are mounted read-write from the zone undergoing 14716cfd72c6Sgjelinek * upgrade. We must be careful not to 'leak' things from the 14726cfd72c6Sgjelinek * main system into the zone, and this accomplishes that goal. 1473108322fbScarlsonj */ 1474108322fbScarlsonj for (cpp = localdirs; *cpp != NULL; cpp++) { 14756cfd72c6Sgjelinek (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, 1476108322fbScarlsonj *cpp); 14776cfd72c6Sgjelinek (void) snprintf(fromdir, sizeof (fromdir), "%s%s", 14786cfd72c6Sgjelinek rootpath, *cpp); 1479108322fbScarlsonj if (mkdir(tmp, 0755) != 0) { 1480108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1481108322fbScarlsonj return (B_FALSE); 1482108322fbScarlsonj } 14836cfd72c6Sgjelinek if (domount(zlogp, MNTTYPE_LOFS, "", fromdir, tmp) 14846cfd72c6Sgjelinek != 0) { 14856cfd72c6Sgjelinek zerror(zlogp, B_TRUE, "cannot mount %s on %s", 14866cfd72c6Sgjelinek tmp, *cpp); 1487108322fbScarlsonj return (B_FALSE); 1488108322fbScarlsonj } 1489108322fbScarlsonj } 14906cfd72c6Sgjelinek } 14916cfd72c6Sgjelinek 14926cfd72c6Sgjelinek if (mount_cmd == Z_MNT_UPDATE) 14936cfd72c6Sgjelinek loopdirs = upd_loopdirs; 14946cfd72c6Sgjelinek else 14956cfd72c6Sgjelinek loopdirs = scr_loopdirs; 1496108322fbScarlsonj 1497108322fbScarlsonj /* 1498108322fbScarlsonj * These are things mounted read-only from the running system because 1499108322fbScarlsonj * they contain binaries that must match system. 1500108322fbScarlsonj */ 1501108322fbScarlsonj for (cpp = loopdirs; *cpp != NULL; cpp++) { 1502108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 1503108322fbScarlsonj if (mkdir(tmp, 0755) != 0) { 1504108322fbScarlsonj if (errno != EEXIST) { 1505108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1506108322fbScarlsonj return (B_FALSE); 1507108322fbScarlsonj } 1508108322fbScarlsonj if (lstat(tmp, &st) != 0) { 1509108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot stat %s", tmp); 1510108322fbScarlsonj return (B_FALSE); 1511108322fbScarlsonj } 1512108322fbScarlsonj /* 1513108322fbScarlsonj * Ignore any non-directories encountered. These are 1514108322fbScarlsonj * things that have been converted into symlinks 1515108322fbScarlsonj * (/etc/fs and /etc/lib) and no longer need a lofs 1516108322fbScarlsonj * fixup. 1517108322fbScarlsonj */ 1518108322fbScarlsonj if (!S_ISDIR(st.st_mode)) 1519108322fbScarlsonj continue; 1520108322fbScarlsonj } 1521108322fbScarlsonj if (domount(zlogp, MNTTYPE_LOFS, IPD_DEFAULT_OPTS, *cpp, 1522108322fbScarlsonj tmp) != 0) { 1523108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot mount %s on %s", tmp, 1524108322fbScarlsonj *cpp); 1525108322fbScarlsonj return (B_FALSE); 1526108322fbScarlsonj } 1527108322fbScarlsonj } 1528108322fbScarlsonj 15296cfd72c6Sgjelinek if (mount_cmd == Z_MNT_UPDATE) 15306cfd72c6Sgjelinek tmpdirs = upd_tmpdirs; 15316cfd72c6Sgjelinek else 15326cfd72c6Sgjelinek tmpdirs = scr_tmpdirs; 15336cfd72c6Sgjelinek 1534108322fbScarlsonj /* 1535108322fbScarlsonj * These are things with tmpfs mounted inside. 1536108322fbScarlsonj */ 1537108322fbScarlsonj for (cpp = tmpdirs; *cpp != NULL; cpp++) { 1538108322fbScarlsonj (void) snprintf(tmp, sizeof (tmp), "%s%s", luroot, *cpp); 15396cfd72c6Sgjelinek if (mount_cmd == Z_MNT_SCRATCH && mkdir(tmp, 0755) != 0 && 15406cfd72c6Sgjelinek errno != EEXIST) { 1541108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", tmp); 1542108322fbScarlsonj return (B_FALSE); 1543108322fbScarlsonj } 1544d30e996aSgjelinek 1545d30e996aSgjelinek /* 1546d30e996aSgjelinek * We could set the mode for /tmp when we do the mkdir but 1547d30e996aSgjelinek * since that can be modified by the umask we will just set 1548d30e996aSgjelinek * the correct mode for /tmp now. 1549d30e996aSgjelinek */ 1550d30e996aSgjelinek if (strcmp(*cpp, "/tmp") == 0 && chmod(tmp, 01777) != 0) { 1551d30e996aSgjelinek zerror(zlogp, B_TRUE, "cannot chmod %s", tmp); 1552d30e996aSgjelinek return (B_FALSE); 1553d30e996aSgjelinek } 1554d30e996aSgjelinek 1555108322fbScarlsonj if (domount(zlogp, MNTTYPE_TMPFS, "", "swap", tmp) != 0) { 1556108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot mount swap on %s", *cpp); 1557108322fbScarlsonj return (B_FALSE); 1558108322fbScarlsonj } 1559108322fbScarlsonj } 1560108322fbScarlsonj return (B_TRUE); 1561108322fbScarlsonj } 1562108322fbScarlsonj 15639acbbeafSnn35248 typedef struct plat_gmount_cb_data { 15649acbbeafSnn35248 zlog_t *pgcd_zlogp; 15659acbbeafSnn35248 struct zone_fstab **pgcd_fs_tab; 15669acbbeafSnn35248 int *pgcd_num_fs; 15679acbbeafSnn35248 } plat_gmount_cb_data_t; 15689acbbeafSnn35248 15699acbbeafSnn35248 /* 15709acbbeafSnn35248 * plat_gmount_cb() is a callback function invoked by libbrand to iterate 15719acbbeafSnn35248 * through all global brand platform mounts. 15729acbbeafSnn35248 */ 15739acbbeafSnn35248 int 15749acbbeafSnn35248 plat_gmount_cb(void *data, const char *spec, const char *dir, 15759acbbeafSnn35248 const char *fstype, const char *opt) 15769acbbeafSnn35248 { 15779acbbeafSnn35248 plat_gmount_cb_data_t *cp = data; 15789acbbeafSnn35248 zlog_t *zlogp = cp->pgcd_zlogp; 15799acbbeafSnn35248 struct zone_fstab *fs_ptr = *cp->pgcd_fs_tab; 15809acbbeafSnn35248 int num_fs = *cp->pgcd_num_fs; 15819acbbeafSnn35248 struct zone_fstab *fsp, *tmp_ptr; 15829acbbeafSnn35248 15839acbbeafSnn35248 num_fs++; 15849acbbeafSnn35248 if ((tmp_ptr = realloc(fs_ptr, num_fs * sizeof (*tmp_ptr))) == NULL) { 15859acbbeafSnn35248 zerror(zlogp, B_TRUE, "memory allocation failed"); 15869acbbeafSnn35248 return (-1); 15879acbbeafSnn35248 } 15889acbbeafSnn35248 15899acbbeafSnn35248 fs_ptr = tmp_ptr; 15909acbbeafSnn35248 fsp = &fs_ptr[num_fs - 1]; 15919acbbeafSnn35248 15929acbbeafSnn35248 /* update the callback struct passed in */ 15939acbbeafSnn35248 *cp->pgcd_fs_tab = fs_ptr; 15949acbbeafSnn35248 *cp->pgcd_num_fs = num_fs; 15959acbbeafSnn35248 15969acbbeafSnn35248 fsp->zone_fs_raw[0] = '\0'; 15979acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_special, spec, 15989acbbeafSnn35248 sizeof (fsp->zone_fs_special)); 15999acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_dir, dir, sizeof (fsp->zone_fs_dir)); 16009acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_type, fstype, sizeof (fsp->zone_fs_type)); 16019acbbeafSnn35248 fsp->zone_fs_options = NULL; 1602fa3d7ae1Sedp if ((opt != NULL) && 1603fa3d7ae1Sedp (zonecfg_add_fs_option(fsp, (char *)opt) != Z_OK)) { 16049acbbeafSnn35248 zerror(zlogp, B_FALSE, "error adding property"); 16059acbbeafSnn35248 return (-1); 16069acbbeafSnn35248 } 16079acbbeafSnn35248 16089acbbeafSnn35248 return (0); 16099acbbeafSnn35248 } 16109acbbeafSnn35248 16119acbbeafSnn35248 static int 16129acbbeafSnn35248 mount_filesystems_ipdent(zone_dochandle_t handle, zlog_t *zlogp, 16139acbbeafSnn35248 struct zone_fstab **fs_tabp, int *num_fsp) 16149acbbeafSnn35248 { 16159acbbeafSnn35248 struct zone_fstab *tmp_ptr, *fs_ptr, *fsp, fstab; 16169acbbeafSnn35248 int num_fs; 16179acbbeafSnn35248 16189acbbeafSnn35248 num_fs = *num_fsp; 16199acbbeafSnn35248 fs_ptr = *fs_tabp; 16209acbbeafSnn35248 16219acbbeafSnn35248 if (zonecfg_setipdent(handle) != Z_OK) { 16229acbbeafSnn35248 zerror(zlogp, B_FALSE, "invalid configuration"); 16239acbbeafSnn35248 return (-1); 16249acbbeafSnn35248 } 16259acbbeafSnn35248 while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 16269acbbeafSnn35248 num_fs++; 16279acbbeafSnn35248 if ((tmp_ptr = realloc(fs_ptr, 16289acbbeafSnn35248 num_fs * sizeof (*tmp_ptr))) == NULL) { 16299acbbeafSnn35248 zerror(zlogp, B_TRUE, "memory allocation failed"); 16309acbbeafSnn35248 (void) zonecfg_endipdent(handle); 16319acbbeafSnn35248 return (-1); 16329acbbeafSnn35248 } 16339acbbeafSnn35248 16349acbbeafSnn35248 /* update the pointers passed in */ 16359acbbeafSnn35248 *fs_tabp = tmp_ptr; 16369acbbeafSnn35248 *num_fsp = num_fs; 16379acbbeafSnn35248 16389acbbeafSnn35248 /* 16399acbbeafSnn35248 * IPDs logically only have a mount point; all other properties 16409acbbeafSnn35248 * are implied. 16419acbbeafSnn35248 */ 16429acbbeafSnn35248 fs_ptr = tmp_ptr; 16439acbbeafSnn35248 fsp = &fs_ptr[num_fs - 1]; 16449acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_dir, 16459acbbeafSnn35248 fstab.zone_fs_dir, sizeof (fsp->zone_fs_dir)); 16469acbbeafSnn35248 fsp->zone_fs_special[0] = '\0'; 16479acbbeafSnn35248 fsp->zone_fs_raw[0] = '\0'; 16489acbbeafSnn35248 fsp->zone_fs_type[0] = '\0'; 16499acbbeafSnn35248 fsp->zone_fs_options = NULL; 16509acbbeafSnn35248 } 16519acbbeafSnn35248 (void) zonecfg_endipdent(handle); 16529acbbeafSnn35248 return (0); 16539acbbeafSnn35248 } 16549acbbeafSnn35248 16559acbbeafSnn35248 static int 16569acbbeafSnn35248 mount_filesystems_fsent(zone_dochandle_t handle, zlog_t *zlogp, 16576cfd72c6Sgjelinek struct zone_fstab **fs_tabp, int *num_fsp, zone_mnt_t mount_cmd) 16589acbbeafSnn35248 { 16599acbbeafSnn35248 struct zone_fstab *tmp_ptr, *fs_ptr, *fsp, fstab; 16609acbbeafSnn35248 int num_fs; 16619acbbeafSnn35248 16629acbbeafSnn35248 num_fs = *num_fsp; 16639acbbeafSnn35248 fs_ptr = *fs_tabp; 16649acbbeafSnn35248 16659acbbeafSnn35248 if (zonecfg_setfsent(handle) != Z_OK) { 16669acbbeafSnn35248 zerror(zlogp, B_FALSE, "invalid configuration"); 16679acbbeafSnn35248 return (-1); 16689acbbeafSnn35248 } 16699acbbeafSnn35248 while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 16709acbbeafSnn35248 /* 16719acbbeafSnn35248 * ZFS filesystems will not be accessible under an alternate 16729acbbeafSnn35248 * root, since the pool will not be known. Ignore them in this 16739acbbeafSnn35248 * case. 16749acbbeafSnn35248 */ 16756cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && 16766cfd72c6Sgjelinek strcmp(fstab.zone_fs_type, MNTTYPE_ZFS) == 0) 16779acbbeafSnn35248 continue; 16789acbbeafSnn35248 16799acbbeafSnn35248 num_fs++; 16809acbbeafSnn35248 if ((tmp_ptr = realloc(fs_ptr, 16819acbbeafSnn35248 num_fs * sizeof (*tmp_ptr))) == NULL) { 16829acbbeafSnn35248 zerror(zlogp, B_TRUE, "memory allocation failed"); 16839acbbeafSnn35248 (void) zonecfg_endfsent(handle); 16849acbbeafSnn35248 return (-1); 16859acbbeafSnn35248 } 16869acbbeafSnn35248 /* update the pointers passed in */ 16879acbbeafSnn35248 *fs_tabp = tmp_ptr; 16889acbbeafSnn35248 *num_fsp = num_fs; 16899acbbeafSnn35248 16909acbbeafSnn35248 fs_ptr = tmp_ptr; 16919acbbeafSnn35248 fsp = &fs_ptr[num_fs - 1]; 16929acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_dir, 16939acbbeafSnn35248 fstab.zone_fs_dir, sizeof (fsp->zone_fs_dir)); 16949acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_raw, fstab.zone_fs_raw, 16959acbbeafSnn35248 sizeof (fsp->zone_fs_raw)); 16969acbbeafSnn35248 (void) strlcpy(fsp->zone_fs_type, fstab.zone_fs_type, 16979acbbeafSnn35248 sizeof (fsp->zone_fs_type)); 16989acbbeafSnn35248 fsp->zone_fs_options = fstab.zone_fs_options; 1699fa3d7ae1Sedp 1700fa3d7ae1Sedp /* 1701fa3d7ae1Sedp * For all lofs mounts, make sure that the 'special' 1702fa3d7ae1Sedp * entry points inside the alternate root. The 1703fa3d7ae1Sedp * source path for a lofs mount in a given zone needs 1704fa3d7ae1Sedp * to be relative to the root of the boot environment 1705fa3d7ae1Sedp * that contains the zone. Note that we don't do this 1706fa3d7ae1Sedp * for non-lofs mounts since they will have a device 1707fa3d7ae1Sedp * as a backing store and device paths must always be 1708fa3d7ae1Sedp * specified relative to the current boot environment. 1709fa3d7ae1Sedp */ 1710fa3d7ae1Sedp fsp->zone_fs_special[0] = '\0'; 1711fa3d7ae1Sedp if (strcmp(fsp->zone_fs_type, MNTTYPE_LOFS) == 0) { 1712fa3d7ae1Sedp (void) strlcat(fsp->zone_fs_special, zonecfg_get_root(), 1713fa3d7ae1Sedp sizeof (fsp->zone_fs_special)); 1714fa3d7ae1Sedp } 1715fa3d7ae1Sedp (void) strlcat(fsp->zone_fs_special, fstab.zone_fs_special, 1716fa3d7ae1Sedp sizeof (fsp->zone_fs_special)); 17179acbbeafSnn35248 } 17189acbbeafSnn35248 (void) zonecfg_endfsent(handle); 17199acbbeafSnn35248 return (0); 17209acbbeafSnn35248 } 17219acbbeafSnn35248 17227c478bd9Sstevel@tonic-gate static int 17236cfd72c6Sgjelinek mount_filesystems(zlog_t *zlogp, zone_mnt_t mount_cmd) 17247c478bd9Sstevel@tonic-gate { 17257c478bd9Sstevel@tonic-gate char rootpath[MAXPATHLEN]; 17267c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 17279acbbeafSnn35248 char brand[MAXNAMELEN]; 172816bca938Svp157776 char luroot[MAXPATHLEN]; 17299acbbeafSnn35248 int i, num_fs = 0; 17309acbbeafSnn35248 struct zone_fstab *fs_ptr = NULL; 17317c478bd9Sstevel@tonic-gate zone_dochandle_t handle = NULL; 17327c478bd9Sstevel@tonic-gate zone_state_t zstate; 1733123807fbSedp brand_handle_t bh; 17349acbbeafSnn35248 plat_gmount_cb_data_t cb; 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate if (zone_get_state(zone_name, &zstate) != Z_OK || 1737108322fbScarlsonj (zstate != ZONE_STATE_READY && zstate != ZONE_STATE_MOUNTED)) { 17387c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 1739108322fbScarlsonj "zone must be in '%s' or '%s' state to mount file-systems", 1740108322fbScarlsonj zone_state_str(ZONE_STATE_READY), 1741108322fbScarlsonj zone_state_str(ZONE_STATE_MOUNTED)); 17427c478bd9Sstevel@tonic-gate goto bad; 17437c478bd9Sstevel@tonic-gate } 17447c478bd9Sstevel@tonic-gate 17457c478bd9Sstevel@tonic-gate if (zone_get_zonepath(zone_name, zonepath, sizeof (zonepath)) != Z_OK) { 17467c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to determine zone path"); 17477c478bd9Sstevel@tonic-gate goto bad; 17487c478bd9Sstevel@tonic-gate } 17497c478bd9Sstevel@tonic-gate 17507c478bd9Sstevel@tonic-gate if (zone_get_rootpath(zone_name, rootpath, sizeof (rootpath)) != Z_OK) { 17517c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to determine zone root"); 17527c478bd9Sstevel@tonic-gate goto bad; 17537c478bd9Sstevel@tonic-gate } 17547c478bd9Sstevel@tonic-gate 17557c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 1756ffbafc53Scomay zerror(zlogp, B_TRUE, "getting zone configuration handle"); 17577c478bd9Sstevel@tonic-gate goto bad; 17587c478bd9Sstevel@tonic-gate } 17597c478bd9Sstevel@tonic-gate if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK || 17607c478bd9Sstevel@tonic-gate zonecfg_setfsent(handle) != Z_OK) { 17617c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid configuration"); 17627c478bd9Sstevel@tonic-gate goto bad; 17637c478bd9Sstevel@tonic-gate } 17647c478bd9Sstevel@tonic-gate 17650679f794S /* 17660679f794S * If we are mounting the zone, then we must always use the native 17670679f794S * brand global mounts. 17680679f794S */ 17690679f794S if (ALT_MOUNT(mount_cmd)) { 17700679f794S (void) strlcpy(brand, NATIVE_BRAND_NAME, sizeof (brand)); 17710679f794S } else { 17720679f794S if (zone_get_brand(zone_name, brand, sizeof (brand)) != Z_OK) { 17730679f794S zerror(zlogp, B_FALSE, 17740679f794S "unable to determine zone brand"); 17750679f794S zonecfg_fini_handle(handle); 17760679f794S return (-1); 17770679f794S } 17780679f794S } 17790679f794S 17809acbbeafSnn35248 /* Get a handle to the brand info for this zone */ 17810679f794S if ((bh = brand_open(brand)) == NULL) { 17829acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 1783e767a340Sgjelinek zonecfg_fini_handle(handle); 17849acbbeafSnn35248 return (-1); 17859acbbeafSnn35248 } 17869acbbeafSnn35248 17879acbbeafSnn35248 /* 17889acbbeafSnn35248 * Get the list of global filesystems to mount from the brand 17899acbbeafSnn35248 * configuration. 17909acbbeafSnn35248 */ 17919acbbeafSnn35248 cb.pgcd_zlogp = zlogp; 17929acbbeafSnn35248 cb.pgcd_fs_tab = &fs_ptr; 17939acbbeafSnn35248 cb.pgcd_num_fs = &num_fs; 1794123807fbSedp if (brand_platform_iter_gmounts(bh, zonepath, 17959acbbeafSnn35248 plat_gmount_cb, &cb) != 0) { 17969acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to mount filesystems"); 1797123807fbSedp brand_close(bh); 1798e767a340Sgjelinek zonecfg_fini_handle(handle); 17999acbbeafSnn35248 return (-1); 18009acbbeafSnn35248 } 1801123807fbSedp brand_close(bh); 18029acbbeafSnn35248 18037c478bd9Sstevel@tonic-gate /* 18047c478bd9Sstevel@tonic-gate * Iterate through the rest of the filesystems, first the IPDs, then 18057c478bd9Sstevel@tonic-gate * the general FSs. Sort them all, then mount them in sorted order. 18067c478bd9Sstevel@tonic-gate * This is to make sure the higher level directories (e.g., /usr) 18077c478bd9Sstevel@tonic-gate * get mounted before any beneath them (e.g., /usr/local). 18087c478bd9Sstevel@tonic-gate */ 18099acbbeafSnn35248 if (mount_filesystems_ipdent(handle, zlogp, &fs_ptr, &num_fs) != 0) 18107c478bd9Sstevel@tonic-gate goto bad; 18117c478bd9Sstevel@tonic-gate 18129acbbeafSnn35248 if (mount_filesystems_fsent(handle, zlogp, &fs_ptr, &num_fs, 18139acbbeafSnn35248 mount_cmd) != 0) 18147c478bd9Sstevel@tonic-gate goto bad; 1815fa9e4066Sahrens 18167c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 18177c478bd9Sstevel@tonic-gate handle = NULL; 18187c478bd9Sstevel@tonic-gate 1819108322fbScarlsonj /* 18209acbbeafSnn35248 * Normally when we mount a zone all the zone filesystems 18219acbbeafSnn35248 * get mounted relative to rootpath, which is usually 18229acbbeafSnn35248 * <zonepath>/root. But when mounting a zone for administration 18239acbbeafSnn35248 * purposes via the zone "mount" state, build_mounted_pre_var() 18249acbbeafSnn35248 * updates rootpath to be <zonepath>/lu/a so we'll mount all 18259acbbeafSnn35248 * the zones filesystems there instead. 18269acbbeafSnn35248 * 18279acbbeafSnn35248 * build_mounted_pre_var() and build_mounted_post_var() will 18289acbbeafSnn35248 * also do some extra work to create directories and lofs mount 18299acbbeafSnn35248 * a bunch of global zone file system paths into <zonepath>/lu. 18309acbbeafSnn35248 * 18319acbbeafSnn35248 * This allows us to be able to enter the zone (now rooted at 18329acbbeafSnn35248 * <zonepath>/lu) and run the upgrade/patch tools that are in the 18339acbbeafSnn35248 * global zone and have them upgrade the to-be-modified zone's 18349acbbeafSnn35248 * files mounted on /a. (Which mirrors the existing standard 18359acbbeafSnn35248 * upgrade environment.) 18369acbbeafSnn35248 * 18379acbbeafSnn35248 * There is of course one catch. When doing the upgrade 18389acbbeafSnn35248 * we need <zoneroot>/lu/dev to be the /dev filesystem 18399acbbeafSnn35248 * for the zone and we don't want to have any /dev filesystem 18409acbbeafSnn35248 * mounted at <zoneroot>/lu/a/dev. Since /dev is specified 18419acbbeafSnn35248 * as a normal zone filesystem by default we'll try to mount 18429acbbeafSnn35248 * it at <zoneroot>/lu/a/dev, so we have to detect this 18439acbbeafSnn35248 * case and instead mount it at <zoneroot>/lu/dev. 18449acbbeafSnn35248 * 18459acbbeafSnn35248 * All this work is done in three phases: 1846f4368d3dSvp157776 * 1) Create and populate lu directory (build_mounted_pre_var()). 1847f4368d3dSvp157776 * 2) Mount the required filesystems as per the zone configuration. 1848f4368d3dSvp157776 * 3) Set up the rest of the scratch zone environment 1849f4368d3dSvp157776 * (build_mounted_post_var()). 1850108322fbScarlsonj */ 18516cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && !build_mounted_pre_var(zlogp, 185216bca938Svp157776 rootpath, sizeof (rootpath), zonepath, luroot, sizeof (luroot))) 1853108322fbScarlsonj goto bad; 1854108322fbScarlsonj 18557c478bd9Sstevel@tonic-gate qsort(fs_ptr, num_fs, sizeof (*fs_ptr), fs_compare); 18569acbbeafSnn35248 18577c478bd9Sstevel@tonic-gate for (i = 0; i < num_fs; i++) { 18586cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && 18599acbbeafSnn35248 strcmp(fs_ptr[i].zone_fs_dir, "/dev") == 0) { 18609acbbeafSnn35248 size_t slen = strlen(rootpath) - 2; 18619acbbeafSnn35248 18629acbbeafSnn35248 /* 18639acbbeafSnn35248 * By default we'll try to mount /dev as /a/dev 18649acbbeafSnn35248 * but /dev is special and always goes at the top 18659acbbeafSnn35248 * so strip the trailing '/a' from the rootpath. 18669acbbeafSnn35248 */ 18679acbbeafSnn35248 assert(strcmp(&rootpath[slen], "/a") == 0); 18689acbbeafSnn35248 rootpath[slen] = '\0'; 18690679f794S if (mount_one(zlogp, &fs_ptr[i], rootpath, mount_cmd) 18700679f794S != 0) 18719acbbeafSnn35248 goto bad; 18729acbbeafSnn35248 rootpath[slen] = '/'; 18739acbbeafSnn35248 continue; 18749acbbeafSnn35248 } 18750679f794S if (mount_one(zlogp, &fs_ptr[i], rootpath, mount_cmd) != 0) 18767c478bd9Sstevel@tonic-gate goto bad; 18777c478bd9Sstevel@tonic-gate } 18786cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd) && 18796cfd72c6Sgjelinek !build_mounted_post_var(zlogp, mount_cmd, rootpath, luroot)) 1880f4368d3dSvp157776 goto bad; 188145916cd2Sjpk 188245916cd2Sjpk /* 188345916cd2Sjpk * For Trusted Extensions cross-mount each lower level /export/home 188445916cd2Sjpk */ 18856cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && 18866cfd72c6Sgjelinek tsol_mounts(zlogp, zone_name, rootpath) != 0) 188745916cd2Sjpk goto bad; 188845916cd2Sjpk 18897c478bd9Sstevel@tonic-gate free_fs_data(fs_ptr, num_fs); 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate /* 18927c478bd9Sstevel@tonic-gate * Everything looks fine. 18937c478bd9Sstevel@tonic-gate */ 18947c478bd9Sstevel@tonic-gate return (0); 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate bad: 18977c478bd9Sstevel@tonic-gate if (handle != NULL) 18987c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 18997c478bd9Sstevel@tonic-gate free_fs_data(fs_ptr, num_fs); 19007c478bd9Sstevel@tonic-gate return (-1); 19017c478bd9Sstevel@tonic-gate } 19027c478bd9Sstevel@tonic-gate 19037c478bd9Sstevel@tonic-gate /* caller makes sure neither parameter is NULL */ 19047c478bd9Sstevel@tonic-gate static int 19057c478bd9Sstevel@tonic-gate addr2netmask(char *prefixstr, int maxprefixlen, uchar_t *maskstr) 19067c478bd9Sstevel@tonic-gate { 19077c478bd9Sstevel@tonic-gate int prefixlen; 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate prefixlen = atoi(prefixstr); 19107c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > maxprefixlen) 19117c478bd9Sstevel@tonic-gate return (1); 19127c478bd9Sstevel@tonic-gate while (prefixlen > 0) { 19137c478bd9Sstevel@tonic-gate if (prefixlen >= 8) { 19147c478bd9Sstevel@tonic-gate *maskstr++ = 0xFF; 19157c478bd9Sstevel@tonic-gate prefixlen -= 8; 19167c478bd9Sstevel@tonic-gate continue; 19177c478bd9Sstevel@tonic-gate } 19187c478bd9Sstevel@tonic-gate *maskstr |= 1 << (8 - prefixlen); 19197c478bd9Sstevel@tonic-gate prefixlen--; 19207c478bd9Sstevel@tonic-gate } 19217c478bd9Sstevel@tonic-gate return (0); 19227c478bd9Sstevel@tonic-gate } 19237c478bd9Sstevel@tonic-gate 19247c478bd9Sstevel@tonic-gate /* 19257c478bd9Sstevel@tonic-gate * Tear down all interfaces belonging to the given zone. This should 19267c478bd9Sstevel@tonic-gate * be called with the zone in a state other than "running", so that 19277c478bd9Sstevel@tonic-gate * interfaces can't be assigned to the zone after this returns. 19287c478bd9Sstevel@tonic-gate * 19297c478bd9Sstevel@tonic-gate * If anything goes wrong, log an error message and return an error. 19307c478bd9Sstevel@tonic-gate */ 19317c478bd9Sstevel@tonic-gate static int 1932f4b3ec61Sdh155122 unconfigure_shared_network_interfaces(zlog_t *zlogp, zoneid_t zone_id) 19337c478bd9Sstevel@tonic-gate { 19347c478bd9Sstevel@tonic-gate struct lifnum lifn; 19357c478bd9Sstevel@tonic-gate struct lifconf lifc; 19367c478bd9Sstevel@tonic-gate struct lifreq *lifrp, lifrl; 19377c478bd9Sstevel@tonic-gate int64_t lifc_flags = LIFC_NOXMIT | LIFC_ALLZONES; 19387c478bd9Sstevel@tonic-gate int num_ifs, s, i, ret_code = 0; 19397c478bd9Sstevel@tonic-gate uint_t bufsize; 19407c478bd9Sstevel@tonic-gate char *buf = NULL; 19417c478bd9Sstevel@tonic-gate 19427c478bd9Sstevel@tonic-gate if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { 19437c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "could not get socket"); 19447c478bd9Sstevel@tonic-gate ret_code = -1; 19457c478bd9Sstevel@tonic-gate goto bad; 19467c478bd9Sstevel@tonic-gate } 19477c478bd9Sstevel@tonic-gate lifn.lifn_family = AF_UNSPEC; 19487c478bd9Sstevel@tonic-gate lifn.lifn_flags = (int)lifc_flags; 19497c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFNUM, (char *)&lifn) < 0) { 19507c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 1951f4b3ec61Sdh155122 "could not determine number of network interfaces"); 19527c478bd9Sstevel@tonic-gate ret_code = -1; 19537c478bd9Sstevel@tonic-gate goto bad; 19547c478bd9Sstevel@tonic-gate } 19557c478bd9Sstevel@tonic-gate num_ifs = lifn.lifn_count; 19567c478bd9Sstevel@tonic-gate bufsize = num_ifs * sizeof (struct lifreq); 19577c478bd9Sstevel@tonic-gate if ((buf = malloc(bufsize)) == NULL) { 19587c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "memory allocation failed"); 19597c478bd9Sstevel@tonic-gate ret_code = -1; 19607c478bd9Sstevel@tonic-gate goto bad; 19617c478bd9Sstevel@tonic-gate } 19627c478bd9Sstevel@tonic-gate lifc.lifc_family = AF_UNSPEC; 19637c478bd9Sstevel@tonic-gate lifc.lifc_flags = (int)lifc_flags; 19647c478bd9Sstevel@tonic-gate lifc.lifc_len = bufsize; 19657c478bd9Sstevel@tonic-gate lifc.lifc_buf = buf; 19667c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFCONF, (char *)&lifc) < 0) { 1967f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "could not get configured network " 1968f4b3ec61Sdh155122 "interfaces"); 19697c478bd9Sstevel@tonic-gate ret_code = -1; 19707c478bd9Sstevel@tonic-gate goto bad; 19717c478bd9Sstevel@tonic-gate } 19727c478bd9Sstevel@tonic-gate lifrp = lifc.lifc_req; 19737c478bd9Sstevel@tonic-gate for (i = lifc.lifc_len / sizeof (struct lifreq); i > 0; i--, lifrp++) { 19747c478bd9Sstevel@tonic-gate (void) close(s); 19757c478bd9Sstevel@tonic-gate if ((s = socket(lifrp->lifr_addr.ss_family, SOCK_DGRAM, 0)) < 19767c478bd9Sstevel@tonic-gate 0) { 19777c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not get socket", 19787c478bd9Sstevel@tonic-gate lifrl.lifr_name); 19797c478bd9Sstevel@tonic-gate ret_code = -1; 19807c478bd9Sstevel@tonic-gate continue; 19817c478bd9Sstevel@tonic-gate } 19827c478bd9Sstevel@tonic-gate (void) memset(&lifrl, 0, sizeof (lifrl)); 19837c478bd9Sstevel@tonic-gate (void) strncpy(lifrl.lifr_name, lifrp->lifr_name, 19847c478bd9Sstevel@tonic-gate sizeof (lifrl.lifr_name)); 19857c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFZONE, (caddr_t)&lifrl) < 0) { 1986c1c0ebd5Ssl108498 if (errno == ENXIO) 1987c1c0ebd5Ssl108498 /* 1988c1c0ebd5Ssl108498 * Interface may have been removed by admin or 1989c1c0ebd5Ssl108498 * another zone halting. 1990c1c0ebd5Ssl108498 */ 1991c1c0ebd5Ssl108498 continue; 19927c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 1993c1c0ebd5Ssl108498 "%s: could not determine the zone to which this " 1994f4b3ec61Sdh155122 "network interface is bound", lifrl.lifr_name); 19957c478bd9Sstevel@tonic-gate ret_code = -1; 19967c478bd9Sstevel@tonic-gate continue; 19977c478bd9Sstevel@tonic-gate } 19987c478bd9Sstevel@tonic-gate if (lifrl.lifr_zoneid == zone_id) { 19997c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifrl) < 0) { 20007c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 2001f4b3ec61Sdh155122 "%s: could not remove network interface", 20027c478bd9Sstevel@tonic-gate lifrl.lifr_name); 20037c478bd9Sstevel@tonic-gate ret_code = -1; 20047c478bd9Sstevel@tonic-gate continue; 20057c478bd9Sstevel@tonic-gate } 20067c478bd9Sstevel@tonic-gate } 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate bad: 20097c478bd9Sstevel@tonic-gate if (s > 0) 20107c478bd9Sstevel@tonic-gate (void) close(s); 20117c478bd9Sstevel@tonic-gate if (buf) 20127c478bd9Sstevel@tonic-gate free(buf); 20137c478bd9Sstevel@tonic-gate return (ret_code); 20147c478bd9Sstevel@tonic-gate } 20157c478bd9Sstevel@tonic-gate 20167c478bd9Sstevel@tonic-gate static union sockunion { 20177c478bd9Sstevel@tonic-gate struct sockaddr sa; 20187c478bd9Sstevel@tonic-gate struct sockaddr_in sin; 20197c478bd9Sstevel@tonic-gate struct sockaddr_dl sdl; 20207c478bd9Sstevel@tonic-gate struct sockaddr_in6 sin6; 20217c478bd9Sstevel@tonic-gate } so_dst, so_ifp; 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate static struct { 20247c478bd9Sstevel@tonic-gate struct rt_msghdr hdr; 20257c478bd9Sstevel@tonic-gate char space[512]; 20267c478bd9Sstevel@tonic-gate } rtmsg; 20277c478bd9Sstevel@tonic-gate 20287c478bd9Sstevel@tonic-gate static int 20297c478bd9Sstevel@tonic-gate salen(struct sockaddr *sa) 20307c478bd9Sstevel@tonic-gate { 20317c478bd9Sstevel@tonic-gate switch (sa->sa_family) { 20327c478bd9Sstevel@tonic-gate case AF_INET: 20337c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr_in)); 20347c478bd9Sstevel@tonic-gate case AF_LINK: 20357c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr_dl)); 20367c478bd9Sstevel@tonic-gate case AF_INET6: 20377c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr_in6)); 20387c478bd9Sstevel@tonic-gate default: 20397c478bd9Sstevel@tonic-gate return (sizeof (struct sockaddr)); 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate } 20427c478bd9Sstevel@tonic-gate 20437c478bd9Sstevel@tonic-gate #define ROUNDUP_LONG(a) \ 20447c478bd9Sstevel@tonic-gate ((a) > 0 ? (1 + (((a) - 1) | (sizeof (long) - 1))) : sizeof (long)) 20457c478bd9Sstevel@tonic-gate 20467c478bd9Sstevel@tonic-gate /* 20477c478bd9Sstevel@tonic-gate * Look up which zone is using a given IP address. The address in question 20487c478bd9Sstevel@tonic-gate * is expected to have been stuffed into the structure to which lifr points 20497c478bd9Sstevel@tonic-gate * via a previous SIOCGLIFADDR ioctl(). 20507c478bd9Sstevel@tonic-gate * 20517c478bd9Sstevel@tonic-gate * This is done using black router socket magic. 20527c478bd9Sstevel@tonic-gate * 20537c478bd9Sstevel@tonic-gate * Return the name of the zone on success or NULL on failure. 20547c478bd9Sstevel@tonic-gate * 20557c478bd9Sstevel@tonic-gate * This is a lot of code for a simple task; a new ioctl request to take care 20567c478bd9Sstevel@tonic-gate * of this might be a useful RFE. 20577c478bd9Sstevel@tonic-gate */ 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate static char * 20607c478bd9Sstevel@tonic-gate who_is_using(zlog_t *zlogp, struct lifreq *lifr) 20617c478bd9Sstevel@tonic-gate { 20627c478bd9Sstevel@tonic-gate static char answer[ZONENAME_MAX]; 20637c478bd9Sstevel@tonic-gate pid_t pid; 20647c478bd9Sstevel@tonic-gate int s, rlen, l, i; 20657c478bd9Sstevel@tonic-gate char *cp = rtmsg.space; 20667c478bd9Sstevel@tonic-gate struct sockaddr_dl *ifp = NULL; 20677c478bd9Sstevel@tonic-gate struct sockaddr *sa; 20687c478bd9Sstevel@tonic-gate char save_if_name[LIFNAMSIZ]; 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate answer[0] = '\0'; 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate pid = getpid(); 20737c478bd9Sstevel@tonic-gate if ((s = socket(PF_ROUTE, SOCK_RAW, 0)) < 0) { 20747c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "could not get routing socket"); 20757c478bd9Sstevel@tonic-gate return (NULL); 20767c478bd9Sstevel@tonic-gate } 20777c478bd9Sstevel@tonic-gate 20787c478bd9Sstevel@tonic-gate if (lifr->lifr_addr.ss_family == AF_INET) { 20797c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 20807c478bd9Sstevel@tonic-gate 20817c478bd9Sstevel@tonic-gate so_dst.sa.sa_family = AF_INET; 20827c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)&lifr->lifr_addr; 20837c478bd9Sstevel@tonic-gate so_dst.sin.sin_addr = sin4->sin_addr; 20847c478bd9Sstevel@tonic-gate } else { 20857c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate so_dst.sa.sa_family = AF_INET6; 20887c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)&lifr->lifr_addr; 20897c478bd9Sstevel@tonic-gate so_dst.sin6.sin6_addr = sin6->sin6_addr; 20907c478bd9Sstevel@tonic-gate } 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate so_ifp.sa.sa_family = AF_LINK; 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate (void) memset(&rtmsg, 0, sizeof (rtmsg)); 20957c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_type = RTM_GET; 20967c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_flags = RTF_UP | RTF_HOST; 20977c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_version = RTM_VERSION; 20987c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_seq = ++rts_seqno; 20997c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_addrs = RTA_IFP | RTA_DST; 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate l = ROUNDUP_LONG(salen(&so_dst.sa)); 21027c478bd9Sstevel@tonic-gate (void) memmove(cp, &(so_dst), l); 21037c478bd9Sstevel@tonic-gate cp += l; 21047c478bd9Sstevel@tonic-gate l = ROUNDUP_LONG(salen(&so_ifp.sa)); 21057c478bd9Sstevel@tonic-gate (void) memmove(cp, &(so_ifp), l); 21067c478bd9Sstevel@tonic-gate cp += l; 21077c478bd9Sstevel@tonic-gate 21087c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_msglen = l = cp - (char *)&rtmsg; 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate if ((rlen = write(s, &rtmsg, l)) < 0) { 21117c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "writing to routing socket"); 21127c478bd9Sstevel@tonic-gate return (NULL); 21137c478bd9Sstevel@tonic-gate } else if (rlen < (int)rtmsg.hdr.rtm_msglen) { 21147c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 21157c478bd9Sstevel@tonic-gate "write to routing socket got only %d for len\n", rlen); 21167c478bd9Sstevel@tonic-gate return (NULL); 21177c478bd9Sstevel@tonic-gate } 21187c478bd9Sstevel@tonic-gate do { 21197c478bd9Sstevel@tonic-gate l = read(s, &rtmsg, sizeof (rtmsg)); 21207c478bd9Sstevel@tonic-gate } while (l > 0 && (rtmsg.hdr.rtm_seq != rts_seqno || 21217c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_pid != pid)); 21227c478bd9Sstevel@tonic-gate if (l < 0) { 21237c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "reading from routing socket"); 21247c478bd9Sstevel@tonic-gate return (NULL); 21257c478bd9Sstevel@tonic-gate } 21267c478bd9Sstevel@tonic-gate 21277c478bd9Sstevel@tonic-gate if (rtmsg.hdr.rtm_version != RTM_VERSION) { 21287c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 21297c478bd9Sstevel@tonic-gate "routing message version %d not understood", 21307c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_version); 21317c478bd9Sstevel@tonic-gate return (NULL); 21327c478bd9Sstevel@tonic-gate } 21337c478bd9Sstevel@tonic-gate if (rtmsg.hdr.rtm_msglen != (ushort_t)l) { 21347c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "message length mismatch, " 21357c478bd9Sstevel@tonic-gate "expected %d bytes, returned %d bytes", 21367c478bd9Sstevel@tonic-gate rtmsg.hdr.rtm_msglen, l); 21377c478bd9Sstevel@tonic-gate return (NULL); 21387c478bd9Sstevel@tonic-gate } 21397c478bd9Sstevel@tonic-gate if (rtmsg.hdr.rtm_errno != 0) { 21407c478bd9Sstevel@tonic-gate errno = rtmsg.hdr.rtm_errno; 21417c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "RTM_GET routing socket message"); 21427c478bd9Sstevel@tonic-gate return (NULL); 21437c478bd9Sstevel@tonic-gate } 21447c478bd9Sstevel@tonic-gate if ((rtmsg.hdr.rtm_addrs & RTA_IFP) == 0) { 2145f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "network interface not found"); 21467c478bd9Sstevel@tonic-gate return (NULL); 21477c478bd9Sstevel@tonic-gate } 21487c478bd9Sstevel@tonic-gate cp = ((char *)(&rtmsg.hdr + 1)); 21497c478bd9Sstevel@tonic-gate for (i = 1; i != 0; i <<= 1) { 21507c478bd9Sstevel@tonic-gate /* LINTED E_BAD_PTR_CAST_ALIGN */ 21517c478bd9Sstevel@tonic-gate sa = (struct sockaddr *)cp; 21527c478bd9Sstevel@tonic-gate if (i != RTA_IFP) { 21537c478bd9Sstevel@tonic-gate if ((i & rtmsg.hdr.rtm_addrs) != 0) 21547c478bd9Sstevel@tonic-gate cp += ROUNDUP_LONG(salen(sa)); 21557c478bd9Sstevel@tonic-gate continue; 21567c478bd9Sstevel@tonic-gate } 21577c478bd9Sstevel@tonic-gate if (sa->sa_family == AF_LINK && 21587c478bd9Sstevel@tonic-gate ((struct sockaddr_dl *)sa)->sdl_nlen != 0) 21597c478bd9Sstevel@tonic-gate ifp = (struct sockaddr_dl *)sa; 21607c478bd9Sstevel@tonic-gate break; 21617c478bd9Sstevel@tonic-gate } 21627c478bd9Sstevel@tonic-gate if (ifp == NULL) { 2163f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "network interface could not be " 2164f4b3ec61Sdh155122 "determined"); 21657c478bd9Sstevel@tonic-gate return (NULL); 21667c478bd9Sstevel@tonic-gate } 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate /* 21697c478bd9Sstevel@tonic-gate * We need to set the I/F name to what we got above, then do the 21707c478bd9Sstevel@tonic-gate * appropriate ioctl to get its zone name. But lifr->lifr_name is 21717c478bd9Sstevel@tonic-gate * used by the calling function to do a REMOVEIF, so if we leave the 21727c478bd9Sstevel@tonic-gate * "good" zone's I/F name in place, *that* I/F will be removed instead 21737c478bd9Sstevel@tonic-gate * of the bad one. So we save the old (bad) I/F name before over- 21747c478bd9Sstevel@tonic-gate * writing it and doing the ioctl, then restore it after the ioctl. 21757c478bd9Sstevel@tonic-gate */ 21767c478bd9Sstevel@tonic-gate (void) strlcpy(save_if_name, lifr->lifr_name, sizeof (save_if_name)); 21777c478bd9Sstevel@tonic-gate (void) strncpy(lifr->lifr_name, ifp->sdl_data, ifp->sdl_nlen); 21787c478bd9Sstevel@tonic-gate lifr->lifr_name[ifp->sdl_nlen] = '\0'; 21797c478bd9Sstevel@tonic-gate i = ioctl(s, SIOCGLIFZONE, lifr); 21807c478bd9Sstevel@tonic-gate (void) strlcpy(lifr->lifr_name, save_if_name, sizeof (save_if_name)); 21817c478bd9Sstevel@tonic-gate if (i < 0) { 21827c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 2183f4b3ec61Sdh155122 "%s: could not determine the zone network interface " 2184f4b3ec61Sdh155122 "belongs to", lifr->lifr_name); 21857c478bd9Sstevel@tonic-gate return (NULL); 21867c478bd9Sstevel@tonic-gate } 21877c478bd9Sstevel@tonic-gate if (getzonenamebyid(lifr->lifr_zoneid, answer, sizeof (answer)) < 0) 21887c478bd9Sstevel@tonic-gate (void) snprintf(answer, sizeof (answer), "%d", 21897c478bd9Sstevel@tonic-gate lifr->lifr_zoneid); 21907c478bd9Sstevel@tonic-gate 21917c478bd9Sstevel@tonic-gate if (strlen(answer) > 0) 21927c478bd9Sstevel@tonic-gate return (answer); 21937c478bd9Sstevel@tonic-gate return (NULL); 21947c478bd9Sstevel@tonic-gate } 21957c478bd9Sstevel@tonic-gate 21967c478bd9Sstevel@tonic-gate /* 21977c478bd9Sstevel@tonic-gate * Configures a single interface: a new virtual interface is added, based on 21987c478bd9Sstevel@tonic-gate * the physical interface nwiftabptr->zone_nwif_physical, with the address 21997c478bd9Sstevel@tonic-gate * specified in nwiftabptr->zone_nwif_address, for zone zone_id. Note that 22007c478bd9Sstevel@tonic-gate * the "address" can be an IPv6 address (with a /prefixlength required), an 22017c478bd9Sstevel@tonic-gate * IPv4 address (with a /prefixlength optional), or a name; for the latter, 22027c478bd9Sstevel@tonic-gate * an IPv4 name-to-address resolution will be attempted. 22037c478bd9Sstevel@tonic-gate * 22047c478bd9Sstevel@tonic-gate * If anything goes wrong, we log an detailed error message, attempt to tear 22057c478bd9Sstevel@tonic-gate * down whatever we set up and return an error. 22067c478bd9Sstevel@tonic-gate */ 22077c478bd9Sstevel@tonic-gate static int 22087c478bd9Sstevel@tonic-gate configure_one_interface(zlog_t *zlogp, zoneid_t zone_id, 2209f14f3ae7Sjv227347 struct zone_nwiftab *nwiftabptr) 22107c478bd9Sstevel@tonic-gate { 22117c478bd9Sstevel@tonic-gate struct lifreq lifr; 22127c478bd9Sstevel@tonic-gate struct sockaddr_in netmask4; 22137c478bd9Sstevel@tonic-gate struct sockaddr_in6 netmask6; 22147c478bd9Sstevel@tonic-gate struct in_addr in4; 22157c478bd9Sstevel@tonic-gate sa_family_t af; 22167c478bd9Sstevel@tonic-gate char *slashp = strchr(nwiftabptr->zone_nwif_address, '/'); 22177c478bd9Sstevel@tonic-gate int s; 22187c478bd9Sstevel@tonic-gate boolean_t got_netmask = B_FALSE; 2219*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India boolean_t is_loopback = B_FALSE; 22207c478bd9Sstevel@tonic-gate char addrstr4[INET_ADDRSTRLEN]; 22217c478bd9Sstevel@tonic-gate int res; 22227c478bd9Sstevel@tonic-gate 22237c478bd9Sstevel@tonic-gate res = zonecfg_valid_net_address(nwiftabptr->zone_nwif_address, &lifr); 22247c478bd9Sstevel@tonic-gate if (res != Z_OK) { 22257c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s: %s", zonecfg_strerror(res), 22267c478bd9Sstevel@tonic-gate nwiftabptr->zone_nwif_address); 22277c478bd9Sstevel@tonic-gate return (-1); 22287c478bd9Sstevel@tonic-gate } 22297c478bd9Sstevel@tonic-gate af = lifr.lifr_addr.ss_family; 22307c478bd9Sstevel@tonic-gate if (af == AF_INET) 22317c478bd9Sstevel@tonic-gate in4 = ((struct sockaddr_in *)(&lifr.lifr_addr))->sin_addr; 22327c478bd9Sstevel@tonic-gate if ((s = socket(af, SOCK_DGRAM, 0)) < 0) { 22337c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "could not get socket"); 22347c478bd9Sstevel@tonic-gate return (-1); 22357c478bd9Sstevel@tonic-gate } 22367c478bd9Sstevel@tonic-gate 22377c478bd9Sstevel@tonic-gate (void) strlcpy(lifr.lifr_name, nwiftabptr->zone_nwif_physical, 22387c478bd9Sstevel@tonic-gate sizeof (lifr.lifr_name)); 22397c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCLIFADDIF, (caddr_t)&lifr) < 0) { 224022321485Svp157776 /* 224122321485Svp157776 * Here, we know that the interface can't be brought up. 224222321485Svp157776 * A similar warning message was already printed out to 224322321485Svp157776 * the console by zoneadm(1M) so instead we log the 224422321485Svp157776 * message to syslog and continue. 224522321485Svp157776 */ 2246f4b3ec61Sdh155122 zerror(&logsys, B_TRUE, "WARNING: skipping network interface " 224722321485Svp157776 "'%s' which may not be present/plumbed in the " 224822321485Svp157776 "global zone.", lifr.lifr_name); 22497c478bd9Sstevel@tonic-gate (void) close(s); 225022321485Svp157776 return (Z_OK); 22517c478bd9Sstevel@tonic-gate } 22527c478bd9Sstevel@tonic-gate 22537c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0) { 22547c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 22557c478bd9Sstevel@tonic-gate "%s: could not set IP address to %s", 22567c478bd9Sstevel@tonic-gate lifr.lifr_name, nwiftabptr->zone_nwif_address); 22577c478bd9Sstevel@tonic-gate goto bad; 22587c478bd9Sstevel@tonic-gate } 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate /* Preserve literal IPv4 address for later potential printing. */ 22617c478bd9Sstevel@tonic-gate if (af == AF_INET) 22627c478bd9Sstevel@tonic-gate (void) inet_ntop(AF_INET, &in4, addrstr4, INET_ADDRSTRLEN); 22637c478bd9Sstevel@tonic-gate 22647c478bd9Sstevel@tonic-gate lifr.lifr_zoneid = zone_id; 22657c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCSLIFZONE, (caddr_t)&lifr) < 0) { 2266f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "%s: could not place network interface " 2267f4b3ec61Sdh155122 "into zone", lifr.lifr_name); 22687c478bd9Sstevel@tonic-gate goto bad; 22697c478bd9Sstevel@tonic-gate } 22707c478bd9Sstevel@tonic-gate 2271*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India /* 2272*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India * Loopback interface will use the default netmask assigned, if no 2273*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India * netmask is found. 2274*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India */ 22757c478bd9Sstevel@tonic-gate if (strcmp(nwiftabptr->zone_nwif_physical, "lo0") == 0) { 2276*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India is_loopback = B_TRUE; 2277*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India } 22787c478bd9Sstevel@tonic-gate if (af == AF_INET) { 22797c478bd9Sstevel@tonic-gate /* 22807c478bd9Sstevel@tonic-gate * The IPv4 netmask can be determined either 22817c478bd9Sstevel@tonic-gate * directly if a prefix length was supplied with 22827c478bd9Sstevel@tonic-gate * the address or via the netmasks database. Not 22837c478bd9Sstevel@tonic-gate * being able to determine it is a common failure, 22847c478bd9Sstevel@tonic-gate * but it often is not fatal to operation of the 22857c478bd9Sstevel@tonic-gate * interface. In that case, a warning will be 22867c478bd9Sstevel@tonic-gate * printed after the rest of the interface's 22877c478bd9Sstevel@tonic-gate * parameters have been configured. 22887c478bd9Sstevel@tonic-gate */ 22897c478bd9Sstevel@tonic-gate (void) memset(&netmask4, 0, sizeof (netmask4)); 22907c478bd9Sstevel@tonic-gate if (slashp != NULL) { 22917c478bd9Sstevel@tonic-gate if (addr2netmask(slashp + 1, V4_ADDR_LEN, 22927c478bd9Sstevel@tonic-gate (uchar_t *)&netmask4.sin_addr) != 0) { 22937c478bd9Sstevel@tonic-gate *slashp = '/'; 22947c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 22957c478bd9Sstevel@tonic-gate "%s: invalid prefix length in %s", 22967c478bd9Sstevel@tonic-gate lifr.lifr_name, 22977c478bd9Sstevel@tonic-gate nwiftabptr->zone_nwif_address); 22987c478bd9Sstevel@tonic-gate goto bad; 22997c478bd9Sstevel@tonic-gate } 23007c478bd9Sstevel@tonic-gate got_netmask = B_TRUE; 23017c478bd9Sstevel@tonic-gate } else if (getnetmaskbyaddr(in4, 23027c478bd9Sstevel@tonic-gate &netmask4.sin_addr) == 0) { 23037c478bd9Sstevel@tonic-gate got_netmask = B_TRUE; 23047c478bd9Sstevel@tonic-gate } 23057c478bd9Sstevel@tonic-gate if (got_netmask) { 23067c478bd9Sstevel@tonic-gate netmask4.sin_family = af; 23077c478bd9Sstevel@tonic-gate (void) memcpy(&lifr.lifr_addr, &netmask4, 23087c478bd9Sstevel@tonic-gate sizeof (netmask4)); 23097c478bd9Sstevel@tonic-gate } 23107c478bd9Sstevel@tonic-gate } else { 23117c478bd9Sstevel@tonic-gate (void) memset(&netmask6, 0, sizeof (netmask6)); 23127c478bd9Sstevel@tonic-gate if (addr2netmask(slashp + 1, V6_ADDR_LEN, 23137c478bd9Sstevel@tonic-gate (uchar_t *)&netmask6.sin6_addr) != 0) { 23147c478bd9Sstevel@tonic-gate *slashp = '/'; 23157c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 23167c478bd9Sstevel@tonic-gate "%s: invalid prefix length in %s", 23177c478bd9Sstevel@tonic-gate lifr.lifr_name, 23187c478bd9Sstevel@tonic-gate nwiftabptr->zone_nwif_address); 23197c478bd9Sstevel@tonic-gate goto bad; 23207c478bd9Sstevel@tonic-gate } 23217c478bd9Sstevel@tonic-gate got_netmask = B_TRUE; 23227c478bd9Sstevel@tonic-gate netmask6.sin6_family = af; 23237c478bd9Sstevel@tonic-gate (void) memcpy(&lifr.lifr_addr, &netmask6, 23247c478bd9Sstevel@tonic-gate sizeof (netmask6)); 23257c478bd9Sstevel@tonic-gate } 23267c478bd9Sstevel@tonic-gate if (got_netmask && 23277c478bd9Sstevel@tonic-gate ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0) { 23287c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not set netmask", 23297c478bd9Sstevel@tonic-gate lifr.lifr_name); 23307c478bd9Sstevel@tonic-gate goto bad; 23317c478bd9Sstevel@tonic-gate } 23327c478bd9Sstevel@tonic-gate 23337c478bd9Sstevel@tonic-gate /* 23347c478bd9Sstevel@tonic-gate * This doesn't set the broadcast address at all. Rather, it 23357c478bd9Sstevel@tonic-gate * gets, then sets the interface's address, relying on the fact 23367c478bd9Sstevel@tonic-gate * that resetting the address will reset the broadcast address. 23377c478bd9Sstevel@tonic-gate */ 23387c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) { 23397c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not get address", 23407c478bd9Sstevel@tonic-gate lifr.lifr_name); 23417c478bd9Sstevel@tonic-gate goto bad; 23427c478bd9Sstevel@tonic-gate } 23437c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0) { 23447c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 23457c478bd9Sstevel@tonic-gate "%s: could not reset broadcast address", 23467c478bd9Sstevel@tonic-gate lifr.lifr_name); 23477c478bd9Sstevel@tonic-gate goto bad; 23487c478bd9Sstevel@tonic-gate } 23497c478bd9Sstevel@tonic-gate 23507c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) { 23517c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not get flags", 23527c478bd9Sstevel@tonic-gate lifr.lifr_name); 23537c478bd9Sstevel@tonic-gate goto bad; 23547c478bd9Sstevel@tonic-gate } 23557c478bd9Sstevel@tonic-gate lifr.lifr_flags |= IFF_UP; 23567c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0) { 23577c478bd9Sstevel@tonic-gate int save_errno = errno; 23587c478bd9Sstevel@tonic-gate char *zone_using; 23597c478bd9Sstevel@tonic-gate 23607c478bd9Sstevel@tonic-gate /* 23617c478bd9Sstevel@tonic-gate * If we failed with something other than EADDRNOTAVAIL, 23627c478bd9Sstevel@tonic-gate * then skip to the end. Otherwise, look up our address, 23637c478bd9Sstevel@tonic-gate * then call a function to determine which zone is already 23647c478bd9Sstevel@tonic-gate * using that address. 23657c478bd9Sstevel@tonic-gate */ 23667c478bd9Sstevel@tonic-gate if (errno != EADDRNOTAVAIL) { 23677c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 2368f4b3ec61Sdh155122 "%s: could not bring network interface up", 2369f4b3ec61Sdh155122 lifr.lifr_name); 23707c478bd9Sstevel@tonic-gate goto bad; 23717c478bd9Sstevel@tonic-gate } 23727c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) { 23737c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s: could not get address", 23747c478bd9Sstevel@tonic-gate lifr.lifr_name); 23757c478bd9Sstevel@tonic-gate goto bad; 23767c478bd9Sstevel@tonic-gate } 23777c478bd9Sstevel@tonic-gate zone_using = who_is_using(zlogp, &lifr); 23787c478bd9Sstevel@tonic-gate errno = save_errno; 23797c478bd9Sstevel@tonic-gate if (zone_using == NULL) 23807c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, 2381f4b3ec61Sdh155122 "%s: could not bring network interface up", 2382f4b3ec61Sdh155122 lifr.lifr_name); 23837c478bd9Sstevel@tonic-gate else 2384f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "%s: could not bring network " 2385f4b3ec61Sdh155122 "interface up: address in use by zone '%s'", 2386f4b3ec61Sdh155122 lifr.lifr_name, zone_using); 23877c478bd9Sstevel@tonic-gate goto bad; 23887c478bd9Sstevel@tonic-gate } 23897c478bd9Sstevel@tonic-gate 2390*f9329705Ssaurabh vyas - Sun Microsystems - Bangalore India if (!got_netmask && !is_loopback) { 23917c478bd9Sstevel@tonic-gate /* 23927c478bd9Sstevel@tonic-gate * A common, but often non-fatal problem, is that the system 23937c478bd9Sstevel@tonic-gate * cannot find the netmask for an interface address. This is 23947c478bd9Sstevel@tonic-gate * often caused by it being only in /etc/inet/netmasks, but 23957c478bd9Sstevel@tonic-gate * /etc/nsswitch.conf says to use NIS or NIS+ and it's not 23967c478bd9Sstevel@tonic-gate * in that. This doesn't show up at boot because the netmask 23977c478bd9Sstevel@tonic-gate * is obtained from /etc/inet/netmasks when no network 23987c478bd9Sstevel@tonic-gate * interfaces are up, but isn't consulted when NIS/NIS+ is 23997c478bd9Sstevel@tonic-gate * available. We warn the user here that something like this 24007c478bd9Sstevel@tonic-gate * has happened and we're just running with a default and 24017c478bd9Sstevel@tonic-gate * possible incorrect netmask. 24027c478bd9Sstevel@tonic-gate */ 24037c478bd9Sstevel@tonic-gate char buffer[INET6_ADDRSTRLEN]; 24047c478bd9Sstevel@tonic-gate void *addr; 2405e11c3f44Smeem const char *nomatch = "no matching subnet found in netmasks(4)"; 24067c478bd9Sstevel@tonic-gate 24077c478bd9Sstevel@tonic-gate if (af == AF_INET) 24087c478bd9Sstevel@tonic-gate addr = &((struct sockaddr_in *) 24097c478bd9Sstevel@tonic-gate (&lifr.lifr_addr))->sin_addr; 24107c478bd9Sstevel@tonic-gate else 24117c478bd9Sstevel@tonic-gate addr = &((struct sockaddr_in6 *) 24127c478bd9Sstevel@tonic-gate (&lifr.lifr_addr))->sin6_addr; 24137c478bd9Sstevel@tonic-gate 2414e11c3f44Smeem /* 2415e11c3f44Smeem * Find out what netmask the interface is going to be using. 2416e11c3f44Smeem * If we just brought up an IPMP data address on an underlying 2417e11c3f44Smeem * interface above, the address will have already migrated, so 2418e11c3f44Smeem * the SIOCGLIFNETMASK won't be able to find it (but we need 2419e11c3f44Smeem * to bring the address up to get the actual netmask). Just 2420e11c3f44Smeem * omit printing the actual netmask in this corner-case. 2421e11c3f44Smeem */ 24227c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFNETMASK, (caddr_t)&lifr) < 0 || 2423e11c3f44Smeem inet_ntop(af, addr, buffer, sizeof (buffer)) == NULL) { 2424e11c3f44Smeem zerror(zlogp, B_FALSE, "WARNING: %s; using default.", 2425e11c3f44Smeem nomatch); 2426e11c3f44Smeem } else { 24277c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 2428e11c3f44Smeem "WARNING: %s: %s: %s; using default of %s.", 2429e11c3f44Smeem lifr.lifr_name, nomatch, addrstr4, buffer); 2430e11c3f44Smeem } 24317c478bd9Sstevel@tonic-gate } 24327c478bd9Sstevel@tonic-gate 2433de860bd9Sgfaden /* 2434de860bd9Sgfaden * If a default router was specified for this interface 2435de860bd9Sgfaden * set the route now. Ignore if already set. 2436de860bd9Sgfaden */ 2437de860bd9Sgfaden if (strlen(nwiftabptr->zone_nwif_defrouter) > 0) { 2438de860bd9Sgfaden int status; 2439de860bd9Sgfaden char *argv[7]; 2440de860bd9Sgfaden 2441de860bd9Sgfaden argv[0] = "route"; 2442de860bd9Sgfaden argv[1] = "add"; 2443de860bd9Sgfaden argv[2] = "-ifp"; 2444de860bd9Sgfaden argv[3] = nwiftabptr->zone_nwif_physical; 2445de860bd9Sgfaden argv[4] = "default"; 2446de860bd9Sgfaden argv[5] = nwiftabptr->zone_nwif_defrouter; 2447de860bd9Sgfaden argv[6] = NULL; 2448de860bd9Sgfaden 2449de860bd9Sgfaden status = forkexec(zlogp, "/usr/sbin/route", argv); 2450de860bd9Sgfaden if (status != 0 && status != EEXIST) 2451de860bd9Sgfaden zerror(zlogp, B_FALSE, "Unable to set route for " 2452de860bd9Sgfaden "interface %s to %s\n", 2453de860bd9Sgfaden nwiftabptr->zone_nwif_physical, 2454de860bd9Sgfaden nwiftabptr->zone_nwif_defrouter); 2455de860bd9Sgfaden } 2456de860bd9Sgfaden 24577c478bd9Sstevel@tonic-gate (void) close(s); 24587c478bd9Sstevel@tonic-gate return (Z_OK); 24597c478bd9Sstevel@tonic-gate bad: 24607c478bd9Sstevel@tonic-gate (void) ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifr); 24617c478bd9Sstevel@tonic-gate (void) close(s); 24627c478bd9Sstevel@tonic-gate return (-1); 24637c478bd9Sstevel@tonic-gate } 24647c478bd9Sstevel@tonic-gate 24657c478bd9Sstevel@tonic-gate /* 24667c478bd9Sstevel@tonic-gate * Sets up network interfaces based on information from the zone configuration. 2467f14f3ae7Sjv227347 * IPv4 and IPv6 loopback interfaces are set up "for free", modeling the global 2468f14f3ae7Sjv227347 * system. 24697c478bd9Sstevel@tonic-gate * 24707c478bd9Sstevel@tonic-gate * If anything goes wrong, we log a general error message, attempt to tear down 24717c478bd9Sstevel@tonic-gate * whatever we set up, and return an error. 24727c478bd9Sstevel@tonic-gate */ 24737c478bd9Sstevel@tonic-gate static int 2474f4b3ec61Sdh155122 configure_shared_network_interfaces(zlog_t *zlogp) 24757c478bd9Sstevel@tonic-gate { 24767c478bd9Sstevel@tonic-gate zone_dochandle_t handle; 24777c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab, loopback_iftab; 24787c478bd9Sstevel@tonic-gate zoneid_t zoneid; 24797c478bd9Sstevel@tonic-gate 24807c478bd9Sstevel@tonic-gate if ((zoneid = getzoneidbyname(zone_name)) == ZONE_ID_UNDEFINED) { 24817c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to get zoneid"); 24827c478bd9Sstevel@tonic-gate return (-1); 24837c478bd9Sstevel@tonic-gate } 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 24867c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "getting zone configuration handle"); 24877c478bd9Sstevel@tonic-gate return (-1); 24887c478bd9Sstevel@tonic-gate } 24897c478bd9Sstevel@tonic-gate if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 24907c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid configuration"); 24917c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 24927c478bd9Sstevel@tonic-gate return (-1); 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) == Z_OK) { 24957c478bd9Sstevel@tonic-gate for (;;) { 24967c478bd9Sstevel@tonic-gate if (zonecfg_getnwifent(handle, &nwiftab) != Z_OK) 24977c478bd9Sstevel@tonic-gate break; 2498f14f3ae7Sjv227347 if (configure_one_interface(zlogp, zoneid, &nwiftab) != 24997c478bd9Sstevel@tonic-gate Z_OK) { 25007c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 25017c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 25027c478bd9Sstevel@tonic-gate return (-1); 25037c478bd9Sstevel@tonic-gate } 25047c478bd9Sstevel@tonic-gate } 25057c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 25067c478bd9Sstevel@tonic-gate } 25077c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 2508fdb7141fSgfaden if (is_system_labeled()) { 2509fdb7141fSgfaden /* 2510fdb7141fSgfaden * Labeled zones share the loopback interface 2511fdb7141fSgfaden * so it is not plumbed for shared stack instances. 2512fdb7141fSgfaden */ 2513fdb7141fSgfaden return (0); 2514fdb7141fSgfaden } 25157c478bd9Sstevel@tonic-gate (void) strlcpy(loopback_iftab.zone_nwif_physical, "lo0", 25167c478bd9Sstevel@tonic-gate sizeof (loopback_iftab.zone_nwif_physical)); 25177c478bd9Sstevel@tonic-gate (void) strlcpy(loopback_iftab.zone_nwif_address, "127.0.0.1", 25187c478bd9Sstevel@tonic-gate sizeof (loopback_iftab.zone_nwif_address)); 2519442d3e9eSgfaden loopback_iftab.zone_nwif_defrouter[0] = '\0'; 2520f14f3ae7Sjv227347 if (configure_one_interface(zlogp, zoneid, &loopback_iftab) != Z_OK) 25217c478bd9Sstevel@tonic-gate return (-1); 2522f14f3ae7Sjv227347 2523f14f3ae7Sjv227347 /* Always plumb up the IPv6 loopback interface. */ 25247c478bd9Sstevel@tonic-gate (void) strlcpy(loopback_iftab.zone_nwif_address, "::1/128", 25257c478bd9Sstevel@tonic-gate sizeof (loopback_iftab.zone_nwif_address)); 2526f14f3ae7Sjv227347 if (configure_one_interface(zlogp, zoneid, &loopback_iftab) != Z_OK) 25277c478bd9Sstevel@tonic-gate return (-1); 25287c478bd9Sstevel@tonic-gate return (0); 25297c478bd9Sstevel@tonic-gate } 25307c478bd9Sstevel@tonic-gate 253189b1c373Smeem static void 253289b1c373Smeem zdlerror(zlog_t *zlogp, dladm_status_t err, const char *dlname, const char *str) 253389b1c373Smeem { 253489b1c373Smeem char errmsg[DLADM_STRSIZE]; 253589b1c373Smeem 253689b1c373Smeem (void) dladm_status2str(err, errmsg); 253789b1c373Smeem zerror(zlogp, B_FALSE, "%s '%s': %s", str, dlname, errmsg); 253889b1c373Smeem } 253989b1c373Smeem 2540f4b3ec61Sdh155122 static int 25413bc21d0aSAruna Ramakrishna - Sun Microsystems add_datalink(zlog_t *zlogp, char *zone_name, char *dlname) 2542f4b3ec61Sdh155122 { 254389b1c373Smeem dladm_status_t err; 254489b1c373Smeem 2545f4b3ec61Sdh155122 /* First check if it's in use by global zone. */ 2546f4b3ec61Sdh155122 if (zonecfg_ifname_exists(AF_INET, dlname) || 2547f4b3ec61Sdh155122 zonecfg_ifname_exists(AF_INET6, dlname)) { 254889b1c373Smeem zerror(zlogp, B_FALSE, "WARNING: skipping network interface " 254989b1c373Smeem "'%s' which is used in the global zone", dlname); 2550f4b3ec61Sdh155122 return (-1); 2551f4b3ec61Sdh155122 } 2552f4b3ec61Sdh155122 2553d62bc4baSyz147064 /* Set zoneid of this link. */ 255489b1c373Smeem err = dladm_setzid(dld_handle, dlname, zone_name); 255589b1c373Smeem if (err != DLADM_STATUS_OK) { 255689b1c373Smeem zdlerror(zlogp, err, dlname, 255789b1c373Smeem "WARNING: unable to add network interface"); 2558f4b3ec61Sdh155122 return (-1); 2559f4b3ec61Sdh155122 } 2560f4b3ec61Sdh155122 2561f4b3ec61Sdh155122 return (0); 2562f4b3ec61Sdh155122 } 2563f4b3ec61Sdh155122 2564f4b3ec61Sdh155122 static int 25653bc21d0aSAruna Ramakrishna - Sun Microsystems remove_datalink(zlog_t *zlogp, char *dlname) 2566f4b3ec61Sdh155122 { 256789b1c373Smeem dladm_status_t err; 256889b1c373Smeem 256989b1c373Smeem err = dladm_setzid(dld_handle, dlname, GLOBAL_ZONENAME); 257089b1c373Smeem if (err != DLADM_STATUS_OK) { 257189b1c373Smeem zdlerror(zlogp, err, dlname, 257289b1c373Smeem "unable to release network interface"); 2573f4b3ec61Sdh155122 return (-1); 2574f4b3ec61Sdh155122 } 2575f4b3ec61Sdh155122 return (0); 2576f4b3ec61Sdh155122 } 2577f4b3ec61Sdh155122 2578f4b3ec61Sdh155122 /* 2579f4b3ec61Sdh155122 * Add the kernel access control information for the interface names. 2580f4b3ec61Sdh155122 * If anything goes wrong, we log a general error message, attempt to tear down 2581f4b3ec61Sdh155122 * whatever we set up, and return an error. 2582f4b3ec61Sdh155122 */ 2583f4b3ec61Sdh155122 static int 2584f4b3ec61Sdh155122 configure_exclusive_network_interfaces(zlog_t *zlogp) 2585f4b3ec61Sdh155122 { 2586f4b3ec61Sdh155122 zone_dochandle_t handle; 2587f4b3ec61Sdh155122 struct zone_nwiftab nwiftab; 2588f4b3ec61Sdh155122 char rootpath[MAXPATHLEN]; 2589f4b3ec61Sdh155122 char path[MAXPATHLEN]; 2590f4b3ec61Sdh155122 di_prof_t prof = NULL; 2591f4b3ec61Sdh155122 boolean_t added = B_FALSE; 2592f4b3ec61Sdh155122 2593f4b3ec61Sdh155122 if ((handle = zonecfg_init_handle()) == NULL) { 2594f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 2595f4b3ec61Sdh155122 return (-1); 2596f4b3ec61Sdh155122 } 2597f4b3ec61Sdh155122 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 2598f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "invalid configuration"); 2599f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2600f4b3ec61Sdh155122 return (-1); 2601f4b3ec61Sdh155122 } 2602f4b3ec61Sdh155122 2603f4b3ec61Sdh155122 if (zonecfg_setnwifent(handle) != Z_OK) { 2604f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2605f4b3ec61Sdh155122 return (0); 2606f4b3ec61Sdh155122 } 2607f4b3ec61Sdh155122 2608f4b3ec61Sdh155122 for (;;) { 2609f4b3ec61Sdh155122 if (zonecfg_getnwifent(handle, &nwiftab) != Z_OK) 2610f4b3ec61Sdh155122 break; 2611f4b3ec61Sdh155122 2612f4b3ec61Sdh155122 if (prof == NULL) { 2613f4b3ec61Sdh155122 if (zone_get_devroot(zone_name, rootpath, 2614f4b3ec61Sdh155122 sizeof (rootpath)) != Z_OK) { 2615f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2616f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2617f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, 2618f4b3ec61Sdh155122 "unable to determine dev root"); 2619f4b3ec61Sdh155122 return (-1); 2620f4b3ec61Sdh155122 } 2621f4b3ec61Sdh155122 (void) snprintf(path, sizeof (path), "%s%s", rootpath, 2622f4b3ec61Sdh155122 "/dev"); 2623f4b3ec61Sdh155122 if (di_prof_init(path, &prof) != 0) { 2624f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2625f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2626f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, 2627f4b3ec61Sdh155122 "failed to initialize profile"); 2628f4b3ec61Sdh155122 return (-1); 2629f4b3ec61Sdh155122 } 2630f4b3ec61Sdh155122 } 2631f4b3ec61Sdh155122 2632f4b3ec61Sdh155122 /* 2633d62bc4baSyz147064 * Create the /dev entry for backward compatibility. 2634f4b3ec61Sdh155122 * Only create the /dev entry if it's not in use. 2635d62bc4baSyz147064 * Note that the zone still boots when the assigned 2636d62bc4baSyz147064 * interface is inaccessible, used by others, etc. 2637d62bc4baSyz147064 * Also, when vanity naming is used, some interface do 2638d62bc4baSyz147064 * do not have corresponding /dev node names (for example, 2639d62bc4baSyz147064 * vanity named aggregations). The /dev entry is not 2640d62bc4baSyz147064 * created in that case. The /dev/net entry is always 2641d62bc4baSyz147064 * accessible. 2642f4b3ec61Sdh155122 */ 26433bc21d0aSAruna Ramakrishna - Sun Microsystems if (add_datalink(zlogp, zone_name, nwiftab.zone_nwif_physical) 2644f4b3ec61Sdh155122 == 0) { 26453bc21d0aSAruna Ramakrishna - Sun Microsystems added = B_TRUE; 26463bc21d0aSAruna Ramakrishna - Sun Microsystems } else { 2647f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2648f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 26493bc21d0aSAruna Ramakrishna - Sun Microsystems zerror(zlogp, B_TRUE, "failed to add network device"); 2650f4b3ec61Sdh155122 return (-1); 2651f4b3ec61Sdh155122 } 2652d62bc4baSyz147064 } 2653f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2654f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2655f4b3ec61Sdh155122 2656f4b3ec61Sdh155122 if (prof != NULL && added) { 2657f4b3ec61Sdh155122 if (di_prof_commit(prof) != 0) { 2658f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "failed to commit profile"); 2659f4b3ec61Sdh155122 return (-1); 2660f4b3ec61Sdh155122 } 2661f4b3ec61Sdh155122 } 2662f4b3ec61Sdh155122 if (prof != NULL) 2663f4b3ec61Sdh155122 di_prof_fini(prof); 2664f4b3ec61Sdh155122 2665f4b3ec61Sdh155122 return (0); 2666f4b3ec61Sdh155122 } 2667f4b3ec61Sdh155122 2668f4b3ec61Sdh155122 /* 2669f4b3ec61Sdh155122 * Get the list of the data-links from kernel, and try to remove it 2670f4b3ec61Sdh155122 */ 2671f4b3ec61Sdh155122 static int 2672f4b3ec61Sdh155122 unconfigure_exclusive_network_interfaces_run(zlog_t *zlogp, zoneid_t zoneid) 2673f4b3ec61Sdh155122 { 2674f4b3ec61Sdh155122 char *dlnames, *ptr; 2675f4b3ec61Sdh155122 int dlnum, dlnum_saved, i; 2676f4b3ec61Sdh155122 2677f4b3ec61Sdh155122 dlnum = 0; 2678f4b3ec61Sdh155122 if (zone_list_datalink(zoneid, &dlnum, NULL) != 0) { 2679f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to list network interfaces"); 2680f4b3ec61Sdh155122 return (-1); 2681f4b3ec61Sdh155122 } 2682f4b3ec61Sdh155122 again: 2683f4b3ec61Sdh155122 /* this zone doesn't have any data-links */ 2684f4b3ec61Sdh155122 if (dlnum == 0) 2685f4b3ec61Sdh155122 return (0); 2686f4b3ec61Sdh155122 2687f4b3ec61Sdh155122 dlnames = malloc(dlnum * LIFNAMSIZ); 2688f4b3ec61Sdh155122 if (dlnames == NULL) { 2689f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "memory allocation failed"); 2690f4b3ec61Sdh155122 return (-1); 2691f4b3ec61Sdh155122 } 2692f4b3ec61Sdh155122 dlnum_saved = dlnum; 2693f4b3ec61Sdh155122 2694f4b3ec61Sdh155122 if (zone_list_datalink(zoneid, &dlnum, dlnames) != 0) { 2695f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to list network interfaces"); 2696f4b3ec61Sdh155122 free(dlnames); 2697f4b3ec61Sdh155122 return (-1); 2698f4b3ec61Sdh155122 } 2699f4b3ec61Sdh155122 if (dlnum_saved < dlnum) { 2700f4b3ec61Sdh155122 /* list increased, try again */ 2701f4b3ec61Sdh155122 free(dlnames); 2702f4b3ec61Sdh155122 goto again; 2703f4b3ec61Sdh155122 } 2704f4b3ec61Sdh155122 ptr = dlnames; 2705f4b3ec61Sdh155122 for (i = 0; i < dlnum; i++) { 2706f4b3ec61Sdh155122 /* Remove access control information */ 27073bc21d0aSAruna Ramakrishna - Sun Microsystems if (remove_datalink(zlogp, ptr) != 0) { 2708f4b3ec61Sdh155122 free(dlnames); 2709f4b3ec61Sdh155122 return (-1); 2710f4b3ec61Sdh155122 } 2711f4b3ec61Sdh155122 ptr += LIFNAMSIZ; 2712f4b3ec61Sdh155122 } 2713f4b3ec61Sdh155122 free(dlnames); 2714f4b3ec61Sdh155122 return (0); 2715f4b3ec61Sdh155122 } 2716f4b3ec61Sdh155122 2717f4b3ec61Sdh155122 /* 2718f4b3ec61Sdh155122 * Get the list of the data-links from configuration, and try to remove it 2719f4b3ec61Sdh155122 */ 2720f4b3ec61Sdh155122 static int 27213bc21d0aSAruna Ramakrishna - Sun Microsystems unconfigure_exclusive_network_interfaces_static(zlog_t *zlogp) 2722f4b3ec61Sdh155122 { 2723f4b3ec61Sdh155122 zone_dochandle_t handle; 2724f4b3ec61Sdh155122 struct zone_nwiftab nwiftab; 2725f4b3ec61Sdh155122 2726f4b3ec61Sdh155122 if ((handle = zonecfg_init_handle()) == NULL) { 2727f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 2728f4b3ec61Sdh155122 return (-1); 2729f4b3ec61Sdh155122 } 2730f4b3ec61Sdh155122 if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 2731f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "invalid configuration"); 2732f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2733f4b3ec61Sdh155122 return (-1); 2734f4b3ec61Sdh155122 } 2735f4b3ec61Sdh155122 if (zonecfg_setnwifent(handle) != Z_OK) { 2736f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2737f4b3ec61Sdh155122 return (0); 2738f4b3ec61Sdh155122 } 2739f4b3ec61Sdh155122 for (;;) { 2740f4b3ec61Sdh155122 if (zonecfg_getnwifent(handle, &nwiftab) != Z_OK) 2741f4b3ec61Sdh155122 break; 2742f4b3ec61Sdh155122 /* Remove access control information */ 27433bc21d0aSAruna Ramakrishna - Sun Microsystems if (remove_datalink(zlogp, nwiftab.zone_nwif_physical) 2744f4b3ec61Sdh155122 != 0) { 2745f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2746f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2747f4b3ec61Sdh155122 return (-1); 2748f4b3ec61Sdh155122 } 2749f4b3ec61Sdh155122 } 2750f4b3ec61Sdh155122 (void) zonecfg_endnwifent(handle); 2751f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2752f4b3ec61Sdh155122 return (0); 2753f4b3ec61Sdh155122 } 2754f4b3ec61Sdh155122 2755f4b3ec61Sdh155122 /* 2756f4b3ec61Sdh155122 * Remove the access control information from the kernel for the exclusive 2757f4b3ec61Sdh155122 * network interfaces. 2758f4b3ec61Sdh155122 */ 2759f4b3ec61Sdh155122 static int 2760f4b3ec61Sdh155122 unconfigure_exclusive_network_interfaces(zlog_t *zlogp, zoneid_t zoneid) 2761f4b3ec61Sdh155122 { 2762f4b3ec61Sdh155122 if (unconfigure_exclusive_network_interfaces_run(zlogp, zoneid) != 0) { 27633bc21d0aSAruna Ramakrishna - Sun Microsystems return (unconfigure_exclusive_network_interfaces_static(zlogp)); 2764f4b3ec61Sdh155122 } 2765f4b3ec61Sdh155122 2766f4b3ec61Sdh155122 return (0); 2767f4b3ec61Sdh155122 } 2768f4b3ec61Sdh155122 27697c478bd9Sstevel@tonic-gate static int 27707c478bd9Sstevel@tonic-gate tcp_abort_conn(zlog_t *zlogp, zoneid_t zoneid, 27717c478bd9Sstevel@tonic-gate const struct sockaddr_storage *local, const struct sockaddr_storage *remote) 27727c478bd9Sstevel@tonic-gate { 27737c478bd9Sstevel@tonic-gate int fd; 27747c478bd9Sstevel@tonic-gate struct strioctl ioc; 27757c478bd9Sstevel@tonic-gate tcp_ioc_abort_conn_t conn; 27767c478bd9Sstevel@tonic-gate int error; 27777c478bd9Sstevel@tonic-gate 27787c478bd9Sstevel@tonic-gate conn.ac_local = *local; 27797c478bd9Sstevel@tonic-gate conn.ac_remote = *remote; 27807c478bd9Sstevel@tonic-gate conn.ac_start = TCPS_SYN_SENT; 27817c478bd9Sstevel@tonic-gate conn.ac_end = TCPS_TIME_WAIT; 27827c478bd9Sstevel@tonic-gate conn.ac_zoneid = zoneid; 27837c478bd9Sstevel@tonic-gate 27847c478bd9Sstevel@tonic-gate ioc.ic_cmd = TCP_IOC_ABORT_CONN; 27857c478bd9Sstevel@tonic-gate ioc.ic_timout = -1; /* infinite timeout */ 27867c478bd9Sstevel@tonic-gate ioc.ic_len = sizeof (conn); 27877c478bd9Sstevel@tonic-gate ioc.ic_dp = (char *)&conn; 27887c478bd9Sstevel@tonic-gate 27897c478bd9Sstevel@tonic-gate if ((fd = open("/dev/tcp", O_RDONLY)) < 0) { 27907c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to open %s", "/dev/tcp"); 27917c478bd9Sstevel@tonic-gate return (-1); 27927c478bd9Sstevel@tonic-gate } 27937c478bd9Sstevel@tonic-gate 27947c478bd9Sstevel@tonic-gate error = ioctl(fd, I_STR, &ioc); 27957c478bd9Sstevel@tonic-gate (void) close(fd); 27967c478bd9Sstevel@tonic-gate if (error == 0 || errno == ENOENT) /* ENOENT is not an error */ 27977c478bd9Sstevel@tonic-gate return (0); 27987c478bd9Sstevel@tonic-gate return (-1); 27997c478bd9Sstevel@tonic-gate } 28007c478bd9Sstevel@tonic-gate 28017c478bd9Sstevel@tonic-gate static int 28027c478bd9Sstevel@tonic-gate tcp_abort_connections(zlog_t *zlogp, zoneid_t zoneid) 28037c478bd9Sstevel@tonic-gate { 28047c478bd9Sstevel@tonic-gate struct sockaddr_storage l, r; 28057c478bd9Sstevel@tonic-gate struct sockaddr_in *local, *remote; 28067c478bd9Sstevel@tonic-gate struct sockaddr_in6 *local6, *remote6; 28077c478bd9Sstevel@tonic-gate int error; 28087c478bd9Sstevel@tonic-gate 28097c478bd9Sstevel@tonic-gate /* 28107c478bd9Sstevel@tonic-gate * Abort IPv4 connections. 28117c478bd9Sstevel@tonic-gate */ 28127c478bd9Sstevel@tonic-gate bzero(&l, sizeof (*local)); 28137c478bd9Sstevel@tonic-gate local = (struct sockaddr_in *)&l; 28147c478bd9Sstevel@tonic-gate local->sin_family = AF_INET; 28157c478bd9Sstevel@tonic-gate local->sin_addr.s_addr = INADDR_ANY; 28167c478bd9Sstevel@tonic-gate local->sin_port = 0; 28177c478bd9Sstevel@tonic-gate 28187c478bd9Sstevel@tonic-gate bzero(&r, sizeof (*remote)); 28197c478bd9Sstevel@tonic-gate remote = (struct sockaddr_in *)&r; 28207c478bd9Sstevel@tonic-gate remote->sin_family = AF_INET; 28217c478bd9Sstevel@tonic-gate remote->sin_addr.s_addr = INADDR_ANY; 28227c478bd9Sstevel@tonic-gate remote->sin_port = 0; 28237c478bd9Sstevel@tonic-gate 28247c478bd9Sstevel@tonic-gate if ((error = tcp_abort_conn(zlogp, zoneid, &l, &r)) != 0) 28257c478bd9Sstevel@tonic-gate return (error); 28267c478bd9Sstevel@tonic-gate 28277c478bd9Sstevel@tonic-gate /* 28287c478bd9Sstevel@tonic-gate * Abort IPv6 connections. 28297c478bd9Sstevel@tonic-gate */ 28307c478bd9Sstevel@tonic-gate bzero(&l, sizeof (*local6)); 28317c478bd9Sstevel@tonic-gate local6 = (struct sockaddr_in6 *)&l; 28327c478bd9Sstevel@tonic-gate local6->sin6_family = AF_INET6; 28337c478bd9Sstevel@tonic-gate local6->sin6_port = 0; 28347c478bd9Sstevel@tonic-gate local6->sin6_addr = in6addr_any; 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate bzero(&r, sizeof (*remote6)); 28377c478bd9Sstevel@tonic-gate remote6 = (struct sockaddr_in6 *)&r; 28387c478bd9Sstevel@tonic-gate remote6->sin6_family = AF_INET6; 28397c478bd9Sstevel@tonic-gate remote6->sin6_port = 0; 28407c478bd9Sstevel@tonic-gate remote6->sin6_addr = in6addr_any; 28417c478bd9Sstevel@tonic-gate 28427c478bd9Sstevel@tonic-gate if ((error = tcp_abort_conn(zlogp, zoneid, &l, &r)) != 0) 28437c478bd9Sstevel@tonic-gate return (error); 28447c478bd9Sstevel@tonic-gate return (0); 28457c478bd9Sstevel@tonic-gate } 28467c478bd9Sstevel@tonic-gate 28477c478bd9Sstevel@tonic-gate static int 28486cfd72c6Sgjelinek get_privset(zlog_t *zlogp, priv_set_t *privs, zone_mnt_t mount_cmd) 2849ffbafc53Scomay { 2850ffbafc53Scomay int error = -1; 2851ffbafc53Scomay zone_dochandle_t handle; 2852ffbafc53Scomay char *privname = NULL; 2853ffbafc53Scomay 2854ffbafc53Scomay if ((handle = zonecfg_init_handle()) == NULL) { 2855ffbafc53Scomay zerror(zlogp, B_TRUE, "getting zone configuration handle"); 2856ffbafc53Scomay return (-1); 2857ffbafc53Scomay } 2858ffbafc53Scomay if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 2859ffbafc53Scomay zerror(zlogp, B_FALSE, "invalid configuration"); 2860ffbafc53Scomay zonecfg_fini_handle(handle); 2861ffbafc53Scomay return (-1); 2862ffbafc53Scomay } 2863ffbafc53Scomay 28646cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd)) { 2865bf1d7e28Sdh155122 zone_iptype_t iptype; 2866bf1d7e28Sdh155122 const char *curr_iptype; 2867bf1d7e28Sdh155122 2868bf1d7e28Sdh155122 if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 2869bf1d7e28Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 2870bf1d7e28Sdh155122 zonecfg_fini_handle(handle); 2871bf1d7e28Sdh155122 return (-1); 2872bf1d7e28Sdh155122 } 2873bf1d7e28Sdh155122 2874bf1d7e28Sdh155122 switch (iptype) { 2875bf1d7e28Sdh155122 case ZS_SHARED: 2876bf1d7e28Sdh155122 curr_iptype = "shared"; 2877bf1d7e28Sdh155122 break; 2878bf1d7e28Sdh155122 case ZS_EXCLUSIVE: 2879bf1d7e28Sdh155122 curr_iptype = "exclusive"; 2880bf1d7e28Sdh155122 break; 2881bf1d7e28Sdh155122 } 2882bf1d7e28Sdh155122 2883e767a340Sgjelinek if (zonecfg_default_privset(privs, curr_iptype) == Z_OK) { 2884e767a340Sgjelinek zonecfg_fini_handle(handle); 28859acbbeafSnn35248 return (0); 2886e767a340Sgjelinek } 28879acbbeafSnn35248 zerror(zlogp, B_FALSE, 28889acbbeafSnn35248 "failed to determine the zone's default privilege set"); 28899acbbeafSnn35248 zonecfg_fini_handle(handle); 28909acbbeafSnn35248 return (-1); 28919acbbeafSnn35248 } 28929acbbeafSnn35248 2893ffbafc53Scomay switch (zonecfg_get_privset(handle, privs, &privname)) { 2894ffbafc53Scomay case Z_OK: 2895ffbafc53Scomay error = 0; 2896ffbafc53Scomay break; 2897ffbafc53Scomay case Z_PRIV_PROHIBITED: 2898ffbafc53Scomay zerror(zlogp, B_FALSE, "privilege \"%s\" is not permitted " 2899ffbafc53Scomay "within the zone's privilege set", privname); 2900ffbafc53Scomay break; 2901ffbafc53Scomay case Z_PRIV_REQUIRED: 2902ffbafc53Scomay zerror(zlogp, B_FALSE, "required privilege \"%s\" is missing " 2903ffbafc53Scomay "from the zone's privilege set", privname); 2904ffbafc53Scomay break; 2905ffbafc53Scomay case Z_PRIV_UNKNOWN: 2906ffbafc53Scomay zerror(zlogp, B_FALSE, "unknown privilege \"%s\" specified " 2907ffbafc53Scomay "in the zone's privilege set", privname); 2908ffbafc53Scomay break; 2909ffbafc53Scomay default: 2910ffbafc53Scomay zerror(zlogp, B_FALSE, "failed to determine the zone's " 2911ffbafc53Scomay "privilege set"); 2912ffbafc53Scomay break; 2913ffbafc53Scomay } 2914ffbafc53Scomay 2915ffbafc53Scomay free(privname); 2916ffbafc53Scomay zonecfg_fini_handle(handle); 2917ffbafc53Scomay return (error); 2918ffbafc53Scomay } 2919ffbafc53Scomay 2920ffbafc53Scomay static int 29217c478bd9Sstevel@tonic-gate get_rctls(zlog_t *zlogp, char **bufp, size_t *bufsizep) 29227c478bd9Sstevel@tonic-gate { 29237c478bd9Sstevel@tonic-gate nvlist_t *nvl = NULL; 29247c478bd9Sstevel@tonic-gate char *nvl_packed = NULL; 29257c478bd9Sstevel@tonic-gate size_t nvl_size = 0; 29267c478bd9Sstevel@tonic-gate nvlist_t **nvlv = NULL; 29277c478bd9Sstevel@tonic-gate int rctlcount = 0; 29287c478bd9Sstevel@tonic-gate int error = -1; 29297c478bd9Sstevel@tonic-gate zone_dochandle_t handle; 29307c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 29317c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk = NULL; 29327c478bd9Sstevel@tonic-gate 29337c478bd9Sstevel@tonic-gate *bufp = NULL; 29347c478bd9Sstevel@tonic-gate *bufsizep = 0; 29357c478bd9Sstevel@tonic-gate 29367c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 29377c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "getting zone configuration handle"); 29387c478bd9Sstevel@tonic-gate return (-1); 29397c478bd9Sstevel@tonic-gate } 29407c478bd9Sstevel@tonic-gate if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 29417c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid configuration"); 29427c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 29437c478bd9Sstevel@tonic-gate return (-1); 29447c478bd9Sstevel@tonic-gate } 29457c478bd9Sstevel@tonic-gate 29467c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 29477c478bd9Sstevel@tonic-gate if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) { 29487c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "nvlist_alloc"); 29497c478bd9Sstevel@tonic-gate goto out; 29507c478bd9Sstevel@tonic-gate } 29517c478bd9Sstevel@tonic-gate 29527c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) { 29537c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setrctlent"); 29547c478bd9Sstevel@tonic-gate goto out; 29557c478bd9Sstevel@tonic-gate } 29567c478bd9Sstevel@tonic-gate 29577c478bd9Sstevel@tonic-gate if ((rctlblk = malloc(rctlblk_size())) == NULL) { 29587c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "memory allocation failed"); 29597c478bd9Sstevel@tonic-gate goto out; 29607c478bd9Sstevel@tonic-gate } 29617c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 29627c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlval; 29637c478bd9Sstevel@tonic-gate uint_t i, count; 29647c478bd9Sstevel@tonic-gate const char *name = rctltab.zone_rctl_name; 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate /* zoneadm should have already warned about unknown rctls. */ 29677c478bd9Sstevel@tonic-gate if (!zonecfg_is_rctl(name)) { 29687c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 29697c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 29707c478bd9Sstevel@tonic-gate continue; 29717c478bd9Sstevel@tonic-gate } 29727c478bd9Sstevel@tonic-gate count = 0; 29737c478bd9Sstevel@tonic-gate for (rctlval = rctltab.zone_rctl_valptr; rctlval != NULL; 29747c478bd9Sstevel@tonic-gate rctlval = rctlval->zone_rctlval_next) { 29757c478bd9Sstevel@tonic-gate count++; 29767c478bd9Sstevel@tonic-gate } 29777c478bd9Sstevel@tonic-gate if (count == 0) { /* ignore */ 29787c478bd9Sstevel@tonic-gate continue; /* Nothing to free */ 29797c478bd9Sstevel@tonic-gate } 29807c478bd9Sstevel@tonic-gate if ((nvlv = malloc(sizeof (*nvlv) * count)) == NULL) 29817c478bd9Sstevel@tonic-gate goto out; 29827c478bd9Sstevel@tonic-gate i = 0; 29837c478bd9Sstevel@tonic-gate for (rctlval = rctltab.zone_rctl_valptr; rctlval != NULL; 29847c478bd9Sstevel@tonic-gate rctlval = rctlval->zone_rctlval_next, i++) { 29857c478bd9Sstevel@tonic-gate if (nvlist_alloc(&nvlv[i], NV_UNIQUE_NAME, 0) != 0) { 29867c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", 29877c478bd9Sstevel@tonic-gate "nvlist_alloc"); 29887c478bd9Sstevel@tonic-gate goto out; 29897c478bd9Sstevel@tonic-gate } 29907c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlval, rctlblk) 29917c478bd9Sstevel@tonic-gate != Z_OK) { 29927c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "invalid rctl value: " 29937c478bd9Sstevel@tonic-gate "(priv=%s,limit=%s,action=%s)", 29947c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_priv, 29957c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_limit, 29967c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_action); 29977c478bd9Sstevel@tonic-gate goto out; 29987c478bd9Sstevel@tonic-gate } 29997c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctl(name, rctlblk)) { 30007c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 30017c478bd9Sstevel@tonic-gate "(priv=%s,limit=%s,action=%s) is not a " 30027c478bd9Sstevel@tonic-gate "valid value for rctl '%s'", 30037c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_priv, 30047c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_limit, 30057c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_action, 30067c478bd9Sstevel@tonic-gate name); 30077c478bd9Sstevel@tonic-gate goto out; 30087c478bd9Sstevel@tonic-gate } 30097c478bd9Sstevel@tonic-gate if (nvlist_add_uint64(nvlv[i], "privilege", 30107c478bd9Sstevel@tonic-gate rctlblk_get_privilege(rctlblk)) != 0) { 30117c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 30127c478bd9Sstevel@tonic-gate "nvlist_add_uint64"); 30137c478bd9Sstevel@tonic-gate goto out; 30147c478bd9Sstevel@tonic-gate } 30157c478bd9Sstevel@tonic-gate if (nvlist_add_uint64(nvlv[i], "limit", 30167c478bd9Sstevel@tonic-gate rctlblk_get_value(rctlblk)) != 0) { 30177c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 30187c478bd9Sstevel@tonic-gate "nvlist_add_uint64"); 30197c478bd9Sstevel@tonic-gate goto out; 30207c478bd9Sstevel@tonic-gate } 30217c478bd9Sstevel@tonic-gate if (nvlist_add_uint64(nvlv[i], "action", 30227c478bd9Sstevel@tonic-gate (uint_t)rctlblk_get_local_action(rctlblk, NULL)) 30237c478bd9Sstevel@tonic-gate != 0) { 30247c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 30257c478bd9Sstevel@tonic-gate "nvlist_add_uint64"); 30267c478bd9Sstevel@tonic-gate goto out; 30277c478bd9Sstevel@tonic-gate } 30287c478bd9Sstevel@tonic-gate } 30297c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 30307c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 30317c478bd9Sstevel@tonic-gate if (nvlist_add_nvlist_array(nvl, (char *)name, nvlv, count) 30327c478bd9Sstevel@tonic-gate != 0) { 30337c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", 30347c478bd9Sstevel@tonic-gate "nvlist_add_nvlist_array"); 30357c478bd9Sstevel@tonic-gate goto out; 30367c478bd9Sstevel@tonic-gate } 30377c478bd9Sstevel@tonic-gate for (i = 0; i < count; i++) 30387c478bd9Sstevel@tonic-gate nvlist_free(nvlv[i]); 30397c478bd9Sstevel@tonic-gate free(nvlv); 30407c478bd9Sstevel@tonic-gate nvlv = NULL; 30417c478bd9Sstevel@tonic-gate rctlcount++; 30427c478bd9Sstevel@tonic-gate } 30437c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 30447c478bd9Sstevel@tonic-gate 30457c478bd9Sstevel@tonic-gate if (rctlcount == 0) { 30467c478bd9Sstevel@tonic-gate error = 0; 30477c478bd9Sstevel@tonic-gate goto out; 30487c478bd9Sstevel@tonic-gate } 30497c478bd9Sstevel@tonic-gate if (nvlist_pack(nvl, &nvl_packed, &nvl_size, NV_ENCODE_NATIVE, 0) 30507c478bd9Sstevel@tonic-gate != 0) { 30517c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s failed", "nvlist_pack"); 30527c478bd9Sstevel@tonic-gate goto out; 30537c478bd9Sstevel@tonic-gate } 30547c478bd9Sstevel@tonic-gate 30557c478bd9Sstevel@tonic-gate error = 0; 30567c478bd9Sstevel@tonic-gate *bufp = nvl_packed; 30577c478bd9Sstevel@tonic-gate *bufsizep = nvl_size; 30587c478bd9Sstevel@tonic-gate 30597c478bd9Sstevel@tonic-gate out: 30607c478bd9Sstevel@tonic-gate free(rctlblk); 30617c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 30627c478bd9Sstevel@tonic-gate if (error && nvl_packed != NULL) 30637c478bd9Sstevel@tonic-gate free(nvl_packed); 30647c478bd9Sstevel@tonic-gate if (nvl != NULL) 30657c478bd9Sstevel@tonic-gate nvlist_free(nvl); 30667c478bd9Sstevel@tonic-gate if (nvlv != NULL) 30677c478bd9Sstevel@tonic-gate free(nvlv); 30687c478bd9Sstevel@tonic-gate if (handle != NULL) 30697c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 30707c478bd9Sstevel@tonic-gate return (error); 30717c478bd9Sstevel@tonic-gate } 30727c478bd9Sstevel@tonic-gate 30737c478bd9Sstevel@tonic-gate static int 3074c5cd6260S get_implicit_datasets(zlog_t *zlogp, char **retstr) 3075c5cd6260S { 3076c5cd6260S char cmdbuf[2 * MAXPATHLEN]; 3077c5cd6260S 3078c5cd6260S if (query_hook[0] == '\0') 3079c5cd6260S return (0); 3080c5cd6260S 3081c5cd6260S if (snprintf(cmdbuf, sizeof (cmdbuf), "%s datasets", query_hook) 3082c5cd6260S > sizeof (cmdbuf)) 3083c5cd6260S return (-1); 3084c5cd6260S 3085c5cd6260S if (do_subproc(zlogp, cmdbuf, retstr) != 0) 3086c5cd6260S return (-1); 3087c5cd6260S 3088c5cd6260S return (0); 3089c5cd6260S } 3090c5cd6260S 3091c5cd6260S static int 3092fa9e4066Sahrens get_datasets(zlog_t *zlogp, char **bufp, size_t *bufsizep) 3093fa9e4066Sahrens { 3094fa9e4066Sahrens zone_dochandle_t handle; 3095fa9e4066Sahrens struct zone_dstab dstab; 3096fa9e4066Sahrens size_t total, offset, len; 3097fa9e4066Sahrens int error = -1; 3098e5a17f6aSgjelinek char *str = NULL; 3099c5cd6260S char *implicit_datasets = NULL; 3100c5cd6260S int implicit_len = 0; 3101fa9e4066Sahrens 3102fa9e4066Sahrens *bufp = NULL; 3103fa9e4066Sahrens *bufsizep = 0; 3104fa9e4066Sahrens 3105fa9e4066Sahrens if ((handle = zonecfg_init_handle()) == NULL) { 3106fa9e4066Sahrens zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3107fa9e4066Sahrens return (-1); 3108fa9e4066Sahrens } 3109fa9e4066Sahrens if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3110fa9e4066Sahrens zerror(zlogp, B_FALSE, "invalid configuration"); 3111fa9e4066Sahrens zonecfg_fini_handle(handle); 3112fa9e4066Sahrens return (-1); 3113fa9e4066Sahrens } 3114fa9e4066Sahrens 3115c5cd6260S if (get_implicit_datasets(zlogp, &implicit_datasets) != 0) { 3116c5cd6260S zerror(zlogp, B_FALSE, "getting implicit datasets failed"); 3117c5cd6260S goto out; 3118c5cd6260S } 3119c5cd6260S 3120fa9e4066Sahrens if (zonecfg_setdsent(handle) != Z_OK) { 3121fa9e4066Sahrens zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setdsent"); 3122fa9e4066Sahrens goto out; 3123fa9e4066Sahrens } 3124fa9e4066Sahrens 3125fa9e4066Sahrens total = 0; 3126fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) 3127fa9e4066Sahrens total += strlen(dstab.zone_dataset_name) + 1; 3128fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3129fa9e4066Sahrens 3130c5cd6260S if (implicit_datasets != NULL) 3131c5cd6260S implicit_len = strlen(implicit_datasets); 3132c5cd6260S if (implicit_len > 0) 3133c5cd6260S total += implicit_len + 1; 3134c5cd6260S 3135fa9e4066Sahrens if (total == 0) { 3136fa9e4066Sahrens error = 0; 3137fa9e4066Sahrens goto out; 3138fa9e4066Sahrens } 3139fa9e4066Sahrens 3140fa9e4066Sahrens if ((str = malloc(total)) == NULL) { 3141fa9e4066Sahrens zerror(zlogp, B_TRUE, "memory allocation failed"); 3142fa9e4066Sahrens goto out; 3143fa9e4066Sahrens } 3144fa9e4066Sahrens 3145fa9e4066Sahrens if (zonecfg_setdsent(handle) != Z_OK) { 3146fa9e4066Sahrens zerror(zlogp, B_FALSE, "%s failed", "zonecfg_setdsent"); 3147fa9e4066Sahrens goto out; 3148fa9e4066Sahrens } 3149fa9e4066Sahrens offset = 0; 3150fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 3151fa9e4066Sahrens len = strlen(dstab.zone_dataset_name); 3152fa9e4066Sahrens (void) strlcpy(str + offset, dstab.zone_dataset_name, 3153e5a17f6aSgjelinek total - offset); 3154fa9e4066Sahrens offset += len; 3155e5a17f6aSgjelinek if (offset < total - 1) 3156fa9e4066Sahrens str[offset++] = ','; 3157fa9e4066Sahrens } 3158fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3159fa9e4066Sahrens 3160c5cd6260S if (implicit_len > 0) 3161c5cd6260S (void) strlcpy(str + offset, implicit_datasets, total - offset); 3162c5cd6260S 3163fa9e4066Sahrens error = 0; 3164fa9e4066Sahrens *bufp = str; 3165fa9e4066Sahrens *bufsizep = total; 3166fa9e4066Sahrens 3167fa9e4066Sahrens out: 3168fa9e4066Sahrens if (error != 0 && str != NULL) 3169fa9e4066Sahrens free(str); 3170fa9e4066Sahrens if (handle != NULL) 3171fa9e4066Sahrens zonecfg_fini_handle(handle); 3172c5cd6260S if (implicit_datasets != NULL) 3173c5cd6260S free(implicit_datasets); 3174fa9e4066Sahrens 3175fa9e4066Sahrens return (error); 3176fa9e4066Sahrens } 3177fa9e4066Sahrens 3178fa9e4066Sahrens static int 3179fa9e4066Sahrens validate_datasets(zlog_t *zlogp) 3180fa9e4066Sahrens { 3181fa9e4066Sahrens zone_dochandle_t handle; 3182fa9e4066Sahrens struct zone_dstab dstab; 3183fa9e4066Sahrens zfs_handle_t *zhp; 318499653d4eSeschrock libzfs_handle_t *hdl; 3185fa9e4066Sahrens 3186fa9e4066Sahrens if ((handle = zonecfg_init_handle()) == NULL) { 3187fa9e4066Sahrens zerror(zlogp, B_TRUE, "getting zone configuration handle"); 3188fa9e4066Sahrens return (-1); 3189fa9e4066Sahrens } 3190fa9e4066Sahrens if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 3191fa9e4066Sahrens zerror(zlogp, B_FALSE, "invalid configuration"); 3192fa9e4066Sahrens zonecfg_fini_handle(handle); 3193fa9e4066Sahrens return (-1); 3194fa9e4066Sahrens } 3195fa9e4066Sahrens 3196fa9e4066Sahrens if (zonecfg_setdsent(handle) != Z_OK) { 3197fa9e4066Sahrens zerror(zlogp, B_FALSE, "invalid configuration"); 3198fa9e4066Sahrens zonecfg_fini_handle(handle); 3199fa9e4066Sahrens return (-1); 3200fa9e4066Sahrens } 3201fa9e4066Sahrens 320299653d4eSeschrock if ((hdl = libzfs_init()) == NULL) { 320399653d4eSeschrock zerror(zlogp, B_FALSE, "opening ZFS library"); 320499653d4eSeschrock zonecfg_fini_handle(handle); 320599653d4eSeschrock return (-1); 320699653d4eSeschrock } 3207fa9e4066Sahrens 3208fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 3209fa9e4066Sahrens 321099653d4eSeschrock if ((zhp = zfs_open(hdl, dstab.zone_dataset_name, 3211fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) == NULL) { 3212fa9e4066Sahrens zerror(zlogp, B_FALSE, "cannot open ZFS dataset '%s'", 3213fa9e4066Sahrens dstab.zone_dataset_name); 3214fa9e4066Sahrens zonecfg_fini_handle(handle); 321599653d4eSeschrock libzfs_fini(hdl); 3216fa9e4066Sahrens return (-1); 3217fa9e4066Sahrens } 3218fa9e4066Sahrens 3219fa9e4066Sahrens /* 3220fa9e4066Sahrens * Automatically set the 'zoned' property. We check the value 3221fa9e4066Sahrens * first because we'll get EPERM if it is already set. 3222fa9e4066Sahrens */ 3223fa9e4066Sahrens if (!zfs_prop_get_int(zhp, ZFS_PROP_ZONED) && 3224e9dbad6fSeschrock zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_ZONED), 3225e9dbad6fSeschrock "on") != 0) { 3226fa9e4066Sahrens zerror(zlogp, B_FALSE, "cannot set 'zoned' " 3227fa9e4066Sahrens "property for ZFS dataset '%s'\n", 3228fa9e4066Sahrens dstab.zone_dataset_name); 3229fa9e4066Sahrens zonecfg_fini_handle(handle); 3230fa9e4066Sahrens zfs_close(zhp); 323199653d4eSeschrock libzfs_fini(hdl); 3232fa9e4066Sahrens return (-1); 3233fa9e4066Sahrens } 3234fa9e4066Sahrens 3235fa9e4066Sahrens zfs_close(zhp); 3236fa9e4066Sahrens } 3237fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3238fa9e4066Sahrens 3239fa9e4066Sahrens zonecfg_fini_handle(handle); 324099653d4eSeschrock libzfs_fini(hdl); 3241fa9e4066Sahrens 3242fa9e4066Sahrens return (0); 3243fa9e4066Sahrens } 3244fa9e4066Sahrens 324545916cd2Sjpk /* 324645916cd2Sjpk * Mount lower level home directories into/from current zone 324745916cd2Sjpk * Share exported directories specified in dfstab for zone 324845916cd2Sjpk */ 324945916cd2Sjpk static int 325045916cd2Sjpk tsol_mounts(zlog_t *zlogp, char *zone_name, char *rootpath) 325145916cd2Sjpk { 325245916cd2Sjpk zoneid_t *zids = NULL; 325345916cd2Sjpk priv_set_t *zid_privs; 325445916cd2Sjpk const priv_impl_info_t *ip = NULL; 325545916cd2Sjpk uint_t nzents_saved; 325645916cd2Sjpk uint_t nzents; 325745916cd2Sjpk int i; 325845916cd2Sjpk char readonly[] = "ro"; 325945916cd2Sjpk struct zone_fstab lower_fstab; 326045916cd2Sjpk char *argv[4]; 326145916cd2Sjpk 326245916cd2Sjpk if (!is_system_labeled()) 326345916cd2Sjpk return (0); 326445916cd2Sjpk 326545916cd2Sjpk if (zid_label == NULL) { 326645916cd2Sjpk zid_label = m_label_alloc(MAC_LABEL); 326745916cd2Sjpk if (zid_label == NULL) 326845916cd2Sjpk return (-1); 326945916cd2Sjpk } 327045916cd2Sjpk 327145916cd2Sjpk /* Make sure our zone has an /export/home dir */ 327245916cd2Sjpk (void) make_one_dir(zlogp, rootpath, "/export/home", 327327e6fb21Sdp DEFAULT_DIR_MODE, DEFAULT_DIR_USER, DEFAULT_DIR_GROUP); 327445916cd2Sjpk 327545916cd2Sjpk lower_fstab.zone_fs_raw[0] = '\0'; 327645916cd2Sjpk (void) strlcpy(lower_fstab.zone_fs_type, MNTTYPE_LOFS, 327745916cd2Sjpk sizeof (lower_fstab.zone_fs_type)); 327845916cd2Sjpk lower_fstab.zone_fs_options = NULL; 327945916cd2Sjpk (void) zonecfg_add_fs_option(&lower_fstab, readonly); 328045916cd2Sjpk 328145916cd2Sjpk /* 328245916cd2Sjpk * Get the list of zones from the kernel 328345916cd2Sjpk */ 328445916cd2Sjpk if (zone_list(NULL, &nzents) != 0) { 328545916cd2Sjpk zerror(zlogp, B_TRUE, "unable to list zones"); 328645916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 328745916cd2Sjpk return (-1); 328845916cd2Sjpk } 328945916cd2Sjpk again: 329045916cd2Sjpk if (nzents == 0) { 329145916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 329245916cd2Sjpk return (-1); 329345916cd2Sjpk } 329445916cd2Sjpk 329545916cd2Sjpk zids = malloc(nzents * sizeof (zoneid_t)); 329645916cd2Sjpk if (zids == NULL) { 32973f2f09c1Sdp zerror(zlogp, B_TRUE, "memory allocation failed"); 329845916cd2Sjpk return (-1); 329945916cd2Sjpk } 330045916cd2Sjpk nzents_saved = nzents; 330145916cd2Sjpk 330245916cd2Sjpk if (zone_list(zids, &nzents) != 0) { 330345916cd2Sjpk zerror(zlogp, B_TRUE, "unable to list zones"); 330445916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 330545916cd2Sjpk free(zids); 330645916cd2Sjpk return (-1); 330745916cd2Sjpk } 330845916cd2Sjpk if (nzents != nzents_saved) { 330945916cd2Sjpk /* list changed, try again */ 331045916cd2Sjpk free(zids); 331145916cd2Sjpk goto again; 331245916cd2Sjpk } 331345916cd2Sjpk 331445916cd2Sjpk ip = getprivimplinfo(); 331545916cd2Sjpk if ((zid_privs = priv_allocset()) == NULL) { 331645916cd2Sjpk zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 331745916cd2Sjpk zonecfg_free_fs_option_list( 331845916cd2Sjpk lower_fstab.zone_fs_options); 331945916cd2Sjpk free(zids); 332045916cd2Sjpk return (-1); 332145916cd2Sjpk } 332245916cd2Sjpk 332345916cd2Sjpk for (i = 0; i < nzents; i++) { 332445916cd2Sjpk char zid_name[ZONENAME_MAX]; 332545916cd2Sjpk zone_state_t zid_state; 332645916cd2Sjpk char zid_rpath[MAXPATHLEN]; 332745916cd2Sjpk struct stat stat_buf; 332845916cd2Sjpk 332945916cd2Sjpk if (zids[i] == GLOBAL_ZONEID) 333045916cd2Sjpk continue; 333145916cd2Sjpk 333245916cd2Sjpk if (getzonenamebyid(zids[i], zid_name, ZONENAME_MAX) == -1) 333345916cd2Sjpk continue; 333445916cd2Sjpk 333545916cd2Sjpk /* 333645916cd2Sjpk * Do special setup for the zone we are booting 333745916cd2Sjpk */ 333845916cd2Sjpk if (strcmp(zid_name, zone_name) == 0) { 333945916cd2Sjpk struct zone_fstab autofs_fstab; 334045916cd2Sjpk char map_path[MAXPATHLEN]; 334145916cd2Sjpk int fd; 334245916cd2Sjpk 334345916cd2Sjpk /* 334445916cd2Sjpk * Create auto_home_<zone> map for this zone 33459acbbeafSnn35248 * in the global zone. The non-global zone entry 334645916cd2Sjpk * will be created by automount when the zone 334745916cd2Sjpk * is booted. 334845916cd2Sjpk */ 334945916cd2Sjpk 335045916cd2Sjpk (void) snprintf(autofs_fstab.zone_fs_special, 335145916cd2Sjpk MAXPATHLEN, "auto_home_%s", zid_name); 335245916cd2Sjpk 335345916cd2Sjpk (void) snprintf(autofs_fstab.zone_fs_dir, MAXPATHLEN, 335445916cd2Sjpk "/zone/%s/home", zid_name); 335545916cd2Sjpk 335645916cd2Sjpk (void) snprintf(map_path, sizeof (map_path), 335745916cd2Sjpk "/etc/%s", autofs_fstab.zone_fs_special); 335845916cd2Sjpk /* 335945916cd2Sjpk * If the map file doesn't exist create a template 336045916cd2Sjpk */ 336145916cd2Sjpk if ((fd = open(map_path, O_RDWR | O_CREAT | O_EXCL, 336245916cd2Sjpk S_IRUSR | S_IWUSR | S_IRGRP| S_IROTH)) != -1) { 336345916cd2Sjpk int len; 336445916cd2Sjpk char map_rec[MAXPATHLEN]; 336545916cd2Sjpk 336645916cd2Sjpk len = snprintf(map_rec, sizeof (map_rec), 336745916cd2Sjpk "+%s\n*\t-fstype=lofs\t:%s/export/home/&\n", 336845916cd2Sjpk autofs_fstab.zone_fs_special, rootpath); 336945916cd2Sjpk (void) write(fd, map_rec, len); 337045916cd2Sjpk (void) close(fd); 337145916cd2Sjpk } 337245916cd2Sjpk 337345916cd2Sjpk /* 337445916cd2Sjpk * Mount auto_home_<zone> in the global zone if absent. 337545916cd2Sjpk * If it's already of type autofs, then 337645916cd2Sjpk * don't mount it again. 337745916cd2Sjpk */ 337845916cd2Sjpk if ((stat(autofs_fstab.zone_fs_dir, &stat_buf) == -1) || 337945916cd2Sjpk strcmp(stat_buf.st_fstype, MNTTYPE_AUTOFS) != 0) { 338045916cd2Sjpk char optstr[] = "indirect,ignore,nobrowse"; 338145916cd2Sjpk 338245916cd2Sjpk (void) make_one_dir(zlogp, "", 338327e6fb21Sdp autofs_fstab.zone_fs_dir, DEFAULT_DIR_MODE, 338427e6fb21Sdp DEFAULT_DIR_USER, DEFAULT_DIR_GROUP); 338545916cd2Sjpk 338645916cd2Sjpk /* 338745916cd2Sjpk * Mount will fail if automounter has already 338845916cd2Sjpk * processed the auto_home_<zonename> map 338945916cd2Sjpk */ 339045916cd2Sjpk (void) domount(zlogp, MNTTYPE_AUTOFS, optstr, 339145916cd2Sjpk autofs_fstab.zone_fs_special, 339245916cd2Sjpk autofs_fstab.zone_fs_dir); 339345916cd2Sjpk } 339445916cd2Sjpk continue; 339545916cd2Sjpk } 339645916cd2Sjpk 339745916cd2Sjpk 339845916cd2Sjpk if (zone_get_state(zid_name, &zid_state) != Z_OK || 339948451833Scarlsonj (zid_state != ZONE_STATE_READY && 340048451833Scarlsonj zid_state != ZONE_STATE_RUNNING)) 340145916cd2Sjpk /* Skip over zones without mounted filesystems */ 340245916cd2Sjpk continue; 340345916cd2Sjpk 340445916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_SLBL, zid_label, 340545916cd2Sjpk sizeof (m_label_t)) < 0) 340645916cd2Sjpk /* Skip over zones with unspecified label */ 340745916cd2Sjpk continue; 340845916cd2Sjpk 340945916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_ROOT, zid_rpath, 341045916cd2Sjpk sizeof (zid_rpath)) == -1) 341145916cd2Sjpk /* Skip over zones with bad path */ 341245916cd2Sjpk continue; 341345916cd2Sjpk 341445916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_PRIVSET, zid_privs, 341545916cd2Sjpk sizeof (priv_chunk_t) * ip->priv_setsize) == -1) 341645916cd2Sjpk /* Skip over zones with bad privs */ 341745916cd2Sjpk continue; 341845916cd2Sjpk 341945916cd2Sjpk /* 342045916cd2Sjpk * Reading down is valid according to our label model 342145916cd2Sjpk * but some customers want to disable it because it 342245916cd2Sjpk * allows execute down and other possible attacks. 342345916cd2Sjpk * Therefore, we restrict this feature to zones that 342445916cd2Sjpk * have the NET_MAC_AWARE privilege which is required 342545916cd2Sjpk * for NFS read-down semantics. 342645916cd2Sjpk */ 342745916cd2Sjpk if ((bldominates(zlabel, zid_label)) && 342845916cd2Sjpk (priv_ismember(zprivs, PRIV_NET_MAC_AWARE))) { 342945916cd2Sjpk /* 343045916cd2Sjpk * Our zone dominates this one. 343145916cd2Sjpk * Create a lofs mount from lower zone's /export/home 343245916cd2Sjpk */ 343345916cd2Sjpk (void) snprintf(lower_fstab.zone_fs_dir, MAXPATHLEN, 343445916cd2Sjpk "%s/zone/%s/export/home", rootpath, zid_name); 343545916cd2Sjpk 343645916cd2Sjpk /* 343745916cd2Sjpk * If the target is already an LOFS mount 343845916cd2Sjpk * then don't do it again. 343945916cd2Sjpk */ 344045916cd2Sjpk if ((stat(lower_fstab.zone_fs_dir, &stat_buf) == -1) || 344145916cd2Sjpk strcmp(stat_buf.st_fstype, MNTTYPE_LOFS) != 0) { 344245916cd2Sjpk 344345916cd2Sjpk if (snprintf(lower_fstab.zone_fs_special, 344445916cd2Sjpk MAXPATHLEN, "%s/export", 344545916cd2Sjpk zid_rpath) > MAXPATHLEN) 344645916cd2Sjpk continue; 344745916cd2Sjpk 344845916cd2Sjpk /* 344945916cd2Sjpk * Make sure the lower-level home exists 345045916cd2Sjpk */ 345145916cd2Sjpk if (make_one_dir(zlogp, 345227e6fb21Sdp lower_fstab.zone_fs_special, "/home", 345327e6fb21Sdp DEFAULT_DIR_MODE, DEFAULT_DIR_USER, 345427e6fb21Sdp DEFAULT_DIR_GROUP) != 0) 345545916cd2Sjpk continue; 345645916cd2Sjpk 345745916cd2Sjpk (void) strlcat(lower_fstab.zone_fs_special, 345845916cd2Sjpk "/home", MAXPATHLEN); 345945916cd2Sjpk 346045916cd2Sjpk /* 346145916cd2Sjpk * Mount can fail because the lower-level 346245916cd2Sjpk * zone may have already done a mount up. 346345916cd2Sjpk */ 34640679f794S (void) mount_one(zlogp, &lower_fstab, "", 34650679f794S Z_MNT_BOOT); 346645916cd2Sjpk } 346745916cd2Sjpk } else if ((bldominates(zid_label, zlabel)) && 346845916cd2Sjpk (priv_ismember(zid_privs, PRIV_NET_MAC_AWARE))) { 346945916cd2Sjpk /* 347045916cd2Sjpk * This zone dominates our zone. 347145916cd2Sjpk * Create a lofs mount from our zone's /export/home 347245916cd2Sjpk */ 347345916cd2Sjpk if (snprintf(lower_fstab.zone_fs_dir, MAXPATHLEN, 347445916cd2Sjpk "%s/zone/%s/export/home", zid_rpath, 347545916cd2Sjpk zone_name) > MAXPATHLEN) 347645916cd2Sjpk continue; 347745916cd2Sjpk 347845916cd2Sjpk /* 347945916cd2Sjpk * If the target is already an LOFS mount 348045916cd2Sjpk * then don't do it again. 348145916cd2Sjpk */ 348245916cd2Sjpk if ((stat(lower_fstab.zone_fs_dir, &stat_buf) == -1) || 348345916cd2Sjpk strcmp(stat_buf.st_fstype, MNTTYPE_LOFS) != 0) { 348445916cd2Sjpk 348545916cd2Sjpk (void) snprintf(lower_fstab.zone_fs_special, 348645916cd2Sjpk MAXPATHLEN, "%s/export/home", rootpath); 348745916cd2Sjpk 348845916cd2Sjpk /* 348945916cd2Sjpk * Mount can fail because the higher-level 349045916cd2Sjpk * zone may have already done a mount down. 349145916cd2Sjpk */ 34920679f794S (void) mount_one(zlogp, &lower_fstab, "", 34930679f794S Z_MNT_BOOT); 349445916cd2Sjpk } 349545916cd2Sjpk } 349645916cd2Sjpk } 349745916cd2Sjpk zonecfg_free_fs_option_list(lower_fstab.zone_fs_options); 349845916cd2Sjpk priv_freeset(zid_privs); 349945916cd2Sjpk free(zids); 350045916cd2Sjpk 350145916cd2Sjpk /* 350245916cd2Sjpk * Now share any exported directories from this zone. 350345916cd2Sjpk * Each zone can have its own dfstab. 350445916cd2Sjpk */ 350545916cd2Sjpk 350645916cd2Sjpk argv[0] = "zoneshare"; 350745916cd2Sjpk argv[1] = "-z"; 350845916cd2Sjpk argv[2] = zone_name; 350945916cd2Sjpk argv[3] = NULL; 351045916cd2Sjpk 351145916cd2Sjpk (void) forkexec(zlogp, "/usr/lib/zones/zoneshare", argv); 351245916cd2Sjpk /* Don't check for errors since they don't affect the zone */ 351345916cd2Sjpk 351445916cd2Sjpk return (0); 351545916cd2Sjpk } 351645916cd2Sjpk 351745916cd2Sjpk /* 351845916cd2Sjpk * Unmount lofs mounts from higher level zones 351945916cd2Sjpk * Unshare nfs exported directories 352045916cd2Sjpk */ 352145916cd2Sjpk static void 352245916cd2Sjpk tsol_unmounts(zlog_t *zlogp, char *zone_name) 352345916cd2Sjpk { 352445916cd2Sjpk zoneid_t *zids = NULL; 352545916cd2Sjpk uint_t nzents_saved; 352645916cd2Sjpk uint_t nzents; 352745916cd2Sjpk int i; 352845916cd2Sjpk char *argv[4]; 352945916cd2Sjpk char path[MAXPATHLEN]; 353045916cd2Sjpk 353145916cd2Sjpk if (!is_system_labeled()) 353245916cd2Sjpk return; 353345916cd2Sjpk 353445916cd2Sjpk /* 353545916cd2Sjpk * Get the list of zones from the kernel 353645916cd2Sjpk */ 353745916cd2Sjpk if (zone_list(NULL, &nzents) != 0) { 353845916cd2Sjpk return; 353945916cd2Sjpk } 354045916cd2Sjpk 354145916cd2Sjpk if (zid_label == NULL) { 354245916cd2Sjpk zid_label = m_label_alloc(MAC_LABEL); 354345916cd2Sjpk if (zid_label == NULL) 354445916cd2Sjpk return; 354545916cd2Sjpk } 354645916cd2Sjpk 354745916cd2Sjpk again: 354845916cd2Sjpk if (nzents == 0) 354945916cd2Sjpk return; 355045916cd2Sjpk 355145916cd2Sjpk zids = malloc(nzents * sizeof (zoneid_t)); 355245916cd2Sjpk if (zids == NULL) { 35533f2f09c1Sdp zerror(zlogp, B_TRUE, "memory allocation failed"); 355445916cd2Sjpk return; 355545916cd2Sjpk } 355645916cd2Sjpk nzents_saved = nzents; 355745916cd2Sjpk 355845916cd2Sjpk if (zone_list(zids, &nzents) != 0) { 355945916cd2Sjpk free(zids); 356045916cd2Sjpk return; 356145916cd2Sjpk } 356245916cd2Sjpk if (nzents != nzents_saved) { 356345916cd2Sjpk /* list changed, try again */ 356445916cd2Sjpk free(zids); 356545916cd2Sjpk goto again; 356645916cd2Sjpk } 356745916cd2Sjpk 356845916cd2Sjpk for (i = 0; i < nzents; i++) { 356945916cd2Sjpk char zid_name[ZONENAME_MAX]; 357045916cd2Sjpk zone_state_t zid_state; 357145916cd2Sjpk char zid_rpath[MAXPATHLEN]; 357245916cd2Sjpk 357345916cd2Sjpk if (zids[i] == GLOBAL_ZONEID) 357445916cd2Sjpk continue; 357545916cd2Sjpk 357645916cd2Sjpk if (getzonenamebyid(zids[i], zid_name, ZONENAME_MAX) == -1) 357745916cd2Sjpk continue; 357845916cd2Sjpk 357945916cd2Sjpk /* 358045916cd2Sjpk * Skip the zone we are halting 358145916cd2Sjpk */ 358245916cd2Sjpk if (strcmp(zid_name, zone_name) == 0) 358345916cd2Sjpk continue; 358445916cd2Sjpk 358545916cd2Sjpk if ((zone_getattr(zids[i], ZONE_ATTR_STATUS, &zid_state, 358645916cd2Sjpk sizeof (zid_state)) < 0) || 358745916cd2Sjpk (zid_state < ZONE_IS_READY)) 358845916cd2Sjpk /* Skip over zones without mounted filesystems */ 358945916cd2Sjpk continue; 359045916cd2Sjpk 359145916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_SLBL, zid_label, 359245916cd2Sjpk sizeof (m_label_t)) < 0) 359345916cd2Sjpk /* Skip over zones with unspecified label */ 359445916cd2Sjpk continue; 359545916cd2Sjpk 359645916cd2Sjpk if (zone_getattr(zids[i], ZONE_ATTR_ROOT, zid_rpath, 359745916cd2Sjpk sizeof (zid_rpath)) == -1) 359845916cd2Sjpk /* Skip over zones with bad path */ 359945916cd2Sjpk continue; 360045916cd2Sjpk 360145916cd2Sjpk if (zlabel != NULL && bldominates(zid_label, zlabel)) { 360245916cd2Sjpk /* 360345916cd2Sjpk * This zone dominates our zone. 360445916cd2Sjpk * Unmount the lofs mount of our zone's /export/home 360545916cd2Sjpk */ 360645916cd2Sjpk 360745916cd2Sjpk if (snprintf(path, MAXPATHLEN, 360845916cd2Sjpk "%s/zone/%s/export/home", zid_rpath, 360945916cd2Sjpk zone_name) > MAXPATHLEN) 361045916cd2Sjpk continue; 361145916cd2Sjpk 361245916cd2Sjpk /* Skip over mount failures */ 361345916cd2Sjpk (void) umount(path); 361445916cd2Sjpk } 361545916cd2Sjpk } 361645916cd2Sjpk free(zids); 361745916cd2Sjpk 361845916cd2Sjpk /* 361945916cd2Sjpk * Unmount global zone autofs trigger for this zone 362045916cd2Sjpk */ 362145916cd2Sjpk (void) snprintf(path, MAXPATHLEN, "/zone/%s/home", zone_name); 362245916cd2Sjpk /* Skip over mount failures */ 362345916cd2Sjpk (void) umount(path); 362445916cd2Sjpk 362545916cd2Sjpk /* 362645916cd2Sjpk * Next unshare any exported directories from this zone. 362745916cd2Sjpk */ 362845916cd2Sjpk 362945916cd2Sjpk argv[0] = "zoneunshare"; 363045916cd2Sjpk argv[1] = "-z"; 363145916cd2Sjpk argv[2] = zone_name; 363245916cd2Sjpk argv[3] = NULL; 363345916cd2Sjpk 363445916cd2Sjpk (void) forkexec(zlogp, "/usr/lib/zones/zoneunshare", argv); 363545916cd2Sjpk /* Don't check for errors since they don't affect the zone */ 363645916cd2Sjpk 363745916cd2Sjpk /* 363845916cd2Sjpk * Finally, deallocate any devices in the zone. 363945916cd2Sjpk */ 364045916cd2Sjpk 364145916cd2Sjpk argv[0] = "deallocate"; 364245916cd2Sjpk argv[1] = "-Isz"; 364345916cd2Sjpk argv[2] = zone_name; 364445916cd2Sjpk argv[3] = NULL; 364545916cd2Sjpk 364645916cd2Sjpk (void) forkexec(zlogp, "/usr/sbin/deallocate", argv); 364745916cd2Sjpk /* Don't check for errors since they don't affect the zone */ 364845916cd2Sjpk } 364945916cd2Sjpk 365045916cd2Sjpk /* 365145916cd2Sjpk * Fetch the Trusted Extensions label and multi-level ports (MLPs) for 365245916cd2Sjpk * this zone. 365345916cd2Sjpk */ 365445916cd2Sjpk static tsol_zcent_t * 365545916cd2Sjpk get_zone_label(zlog_t *zlogp, priv_set_t *privs) 365645916cd2Sjpk { 365745916cd2Sjpk FILE *fp; 365845916cd2Sjpk tsol_zcent_t *zcent = NULL; 365945916cd2Sjpk char line[MAXTNZLEN]; 366045916cd2Sjpk 366145916cd2Sjpk if ((fp = fopen(TNZONECFG_PATH, "r")) == NULL) { 366245916cd2Sjpk zerror(zlogp, B_TRUE, "%s", TNZONECFG_PATH); 366345916cd2Sjpk return (NULL); 366445916cd2Sjpk } 366545916cd2Sjpk 366645916cd2Sjpk while (fgets(line, sizeof (line), fp) != NULL) { 366745916cd2Sjpk /* 366845916cd2Sjpk * Check for malformed database 366945916cd2Sjpk */ 367045916cd2Sjpk if (strlen(line) == MAXTNZLEN - 1) 367145916cd2Sjpk break; 367245916cd2Sjpk if ((zcent = tsol_sgetzcent(line, NULL, NULL)) == NULL) 367345916cd2Sjpk continue; 367445916cd2Sjpk if (strcmp(zcent->zc_name, zone_name) == 0) 367545916cd2Sjpk break; 367645916cd2Sjpk tsol_freezcent(zcent); 367745916cd2Sjpk zcent = NULL; 367845916cd2Sjpk } 367945916cd2Sjpk (void) fclose(fp); 368045916cd2Sjpk 368145916cd2Sjpk if (zcent == NULL) { 368245916cd2Sjpk zerror(zlogp, B_FALSE, "zone requires a label assignment. " 368345916cd2Sjpk "See tnzonecfg(4)"); 368445916cd2Sjpk } else { 368545916cd2Sjpk if (zlabel == NULL) 368645916cd2Sjpk zlabel = m_label_alloc(MAC_LABEL); 368745916cd2Sjpk /* 368845916cd2Sjpk * Save this zone's privileges for later read-down processing 368945916cd2Sjpk */ 369045916cd2Sjpk if ((zprivs = priv_allocset()) == NULL) { 369145916cd2Sjpk zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 369245916cd2Sjpk return (NULL); 369345916cd2Sjpk } else { 369445916cd2Sjpk priv_copyset(privs, zprivs); 369545916cd2Sjpk } 369645916cd2Sjpk } 369745916cd2Sjpk return (zcent); 369845916cd2Sjpk } 369945916cd2Sjpk 370045916cd2Sjpk /* 370145916cd2Sjpk * Add the Trusted Extensions multi-level ports for this zone. 370245916cd2Sjpk */ 370345916cd2Sjpk static void 370445916cd2Sjpk set_mlps(zlog_t *zlogp, zoneid_t zoneid, tsol_zcent_t *zcent) 370545916cd2Sjpk { 370645916cd2Sjpk tsol_mlp_t *mlp; 370745916cd2Sjpk tsol_mlpent_t tsme; 370845916cd2Sjpk 370945916cd2Sjpk if (!is_system_labeled()) 371045916cd2Sjpk return; 371145916cd2Sjpk 371245916cd2Sjpk tsme.tsme_zoneid = zoneid; 371345916cd2Sjpk tsme.tsme_flags = 0; 371445916cd2Sjpk for (mlp = zcent->zc_private_mlp; !TSOL_MLP_END(mlp); mlp++) { 371545916cd2Sjpk tsme.tsme_mlp = *mlp; 371645916cd2Sjpk if (tnmlp(TNDB_LOAD, &tsme) != 0) { 371745916cd2Sjpk zerror(zlogp, B_TRUE, "cannot set zone-specific MLP " 371845916cd2Sjpk "on %d-%d/%d", mlp->mlp_port, 371945916cd2Sjpk mlp->mlp_port_upper, mlp->mlp_ipp); 372045916cd2Sjpk } 372145916cd2Sjpk } 372245916cd2Sjpk 372345916cd2Sjpk tsme.tsme_flags = TSOL_MEF_SHARED; 372445916cd2Sjpk for (mlp = zcent->zc_shared_mlp; !TSOL_MLP_END(mlp); mlp++) { 372545916cd2Sjpk tsme.tsme_mlp = *mlp; 372645916cd2Sjpk if (tnmlp(TNDB_LOAD, &tsme) != 0) { 372745916cd2Sjpk zerror(zlogp, B_TRUE, "cannot set shared MLP " 372845916cd2Sjpk "on %d-%d/%d", mlp->mlp_port, 372945916cd2Sjpk mlp->mlp_port_upper, mlp->mlp_ipp); 373045916cd2Sjpk } 373145916cd2Sjpk } 373245916cd2Sjpk } 373345916cd2Sjpk 373445916cd2Sjpk static void 373545916cd2Sjpk remove_mlps(zlog_t *zlogp, zoneid_t zoneid) 373645916cd2Sjpk { 373745916cd2Sjpk tsol_mlpent_t tsme; 373845916cd2Sjpk 373945916cd2Sjpk if (!is_system_labeled()) 374045916cd2Sjpk return; 374145916cd2Sjpk 374245916cd2Sjpk (void) memset(&tsme, 0, sizeof (tsme)); 374345916cd2Sjpk tsme.tsme_zoneid = zoneid; 374445916cd2Sjpk if (tnmlp(TNDB_FLUSH, &tsme) != 0) 374545916cd2Sjpk zerror(zlogp, B_TRUE, "cannot flush MLPs"); 374645916cd2Sjpk } 374745916cd2Sjpk 37487c478bd9Sstevel@tonic-gate int 37497c478bd9Sstevel@tonic-gate prtmount(const char *fs, void *x) { 37507c478bd9Sstevel@tonic-gate zerror((zlog_t *)x, B_FALSE, " %s", fs); 37517c478bd9Sstevel@tonic-gate return (0); 37527c478bd9Sstevel@tonic-gate } 37537c478bd9Sstevel@tonic-gate 3754108322fbScarlsonj /* 3755108322fbScarlsonj * Look for zones running on the main system that are using this root (or any 3756108322fbScarlsonj * subdirectory of it). Return B_TRUE and print an error if a conflicting zone 3757108322fbScarlsonj * is found or if we can't tell. 3758108322fbScarlsonj */ 3759108322fbScarlsonj static boolean_t 3760108322fbScarlsonj duplicate_zone_root(zlog_t *zlogp, const char *rootpath) 37617c478bd9Sstevel@tonic-gate { 3762108322fbScarlsonj zoneid_t *zids = NULL; 3763108322fbScarlsonj uint_t nzids = 0; 3764108322fbScarlsonj boolean_t retv; 3765108322fbScarlsonj int rlen, zlen; 3766108322fbScarlsonj char zroot[MAXPATHLEN]; 3767108322fbScarlsonj char zonename[ZONENAME_MAX]; 3768108322fbScarlsonj 3769108322fbScarlsonj for (;;) { 3770108322fbScarlsonj nzids += 10; 3771108322fbScarlsonj zids = malloc(nzids * sizeof (*zids)); 3772108322fbScarlsonj if (zids == NULL) { 37733f2f09c1Sdp zerror(zlogp, B_TRUE, "memory allocation failed"); 3774108322fbScarlsonj return (B_TRUE); 3775108322fbScarlsonj } 3776108322fbScarlsonj if (zone_list(zids, &nzids) == 0) 3777108322fbScarlsonj break; 3778108322fbScarlsonj free(zids); 3779108322fbScarlsonj } 3780108322fbScarlsonj retv = B_FALSE; 3781108322fbScarlsonj rlen = strlen(rootpath); 3782108322fbScarlsonj while (nzids > 0) { 3783108322fbScarlsonj /* 3784108322fbScarlsonj * Ignore errors; they just mean that the zone has disappeared 3785108322fbScarlsonj * while we were busy. 3786108322fbScarlsonj */ 3787108322fbScarlsonj if (zone_getattr(zids[--nzids], ZONE_ATTR_ROOT, zroot, 3788108322fbScarlsonj sizeof (zroot)) == -1) 3789108322fbScarlsonj continue; 3790108322fbScarlsonj zlen = strlen(zroot); 3791108322fbScarlsonj if (zlen > rlen) 3792108322fbScarlsonj zlen = rlen; 3793108322fbScarlsonj if (strncmp(rootpath, zroot, zlen) == 0 && 3794108322fbScarlsonj (zroot[zlen] == '\0' || zroot[zlen] == '/') && 3795108322fbScarlsonj (rootpath[zlen] == '\0' || rootpath[zlen] == '/')) { 3796108322fbScarlsonj if (getzonenamebyid(zids[nzids], zonename, 3797108322fbScarlsonj sizeof (zonename)) == -1) 3798108322fbScarlsonj (void) snprintf(zonename, sizeof (zonename), 3799108322fbScarlsonj "id %d", (int)zids[nzids]); 3800108322fbScarlsonj zerror(zlogp, B_FALSE, 3801108322fbScarlsonj "zone root %s already in use by zone %s", 3802108322fbScarlsonj rootpath, zonename); 3803108322fbScarlsonj retv = B_TRUE; 3804108322fbScarlsonj break; 3805108322fbScarlsonj } 3806108322fbScarlsonj } 3807108322fbScarlsonj free(zids); 3808108322fbScarlsonj return (retv); 3809108322fbScarlsonj } 3810108322fbScarlsonj 3811108322fbScarlsonj /* 3812108322fbScarlsonj * Search for loopback mounts that use this same source node (same device and 3813108322fbScarlsonj * inode). Return B_TRUE if there is one or if we can't tell. 3814108322fbScarlsonj */ 3815108322fbScarlsonj static boolean_t 3816108322fbScarlsonj duplicate_reachable_path(zlog_t *zlogp, const char *rootpath) 3817108322fbScarlsonj { 3818108322fbScarlsonj struct stat64 rst, zst; 3819108322fbScarlsonj struct mnttab *mnp; 3820108322fbScarlsonj 3821108322fbScarlsonj if (stat64(rootpath, &rst) == -1) { 3822108322fbScarlsonj zerror(zlogp, B_TRUE, "can't stat %s", rootpath); 3823108322fbScarlsonj return (B_TRUE); 3824108322fbScarlsonj } 3825108322fbScarlsonj if (resolve_lofs_mnts == NULL && lofs_read_mnttab(zlogp) == -1) 3826108322fbScarlsonj return (B_TRUE); 3827108322fbScarlsonj for (mnp = resolve_lofs_mnts; mnp < resolve_lofs_mnt_max; mnp++) { 3828108322fbScarlsonj if (mnp->mnt_fstype == NULL || 3829108322fbScarlsonj strcmp(MNTTYPE_LOFS, mnp->mnt_fstype) != 0) 3830108322fbScarlsonj continue; 3831108322fbScarlsonj /* We're looking at a loopback mount. Stat it. */ 3832108322fbScarlsonj if (mnp->mnt_special != NULL && 3833108322fbScarlsonj stat64(mnp->mnt_special, &zst) != -1 && 3834108322fbScarlsonj rst.st_dev == zst.st_dev && rst.st_ino == zst.st_ino) { 3835108322fbScarlsonj zerror(zlogp, B_FALSE, 3836108322fbScarlsonj "zone root %s is reachable through %s", 3837108322fbScarlsonj rootpath, mnp->mnt_mountp); 3838108322fbScarlsonj return (B_TRUE); 3839108322fbScarlsonj } 3840108322fbScarlsonj } 3841108322fbScarlsonj return (B_FALSE); 3842108322fbScarlsonj } 3843108322fbScarlsonj 38440209230bSgjelinek /* 38450209230bSgjelinek * Set memory cap and pool info for the zone's resource management 38460209230bSgjelinek * configuration. 38470209230bSgjelinek */ 38480209230bSgjelinek static int 38490209230bSgjelinek setup_zone_rm(zlog_t *zlogp, char *zone_name, zoneid_t zoneid) 38500209230bSgjelinek { 38510209230bSgjelinek int res; 38520209230bSgjelinek uint64_t tmp; 38530209230bSgjelinek struct zone_mcaptab mcap; 38540209230bSgjelinek char sched[MAXNAMELEN]; 38550209230bSgjelinek zone_dochandle_t handle = NULL; 38560209230bSgjelinek char pool_err[128]; 38570209230bSgjelinek 38580209230bSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 38590209230bSgjelinek zerror(zlogp, B_TRUE, "getting zone configuration handle"); 38600209230bSgjelinek return (Z_BAD_HANDLE); 38610209230bSgjelinek } 38620209230bSgjelinek 38630209230bSgjelinek if ((res = zonecfg_get_snapshot_handle(zone_name, handle)) != Z_OK) { 38640209230bSgjelinek zerror(zlogp, B_FALSE, "invalid configuration"); 38650209230bSgjelinek zonecfg_fini_handle(handle); 38660209230bSgjelinek return (res); 38670209230bSgjelinek } 38680209230bSgjelinek 38690209230bSgjelinek /* 38700209230bSgjelinek * If a memory cap is configured, set the cap in the kernel using 38710209230bSgjelinek * zone_setattr() and make sure the rcapd SMF service is enabled. 38720209230bSgjelinek */ 38730209230bSgjelinek if (zonecfg_getmcapent(handle, &mcap) == Z_OK) { 38740209230bSgjelinek uint64_t num; 38750209230bSgjelinek char smf_err[128]; 38760209230bSgjelinek 38770209230bSgjelinek num = (uint64_t)strtoull(mcap.zone_physmem_cap, NULL, 10); 38780209230bSgjelinek if (zone_setattr(zoneid, ZONE_ATTR_PHYS_MCAP, &num, 0) == -1) { 38790209230bSgjelinek zerror(zlogp, B_TRUE, "could not set zone memory cap"); 38800209230bSgjelinek zonecfg_fini_handle(handle); 38810209230bSgjelinek return (Z_INVAL); 38820209230bSgjelinek } 38830209230bSgjelinek 38840209230bSgjelinek if (zonecfg_enable_rcapd(smf_err, sizeof (smf_err)) != Z_OK) { 38850209230bSgjelinek zerror(zlogp, B_FALSE, "enabling system/rcap service " 38860209230bSgjelinek "failed: %s", smf_err); 38870209230bSgjelinek zonecfg_fini_handle(handle); 38880209230bSgjelinek return (Z_INVAL); 38890209230bSgjelinek } 38900209230bSgjelinek } 38910209230bSgjelinek 38920209230bSgjelinek /* Get the scheduling class set in the zone configuration. */ 38930209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 38940209230bSgjelinek strlen(sched) > 0) { 38950209230bSgjelinek if (zone_setattr(zoneid, ZONE_ATTR_SCHED_CLASS, sched, 38960209230bSgjelinek strlen(sched)) == -1) 38970209230bSgjelinek zerror(zlogp, B_TRUE, "WARNING: unable to set the " 38980209230bSgjelinek "default scheduling class"); 38990209230bSgjelinek 39000209230bSgjelinek } else if (zonecfg_get_aliased_rctl(handle, ALIAS_SHARES, &tmp) 39010209230bSgjelinek == Z_OK) { 39020209230bSgjelinek /* 39030209230bSgjelinek * If the zone has the zone.cpu-shares rctl set then we want to 39040209230bSgjelinek * use the Fair Share Scheduler (FSS) for processes in the 39050209230bSgjelinek * zone. Check what scheduling class the zone would be running 39060209230bSgjelinek * in by default so we can print a warning and modify the class 39070209230bSgjelinek * if we wouldn't be using FSS. 39080209230bSgjelinek */ 39090209230bSgjelinek char class_name[PC_CLNMSZ]; 39100209230bSgjelinek 39110209230bSgjelinek if (zonecfg_get_dflt_sched_class(handle, class_name, 39120209230bSgjelinek sizeof (class_name)) != Z_OK) { 39130209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: unable to determine " 39140209230bSgjelinek "the zone's scheduling class"); 39150209230bSgjelinek 39160209230bSgjelinek } else if (strcmp("FSS", class_name) != 0) { 39170209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: The zone.cpu-shares " 39180209230bSgjelinek "rctl is set but\nFSS is not the default " 39190209230bSgjelinek "scheduling class for\nthis zone. FSS will be " 39200209230bSgjelinek "used for processes\nin the zone but to get the " 39210209230bSgjelinek "full benefit of FSS,\nit should be the default " 39220209230bSgjelinek "scheduling class.\nSee dispadmin(1M) for more " 39230209230bSgjelinek "details."); 39240209230bSgjelinek 39250209230bSgjelinek if (zone_setattr(zoneid, ZONE_ATTR_SCHED_CLASS, "FSS", 39260209230bSgjelinek strlen("FSS")) == -1) 39270209230bSgjelinek zerror(zlogp, B_TRUE, "WARNING: unable to set " 39280209230bSgjelinek "zone scheduling class to FSS"); 39290209230bSgjelinek } 39300209230bSgjelinek } 39310209230bSgjelinek 39320209230bSgjelinek /* 39330209230bSgjelinek * The next few blocks of code attempt to set up temporary pools as 39340209230bSgjelinek * well as persistent pools. In all cases we call the functions 39350209230bSgjelinek * unconditionally. Within each funtion the code will check if the 39360209230bSgjelinek * zone is actually configured for a temporary pool or persistent pool 39370209230bSgjelinek * and just return if there is nothing to do. 39380209230bSgjelinek * 39390209230bSgjelinek * If we are rebooting we want to attempt to reuse any temporary pool 39400209230bSgjelinek * that was previously set up. zonecfg_bind_tmp_pool() will do the 39410209230bSgjelinek * right thing in all cases (reuse or create) based on the current 39420209230bSgjelinek * zonecfg. 39430209230bSgjelinek */ 39440209230bSgjelinek if ((res = zonecfg_bind_tmp_pool(handle, zoneid, pool_err, 39450209230bSgjelinek sizeof (pool_err))) != Z_OK) { 39460209230bSgjelinek if (res == Z_POOL || res == Z_POOL_CREATE || res == Z_POOL_BIND) 39470209230bSgjelinek zerror(zlogp, B_FALSE, "%s: %s\ndedicated-cpu setting " 39480209230bSgjelinek "cannot be instantiated", zonecfg_strerror(res), 39490209230bSgjelinek pool_err); 39500209230bSgjelinek else 39510209230bSgjelinek zerror(zlogp, B_FALSE, "could not bind zone to " 39520209230bSgjelinek "temporary pool: %s", zonecfg_strerror(res)); 39530209230bSgjelinek zonecfg_fini_handle(handle); 39540209230bSgjelinek return (Z_POOL_BIND); 39550209230bSgjelinek } 39560209230bSgjelinek 39570209230bSgjelinek /* 39580209230bSgjelinek * Check if we need to warn about poold not being enabled. 39590209230bSgjelinek */ 39600209230bSgjelinek if (zonecfg_warn_poold(handle)) { 39610209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: A range of dedicated-cpus has " 39620209230bSgjelinek "been specified\nbut the dynamic pool service is not " 39630209230bSgjelinek "enabled.\nThe system will not dynamically adjust the\n" 39640209230bSgjelinek "processor allocation within the specified range\n" 39650209230bSgjelinek "until svc:/system/pools/dynamic is enabled.\n" 39660209230bSgjelinek "See poold(1M)."); 39670209230bSgjelinek } 39680209230bSgjelinek 39690209230bSgjelinek /* The following is a warning, not an error. */ 39700209230bSgjelinek if ((res = zonecfg_bind_pool(handle, zoneid, pool_err, 39710209230bSgjelinek sizeof (pool_err))) != Z_OK) { 39720209230bSgjelinek if (res == Z_POOL_BIND) 39730209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: unable to bind to " 39740209230bSgjelinek "pool '%s'; using default pool.", pool_err); 39750209230bSgjelinek else if (res == Z_POOL) 39760209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: %s: %s", 39770209230bSgjelinek zonecfg_strerror(res), pool_err); 39780209230bSgjelinek else 39790209230bSgjelinek zerror(zlogp, B_FALSE, "WARNING: %s", 39800209230bSgjelinek zonecfg_strerror(res)); 39810209230bSgjelinek } 39820209230bSgjelinek 39830209230bSgjelinek zonecfg_fini_handle(handle); 39840209230bSgjelinek return (Z_OK); 39850209230bSgjelinek } 39860209230bSgjelinek 39875679c89fSjv227347 /* 39885679c89fSjv227347 * Sets the hostid of the new zone based on its configured value. The zone's 39895679c89fSjv227347 * zone_t structure must already exist in kernel memory. 'zlogp' refers to the 39905679c89fSjv227347 * log used to report errors and warnings and must be non-NULL. 'zone_namep' 39915679c89fSjv227347 * is the name of the new zone and must be non-NULL. 'zoneid' is the numeric 39925679c89fSjv227347 * ID of the new zone. 39935679c89fSjv227347 * 39945679c89fSjv227347 * This function returns zero on success and a nonzero error code on failure. 39955679c89fSjv227347 */ 39965679c89fSjv227347 static int 39975679c89fSjv227347 setup_zone_hostid(zlog_t *zlogp, char *zone_namep, zoneid_t zoneid) 39985679c89fSjv227347 { 39995679c89fSjv227347 int res; 40005679c89fSjv227347 zone_dochandle_t handle; 40015679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 40025679c89fSjv227347 unsigned int hostid; 40035679c89fSjv227347 40045679c89fSjv227347 if ((handle = zonecfg_init_handle()) == NULL) { 40055679c89fSjv227347 zerror(zlogp, B_TRUE, "getting zone configuration handle"); 40065679c89fSjv227347 return (Z_BAD_HANDLE); 40075679c89fSjv227347 } 40085679c89fSjv227347 if ((res = zonecfg_get_snapshot_handle(zone_namep, handle)) != Z_OK) { 40095679c89fSjv227347 zerror(zlogp, B_FALSE, "invalid configuration"); 40105679c89fSjv227347 zonecfg_fini_handle(handle); 40115679c89fSjv227347 return (res); 40125679c89fSjv227347 } 40135679c89fSjv227347 40145679c89fSjv227347 if ((res = zonecfg_get_hostid(handle, hostidp, sizeof (hostidp))) == 40155679c89fSjv227347 Z_OK) { 40165679c89fSjv227347 if (zonecfg_valid_hostid(hostidp) != Z_OK) { 40175679c89fSjv227347 zerror(zlogp, B_FALSE, 40185679c89fSjv227347 "zone hostid is not valid: %s", hostidp); 40195679c89fSjv227347 zonecfg_fini_handle(handle); 40205679c89fSjv227347 return (Z_HOSTID_FUBAR); 40215679c89fSjv227347 } 40225679c89fSjv227347 hostid = (unsigned int)strtoul(hostidp, NULL, 16); 40235679c89fSjv227347 if (zone_setattr(zoneid, ZONE_ATTR_HOSTID, &hostid, 40245679c89fSjv227347 sizeof (hostid)) != 0) { 40255679c89fSjv227347 zerror(zlogp, B_TRUE, 40265679c89fSjv227347 "zone hostid is not valid: %s", hostidp); 40275679c89fSjv227347 zonecfg_fini_handle(handle); 40285679c89fSjv227347 return (Z_SYSTEM); 40295679c89fSjv227347 } 40305679c89fSjv227347 } else if (res != Z_BAD_PROPERTY) { 40315679c89fSjv227347 /* 40325679c89fSjv227347 * Z_BAD_PROPERTY is an acceptable error value (from 40335679c89fSjv227347 * zonecfg_get_hostid()) because it indicates that the zone 40345679c89fSjv227347 * doesn't have a hostid. 40355679c89fSjv227347 */ 40365679c89fSjv227347 if (res == Z_TOO_BIG) 40375679c89fSjv227347 zerror(zlogp, B_FALSE, "hostid string in zone " 40385679c89fSjv227347 "configuration is too large."); 40395679c89fSjv227347 else 40405679c89fSjv227347 zerror(zlogp, B_TRUE, "fetching zone hostid from " 40415679c89fSjv227347 "configuration"); 40425679c89fSjv227347 zonecfg_fini_handle(handle); 40435679c89fSjv227347 return (res); 40445679c89fSjv227347 } 40455679c89fSjv227347 40465679c89fSjv227347 zonecfg_fini_handle(handle); 40475679c89fSjv227347 return (Z_OK); 40485679c89fSjv227347 } 40495679c89fSjv227347 4050108322fbScarlsonj zoneid_t 40516cfd72c6Sgjelinek vplat_create(zlog_t *zlogp, zone_mnt_t mount_cmd) 4052108322fbScarlsonj { 4053108322fbScarlsonj zoneid_t rval = -1; 40547c478bd9Sstevel@tonic-gate priv_set_t *privs; 40557c478bd9Sstevel@tonic-gate char rootpath[MAXPATHLEN]; 40567c478bd9Sstevel@tonic-gate char *rctlbuf = NULL; 4057108322fbScarlsonj size_t rctlbufsz = 0; 4058fa9e4066Sahrens char *zfsbuf = NULL; 4059fa9e4066Sahrens size_t zfsbufsz = 0; 4060108322fbScarlsonj zoneid_t zoneid = -1; 40617c478bd9Sstevel@tonic-gate int xerr; 4062108322fbScarlsonj char *kzone; 4063108322fbScarlsonj FILE *fp = NULL; 406445916cd2Sjpk tsol_zcent_t *zcent = NULL; 406545916cd2Sjpk int match = 0; 406645916cd2Sjpk int doi = 0; 4067f4b3ec61Sdh155122 int flags; 4068f4b3ec61Sdh155122 zone_iptype_t iptype; 40697c478bd9Sstevel@tonic-gate 40707c478bd9Sstevel@tonic-gate if (zone_get_rootpath(zone_name, rootpath, sizeof (rootpath)) != Z_OK) { 40717c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to determine zone root"); 40727c478bd9Sstevel@tonic-gate return (-1); 40737c478bd9Sstevel@tonic-gate } 4074108322fbScarlsonj if (zonecfg_in_alt_root()) 4075108322fbScarlsonj resolve_lofs(zlogp, rootpath, sizeof (rootpath)); 40767c478bd9Sstevel@tonic-gate 4077f4b3ec61Sdh155122 if (get_iptype(zlogp, &iptype) < 0) { 4078f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 4079f4b3ec61Sdh155122 return (-1); 4080f4b3ec61Sdh155122 } 4081f4b3ec61Sdh155122 switch (iptype) { 4082f4b3ec61Sdh155122 case ZS_SHARED: 4083f4b3ec61Sdh155122 flags = 0; 4084f4b3ec61Sdh155122 break; 4085f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 4086f4b3ec61Sdh155122 flags = ZCF_NET_EXCL; 4087f4b3ec61Sdh155122 break; 4088f4b3ec61Sdh155122 } 4089f4b3ec61Sdh155122 40907c478bd9Sstevel@tonic-gate if ((privs = priv_allocset()) == NULL) { 40917c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "priv_allocset"); 40927c478bd9Sstevel@tonic-gate return (-1); 40937c478bd9Sstevel@tonic-gate } 40947c478bd9Sstevel@tonic-gate priv_emptyset(privs); 4095ffbafc53Scomay if (get_privset(zlogp, privs, mount_cmd) != 0) 40967c478bd9Sstevel@tonic-gate goto error; 4097ffbafc53Scomay 40986cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && 40996cfd72c6Sgjelinek get_rctls(zlogp, &rctlbuf, &rctlbufsz) != 0) { 41007c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "Unable to get list of rctls"); 41017c478bd9Sstevel@tonic-gate goto error; 41027c478bd9Sstevel@tonic-gate } 4103ffbafc53Scomay 4104fa9e4066Sahrens if (get_datasets(zlogp, &zfsbuf, &zfsbufsz) != 0) { 4105fa9e4066Sahrens zerror(zlogp, B_FALSE, "Unable to get list of ZFS datasets"); 4106fa9e4066Sahrens goto error; 4107fa9e4066Sahrens } 41087c478bd9Sstevel@tonic-gate 41096cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && is_system_labeled()) { 411045916cd2Sjpk zcent = get_zone_label(zlogp, privs); 411148451833Scarlsonj if (zcent != NULL) { 411245916cd2Sjpk match = zcent->zc_match; 411345916cd2Sjpk doi = zcent->zc_doi; 411445916cd2Sjpk *zlabel = zcent->zc_label; 411545916cd2Sjpk } else { 411645916cd2Sjpk goto error; 411745916cd2Sjpk } 411845916cd2Sjpk } 411945916cd2Sjpk 4120108322fbScarlsonj kzone = zone_name; 4121108322fbScarlsonj 4122108322fbScarlsonj /* 4123108322fbScarlsonj * We must do this scan twice. First, we look for zones running on the 4124108322fbScarlsonj * main system that are using this root (or any subdirectory of it). 4125108322fbScarlsonj * Next, we reduce to the shortest path and search for loopback mounts 4126108322fbScarlsonj * that use this same source node (same device and inode). 4127108322fbScarlsonj */ 4128108322fbScarlsonj if (duplicate_zone_root(zlogp, rootpath)) 4129108322fbScarlsonj goto error; 4130108322fbScarlsonj if (duplicate_reachable_path(zlogp, rootpath)) 4131108322fbScarlsonj goto error; 4132108322fbScarlsonj 41336cfd72c6Sgjelinek if (ALT_MOUNT(mount_cmd)) { 4134108322fbScarlsonj root_to_lu(zlogp, rootpath, sizeof (rootpath), B_TRUE); 4135108322fbScarlsonj 4136108322fbScarlsonj /* 4137108322fbScarlsonj * Forge up a special root for this zone. When a zone is 4138108322fbScarlsonj * mounted, we can't let the zone have its own root because the 4139108322fbScarlsonj * tools that will be used in this "scratch zone" need access 4140108322fbScarlsonj * to both the zone's resources and the running machine's 4141108322fbScarlsonj * executables. 4142108322fbScarlsonj * 4143108322fbScarlsonj * Note that the mkdir here also catches read-only filesystems. 4144108322fbScarlsonj */ 4145108322fbScarlsonj if (mkdir(rootpath, 0755) != 0 && errno != EEXIST) { 4146108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot create %s", rootpath); 4147108322fbScarlsonj goto error; 4148108322fbScarlsonj } 4149108322fbScarlsonj if (domount(zlogp, "tmpfs", "", "swap", rootpath) != 0) 4150108322fbScarlsonj goto error; 4151108322fbScarlsonj } 4152108322fbScarlsonj 4153108322fbScarlsonj if (zonecfg_in_alt_root()) { 4154108322fbScarlsonj /* 4155108322fbScarlsonj * If we are mounting up a zone in an alternate root partition, 4156108322fbScarlsonj * then we have some additional work to do before starting the 4157108322fbScarlsonj * zone. First, resolve the root path down so that we're not 4158108322fbScarlsonj * fooled by duplicates. Then forge up an internal name for 4159108322fbScarlsonj * the zone. 4160108322fbScarlsonj */ 4161108322fbScarlsonj if ((fp = zonecfg_open_scratch("", B_TRUE)) == NULL) { 4162108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot open mapfile"); 4163108322fbScarlsonj goto error; 4164108322fbScarlsonj } 4165108322fbScarlsonj if (zonecfg_lock_scratch(fp) != 0) { 4166108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot lock mapfile"); 4167108322fbScarlsonj goto error; 4168108322fbScarlsonj } 4169108322fbScarlsonj if (zonecfg_find_scratch(fp, zone_name, zonecfg_get_root(), 4170108322fbScarlsonj NULL, 0) == 0) { 4171108322fbScarlsonj zerror(zlogp, B_FALSE, "scratch zone already running"); 4172108322fbScarlsonj goto error; 4173108322fbScarlsonj } 4174108322fbScarlsonj /* This is the preferred name */ 4175108322fbScarlsonj (void) snprintf(kernzone, sizeof (kernzone), "SUNWlu-%s", 4176108322fbScarlsonj zone_name); 4177108322fbScarlsonj srandom(getpid()); 4178108322fbScarlsonj while (zonecfg_reverse_scratch(fp, kernzone, NULL, 0, NULL, 4179108322fbScarlsonj 0) == 0) { 4180108322fbScarlsonj /* This is just an arbitrary name; note "." usage */ 4181108322fbScarlsonj (void) snprintf(kernzone, sizeof (kernzone), 4182108322fbScarlsonj "SUNWlu.%08lX%08lX", random(), random()); 4183108322fbScarlsonj } 4184108322fbScarlsonj kzone = kernzone; 4185108322fbScarlsonj } 4186108322fbScarlsonj 41877c478bd9Sstevel@tonic-gate xerr = 0; 4188108322fbScarlsonj if ((zoneid = zone_create(kzone, rootpath, privs, rctlbuf, 4189f4b3ec61Sdh155122 rctlbufsz, zfsbuf, zfsbufsz, &xerr, match, doi, zlabel, 4190f4b3ec61Sdh155122 flags)) == -1) { 41917c478bd9Sstevel@tonic-gate if (xerr == ZE_AREMOUNTS) { 41927c478bd9Sstevel@tonic-gate if (zonecfg_find_mounts(rootpath, NULL, NULL) < 1) { 41937c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 41947c478bd9Sstevel@tonic-gate "An unknown file-system is mounted on " 41957c478bd9Sstevel@tonic-gate "a subdirectory of %s", rootpath); 41967c478bd9Sstevel@tonic-gate } else { 41977c478bd9Sstevel@tonic-gate 41987c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 41997c478bd9Sstevel@tonic-gate "These file-systems are mounted on " 42007c478bd9Sstevel@tonic-gate "subdirectories of %s:", rootpath); 42017c478bd9Sstevel@tonic-gate (void) zonecfg_find_mounts(rootpath, 42027c478bd9Sstevel@tonic-gate prtmount, zlogp); 42037c478bd9Sstevel@tonic-gate } 42047c478bd9Sstevel@tonic-gate } else if (xerr == ZE_CHROOTED) { 42057c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "%s: " 42067c478bd9Sstevel@tonic-gate "cannot create a zone from a chrooted " 42077c478bd9Sstevel@tonic-gate "environment", "zone_create"); 42088c55461bSton } else if (xerr == ZE_LABELINUSE) { 42098c55461bSton char zonename[ZONENAME_MAX]; 42108c55461bSton (void) getzonenamebyid(getzoneidbylabel(zlabel), 42118c55461bSton zonename, ZONENAME_MAX); 42128c55461bSton zerror(zlogp, B_FALSE, "The zone label is already " 42138c55461bSton "used by the zone '%s'.", zonename); 42147c478bd9Sstevel@tonic-gate } else { 42157c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "zone_create"); 42167c478bd9Sstevel@tonic-gate } 42177c478bd9Sstevel@tonic-gate goto error; 42187c478bd9Sstevel@tonic-gate } 4219108322fbScarlsonj 4220108322fbScarlsonj if (zonecfg_in_alt_root() && 4221108322fbScarlsonj zonecfg_add_scratch(fp, zone_name, kernzone, 4222108322fbScarlsonj zonecfg_get_root()) == -1) { 4223108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot add mapfile entry"); 4224108322fbScarlsonj goto error; 4225108322fbScarlsonj } 4226108322fbScarlsonj 42270679f794S /* 42280679f794S * The following actions are not performed when merely mounting a zone 42290679f794S * for administrative use. 42300679f794S */ 42310679f794S if (mount_cmd == Z_MNT_BOOT) { 42320679f794S brand_handle_t bh; 42330679f794S struct brand_attr attr; 42340679f794S char modname[MAXPATHLEN]; 42350679f794S 42365679c89fSjv227347 if (setup_zone_hostid(zlogp, zone_name, zoneid) != Z_OK) 42375679c89fSjv227347 goto error; 42385679c89fSjv227347 42399acbbeafSnn35248 if ((zone_get_brand(zone_name, attr.ba_brandname, 42409acbbeafSnn35248 MAXNAMELEN) != Z_OK) || 4241123807fbSedp (bh = brand_open(attr.ba_brandname)) == NULL) { 42420679f794S zerror(zlogp, B_FALSE, 42430679f794S "unable to determine brand name"); 42445679c89fSjv227347 goto error; 42459acbbeafSnn35248 } 42469acbbeafSnn35248 42479a5d73e0SRic Aleshire if (!is_system_labeled() && 42489a5d73e0SRic Aleshire (strcmp(attr.ba_brandname, LABELED_BRAND_NAME) == 0)) { 42499a5d73e0SRic Aleshire brand_close(bh); 42509a5d73e0SRic Aleshire zerror(zlogp, B_FALSE, 42519a5d73e0SRic Aleshire "cannot boot labeled zone on unlabeled system"); 42529a5d73e0SRic Aleshire goto error; 42539a5d73e0SRic Aleshire } 42549a5d73e0SRic Aleshire 42559acbbeafSnn35248 /* 42569acbbeafSnn35248 * If this brand requires any kernel support, now is the time to 42579acbbeafSnn35248 * get it loaded and initialized. 42589acbbeafSnn35248 */ 4259123807fbSedp if (brand_get_modname(bh, modname, MAXPATHLEN) < 0) { 4260e767a340Sgjelinek brand_close(bh); 42610679f794S zerror(zlogp, B_FALSE, 42620679f794S "unable to determine brand kernel module"); 42635679c89fSjv227347 goto error; 42649acbbeafSnn35248 } 4265e767a340Sgjelinek brand_close(bh); 42669acbbeafSnn35248 42679acbbeafSnn35248 if (strlen(modname) > 0) { 42689acbbeafSnn35248 (void) strlcpy(attr.ba_modname, modname, MAXPATHLEN); 42699acbbeafSnn35248 if (zone_setattr(zoneid, ZONE_ATTR_BRAND, &attr, 42709acbbeafSnn35248 sizeof (attr) != 0)) { 42710679f794S zerror(zlogp, B_TRUE, 42720679f794S "could not set zone brand attribute."); 42739acbbeafSnn35248 goto error; 42749acbbeafSnn35248 } 42759acbbeafSnn35248 } 42769acbbeafSnn35248 42775679c89fSjv227347 if (setup_zone_rm(zlogp, zone_name, zoneid) != Z_OK) 42780209230bSgjelinek goto error; 42790209230bSgjelinek 428045916cd2Sjpk set_mlps(zlogp, zoneid, zcent); 42810209230bSgjelinek } 42820209230bSgjelinek 4283108322fbScarlsonj rval = zoneid; 4284108322fbScarlsonj zoneid = -1; 4285108322fbScarlsonj 42867c478bd9Sstevel@tonic-gate error: 42875679c89fSjv227347 if (zoneid != -1) { 42885679c89fSjv227347 (void) zone_shutdown(zoneid); 4289108322fbScarlsonj (void) zone_destroy(zoneid); 42905679c89fSjv227347 } 42917c478bd9Sstevel@tonic-gate if (rctlbuf != NULL) 42927c478bd9Sstevel@tonic-gate free(rctlbuf); 42937c478bd9Sstevel@tonic-gate priv_freeset(privs); 4294108322fbScarlsonj if (fp != NULL) 4295108322fbScarlsonj zonecfg_close_scratch(fp); 4296108322fbScarlsonj lofs_discard_mnttab(); 429745916cd2Sjpk if (zcent != NULL) 429845916cd2Sjpk tsol_freezcent(zcent); 42997c478bd9Sstevel@tonic-gate return (rval); 43007c478bd9Sstevel@tonic-gate } 43017c478bd9Sstevel@tonic-gate 4302555afedfScarlsonj /* 4303555afedfScarlsonj * Enter the zone and write a /etc/zones/index file there. This allows 4304555afedfScarlsonj * libzonecfg (and thus zoneadm) to report the UUID and potentially other zone 4305555afedfScarlsonj * details from inside the zone. 4306555afedfScarlsonj */ 4307555afedfScarlsonj static void 4308555afedfScarlsonj write_index_file(zoneid_t zoneid) 4309555afedfScarlsonj { 4310555afedfScarlsonj FILE *zef; 4311555afedfScarlsonj FILE *zet; 4312555afedfScarlsonj struct zoneent *zep; 4313555afedfScarlsonj pid_t child; 4314555afedfScarlsonj int tmpl_fd; 4315555afedfScarlsonj ctid_t ct; 4316555afedfScarlsonj int fd; 4317555afedfScarlsonj char uuidstr[UUID_PRINTABLE_STRING_LENGTH]; 4318555afedfScarlsonj 4319555afedfScarlsonj /* Locate the zone entry in the global zone's index file */ 4320555afedfScarlsonj if ((zef = setzoneent()) == NULL) 4321555afedfScarlsonj return; 4322555afedfScarlsonj while ((zep = getzoneent_private(zef)) != NULL) { 4323555afedfScarlsonj if (strcmp(zep->zone_name, zone_name) == 0) 4324555afedfScarlsonj break; 4325555afedfScarlsonj free(zep); 4326555afedfScarlsonj } 4327555afedfScarlsonj endzoneent(zef); 4328555afedfScarlsonj if (zep == NULL) 4329555afedfScarlsonj return; 4330555afedfScarlsonj 4331555afedfScarlsonj if ((tmpl_fd = init_template()) == -1) { 4332555afedfScarlsonj free(zep); 4333555afedfScarlsonj return; 4334555afedfScarlsonj } 4335555afedfScarlsonj 4336555afedfScarlsonj if ((child = fork()) == -1) { 4337555afedfScarlsonj (void) ct_tmpl_clear(tmpl_fd); 4338555afedfScarlsonj (void) close(tmpl_fd); 4339555afedfScarlsonj free(zep); 4340555afedfScarlsonj return; 4341555afedfScarlsonj } 4342555afedfScarlsonj 4343555afedfScarlsonj /* parent waits for child to finish */ 4344555afedfScarlsonj if (child != 0) { 4345555afedfScarlsonj free(zep); 4346555afedfScarlsonj if (contract_latest(&ct) == -1) 4347555afedfScarlsonj ct = -1; 4348555afedfScarlsonj (void) ct_tmpl_clear(tmpl_fd); 4349555afedfScarlsonj (void) close(tmpl_fd); 4350555afedfScarlsonj (void) waitpid(child, NULL, 0); 4351555afedfScarlsonj (void) contract_abandon_id(ct); 4352555afedfScarlsonj return; 4353555afedfScarlsonj } 4354555afedfScarlsonj 4355555afedfScarlsonj /* child enters zone and sets up index file */ 4356555afedfScarlsonj (void) ct_tmpl_clear(tmpl_fd); 4357555afedfScarlsonj if (zone_enter(zoneid) != -1) { 4358555afedfScarlsonj (void) mkdir(ZONE_CONFIG_ROOT, ZONE_CONFIG_MODE); 4359555afedfScarlsonj (void) chown(ZONE_CONFIG_ROOT, ZONE_CONFIG_UID, 4360555afedfScarlsonj ZONE_CONFIG_GID); 4361555afedfScarlsonj fd = open(ZONE_INDEX_FILE, O_WRONLY|O_CREAT|O_TRUNC, 4362555afedfScarlsonj ZONE_INDEX_MODE); 4363555afedfScarlsonj if (fd != -1 && (zet = fdopen(fd, "w")) != NULL) { 4364555afedfScarlsonj (void) fchown(fd, ZONE_INDEX_UID, ZONE_INDEX_GID); 4365555afedfScarlsonj if (uuid_is_null(zep->zone_uuid)) 4366555afedfScarlsonj uuidstr[0] = '\0'; 4367555afedfScarlsonj else 4368555afedfScarlsonj uuid_unparse(zep->zone_uuid, uuidstr); 4369555afedfScarlsonj (void) fprintf(zet, "%s:%s:/:%s\n", zep->zone_name, 4370555afedfScarlsonj zone_state_str(zep->zone_state), 4371555afedfScarlsonj uuidstr); 4372555afedfScarlsonj (void) fclose(zet); 4373555afedfScarlsonj } 4374555afedfScarlsonj } 4375555afedfScarlsonj _exit(0); 4376555afedfScarlsonj } 4377555afedfScarlsonj 43787c478bd9Sstevel@tonic-gate int 43796cfd72c6Sgjelinek vplat_bringup(zlog_t *zlogp, zone_mnt_t mount_cmd, zoneid_t zoneid) 43807c478bd9Sstevel@tonic-gate { 43819acbbeafSnn35248 char zonepath[MAXPATHLEN]; 43825749802bSdp 43836cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT && validate_datasets(zlogp) != 0) { 4384fa9e4066Sahrens lofs_discard_mnttab(); 4385fa9e4066Sahrens return (-1); 4386fa9e4066Sahrens } 4387fa9e4066Sahrens 43889acbbeafSnn35248 /* 43899acbbeafSnn35248 * Before we try to mount filesystems we need to create the 43909acbbeafSnn35248 * attribute backing store for /dev 43919acbbeafSnn35248 */ 43929acbbeafSnn35248 if (zone_get_zonepath(zone_name, zonepath, sizeof (zonepath)) != Z_OK) { 43939acbbeafSnn35248 lofs_discard_mnttab(); 43949acbbeafSnn35248 return (-1); 43959acbbeafSnn35248 } 439616bca938Svp157776 resolve_lofs(zlogp, zonepath, sizeof (zonepath)); 439727e6fb21Sdp 439827e6fb21Sdp /* Make /dev directory owned by root, grouped sys */ 439927e6fb21Sdp if (make_one_dir(zlogp, zonepath, "/dev", DEFAULT_DIR_MODE, 440027e6fb21Sdp 0, 3) != 0) { 4401108322fbScarlsonj lofs_discard_mnttab(); 44027c478bd9Sstevel@tonic-gate return (-1); 4403108322fbScarlsonj } 4404facf4a8dSllai1 44059acbbeafSnn35248 if (mount_filesystems(zlogp, mount_cmd) != 0) { 4406facf4a8dSllai1 lofs_discard_mnttab(); 4407facf4a8dSllai1 return (-1); 4408facf4a8dSllai1 } 4409facf4a8dSllai1 44106cfd72c6Sgjelinek if (mount_cmd == Z_MNT_BOOT) { 4411f4b3ec61Sdh155122 zone_iptype_t iptype; 4412f4b3ec61Sdh155122 4413f4b3ec61Sdh155122 if (get_iptype(zlogp, &iptype) < 0) { 4414f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine ip-type"); 4415108322fbScarlsonj lofs_discard_mnttab(); 44167c478bd9Sstevel@tonic-gate return (-1); 4417108322fbScarlsonj } 4418555afedfScarlsonj 4419f4b3ec61Sdh155122 switch (iptype) { 4420f4b3ec61Sdh155122 case ZS_SHARED: 4421f4b3ec61Sdh155122 /* Always do this to make lo0 get configured */ 4422f4b3ec61Sdh155122 if (configure_shared_network_interfaces(zlogp) != 0) { 4423f4b3ec61Sdh155122 lofs_discard_mnttab(); 4424f4b3ec61Sdh155122 return (-1); 4425f4b3ec61Sdh155122 } 4426f4b3ec61Sdh155122 break; 4427f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 4428f4b3ec61Sdh155122 if (configure_exclusive_network_interfaces(zlogp) != 4429f4b3ec61Sdh155122 0) { 4430f4b3ec61Sdh155122 lofs_discard_mnttab(); 4431f4b3ec61Sdh155122 return (-1); 4432f4b3ec61Sdh155122 } 4433f4b3ec61Sdh155122 break; 4434f4b3ec61Sdh155122 } 4435f4b3ec61Sdh155122 } 4436f4b3ec61Sdh155122 4437555afedfScarlsonj write_index_file(zoneid); 4438555afedfScarlsonj 4439108322fbScarlsonj lofs_discard_mnttab(); 44407c478bd9Sstevel@tonic-gate return (0); 44417c478bd9Sstevel@tonic-gate } 44427c478bd9Sstevel@tonic-gate 4443108322fbScarlsonj static int 4444108322fbScarlsonj lu_root_teardown(zlog_t *zlogp) 44457c478bd9Sstevel@tonic-gate { 4446108322fbScarlsonj char zroot[MAXPATHLEN]; 4447108322fbScarlsonj 4448108322fbScarlsonj if (zone_get_rootpath(zone_name, zroot, sizeof (zroot)) != Z_OK) { 4449108322fbScarlsonj zerror(zlogp, B_FALSE, "unable to determine zone root"); 4450108322fbScarlsonj return (-1); 4451108322fbScarlsonj } 4452108322fbScarlsonj root_to_lu(zlogp, zroot, sizeof (zroot), B_FALSE); 4453108322fbScarlsonj 4454108322fbScarlsonj /* 4455108322fbScarlsonj * At this point, the processes are gone, the filesystems (save the 4456108322fbScarlsonj * root) are unmounted, and the zone is on death row. But there may 4457108322fbScarlsonj * still be creds floating about in the system that reference the 4458108322fbScarlsonj * zone_t, and which pin down zone_rootvp causing this call to fail 4459108322fbScarlsonj * with EBUSY. Thus, we try for a little while before just giving up. 4460108322fbScarlsonj * (How I wish this were not true, and umount2 just did the right 4461108322fbScarlsonj * thing, or tmpfs supported MS_FORCE This is a gross hack.) 4462108322fbScarlsonj */ 4463108322fbScarlsonj if (umount2(zroot, MS_FORCE) != 0) { 4464108322fbScarlsonj if (errno == ENOTSUP && umount2(zroot, 0) == 0) 4465108322fbScarlsonj goto unmounted; 4466108322fbScarlsonj if (errno == EBUSY) { 4467108322fbScarlsonj int tries = 10; 4468108322fbScarlsonj 4469108322fbScarlsonj while (--tries >= 0) { 4470108322fbScarlsonj (void) sleep(1); 4471108322fbScarlsonj if (umount2(zroot, 0) == 0) 4472108322fbScarlsonj goto unmounted; 4473108322fbScarlsonj if (errno != EBUSY) 4474108322fbScarlsonj break; 4475108322fbScarlsonj } 4476108322fbScarlsonj } 4477108322fbScarlsonj zerror(zlogp, B_TRUE, "unable to unmount '%s'", zroot); 4478108322fbScarlsonj return (-1); 4479108322fbScarlsonj } 4480108322fbScarlsonj unmounted: 4481108322fbScarlsonj 4482108322fbScarlsonj /* 4483108322fbScarlsonj * Only zones in an alternate root environment have scratch zone 4484108322fbScarlsonj * entries. 4485108322fbScarlsonj */ 4486108322fbScarlsonj if (zonecfg_in_alt_root()) { 4487108322fbScarlsonj FILE *fp; 4488108322fbScarlsonj int retv; 4489108322fbScarlsonj 4490108322fbScarlsonj if ((fp = zonecfg_open_scratch("", B_FALSE)) == NULL) { 4491108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot open mapfile"); 4492108322fbScarlsonj return (-1); 4493108322fbScarlsonj } 4494108322fbScarlsonj retv = -1; 4495108322fbScarlsonj if (zonecfg_lock_scratch(fp) != 0) 4496108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot lock mapfile"); 4497108322fbScarlsonj else if (zonecfg_delete_scratch(fp, kernzone) != 0) 4498108322fbScarlsonj zerror(zlogp, B_TRUE, "cannot delete map entry"); 4499108322fbScarlsonj else 4500108322fbScarlsonj retv = 0; 4501108322fbScarlsonj zonecfg_close_scratch(fp); 4502108322fbScarlsonj return (retv); 4503108322fbScarlsonj } else { 4504108322fbScarlsonj return (0); 4505108322fbScarlsonj } 4506108322fbScarlsonj } 4507108322fbScarlsonj 4508108322fbScarlsonj int 45090209230bSgjelinek vplat_teardown(zlog_t *zlogp, boolean_t unmount_cmd, boolean_t rebooting) 4510108322fbScarlsonj { 4511108322fbScarlsonj char *kzone; 45127c478bd9Sstevel@tonic-gate zoneid_t zoneid; 45130209230bSgjelinek int res; 45140209230bSgjelinek char pool_err[128]; 4515ff17c8bfSgjelinek char zpath[MAXPATHLEN]; 45169acbbeafSnn35248 char cmdbuf[MAXPATHLEN]; 45179acbbeafSnn35248 char brand[MAXNAMELEN]; 4518123807fbSedp brand_handle_t bh = NULL; 4519f4b3ec61Sdh155122 ushort_t flags; 45207c478bd9Sstevel@tonic-gate 4521108322fbScarlsonj kzone = zone_name; 4522108322fbScarlsonj if (zonecfg_in_alt_root()) { 4523108322fbScarlsonj FILE *fp; 4524108322fbScarlsonj 4525108322fbScarlsonj if ((fp = zonecfg_open_scratch("", B_FALSE)) == NULL) { 4526108322fbScarlsonj zerror(zlogp, B_TRUE, "unable to open map file"); 4527108322fbScarlsonj goto error; 4528108322fbScarlsonj } 4529108322fbScarlsonj if (zonecfg_find_scratch(fp, zone_name, zonecfg_get_root(), 4530108322fbScarlsonj kernzone, sizeof (kernzone)) != 0) { 4531108322fbScarlsonj zerror(zlogp, B_FALSE, "unable to find scratch zone"); 4532108322fbScarlsonj zonecfg_close_scratch(fp); 4533108322fbScarlsonj goto error; 4534108322fbScarlsonj } 4535108322fbScarlsonj zonecfg_close_scratch(fp); 4536108322fbScarlsonj kzone = kernzone; 4537108322fbScarlsonj } 4538108322fbScarlsonj 4539108322fbScarlsonj if ((zoneid = getzoneidbyname(kzone)) == ZONE_ID_UNDEFINED) { 45407c478bd9Sstevel@tonic-gate if (!bringup_failure_recovery) 45417c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to get zoneid"); 4542108322fbScarlsonj if (unmount_cmd) 4543108322fbScarlsonj (void) lu_root_teardown(zlogp); 45447c478bd9Sstevel@tonic-gate goto error; 45457c478bd9Sstevel@tonic-gate } 45467c478bd9Sstevel@tonic-gate 45477c478bd9Sstevel@tonic-gate if (zone_shutdown(zoneid) != 0) { 45487c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to shutdown zone"); 45497c478bd9Sstevel@tonic-gate goto error; 45507c478bd9Sstevel@tonic-gate } 45517c478bd9Sstevel@tonic-gate 4552ff17c8bfSgjelinek /* Get the zonepath of this zone */ 4553ff17c8bfSgjelinek if (zone_get_zonepath(zone_name, zpath, sizeof (zpath)) != Z_OK) { 4554ff17c8bfSgjelinek zerror(zlogp, B_FALSE, "unable to determine zone path"); 45559acbbeafSnn35248 goto error; 45569acbbeafSnn35248 } 45579acbbeafSnn35248 45589acbbeafSnn35248 /* Get a handle to the brand info for this zone */ 45599acbbeafSnn35248 if ((zone_get_brand(zone_name, brand, sizeof (brand)) != Z_OK) || 4560123807fbSedp (bh = brand_open(brand)) == NULL) { 45619acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine zone brand"); 45629acbbeafSnn35248 return (-1); 45639acbbeafSnn35248 } 45649acbbeafSnn35248 /* 45659acbbeafSnn35248 * If there is a brand 'halt' callback, execute it now to give the 45669acbbeafSnn35248 * brand a chance to cleanup any custom configuration. 45679acbbeafSnn35248 */ 45689acbbeafSnn35248 (void) strcpy(cmdbuf, EXEC_PREFIX); 4569ff17c8bfSgjelinek if (brand_get_halt(bh, zone_name, zpath, cmdbuf + EXEC_LEN, 4570ff17c8bfSgjelinek sizeof (cmdbuf) - EXEC_LEN) < 0) { 4571123807fbSedp brand_close(bh); 45729acbbeafSnn35248 zerror(zlogp, B_FALSE, "unable to determine branded zone's " 45739acbbeafSnn35248 "halt callback."); 45749acbbeafSnn35248 goto error; 45759acbbeafSnn35248 } 4576123807fbSedp brand_close(bh); 45779acbbeafSnn35248 45789acbbeafSnn35248 if ((strlen(cmdbuf) > EXEC_LEN) && 4579c5cd6260S (do_subproc(zlogp, cmdbuf, NULL) != Z_OK)) { 45809acbbeafSnn35248 zerror(zlogp, B_FALSE, "%s failed", cmdbuf); 45819acbbeafSnn35248 goto error; 45829acbbeafSnn35248 } 45839acbbeafSnn35248 4584f4b3ec61Sdh155122 if (!unmount_cmd) { 4585f4b3ec61Sdh155122 zone_iptype_t iptype; 4586f4b3ec61Sdh155122 4587f4b3ec61Sdh155122 if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &flags, 4588f4b3ec61Sdh155122 sizeof (flags)) < 0) { 4589f4b3ec61Sdh155122 if (get_iptype(zlogp, &iptype) < 0) { 4590f4b3ec61Sdh155122 zerror(zlogp, B_TRUE, "unable to determine " 4591f4b3ec61Sdh155122 "ip-type"); 45927c478bd9Sstevel@tonic-gate goto error; 45937c478bd9Sstevel@tonic-gate } 4594f4b3ec61Sdh155122 } else { 4595f4b3ec61Sdh155122 if (flags & ZF_NET_EXCL) 4596f4b3ec61Sdh155122 iptype = ZS_EXCLUSIVE; 4597f4b3ec61Sdh155122 else 4598f4b3ec61Sdh155122 iptype = ZS_SHARED; 4599f4b3ec61Sdh155122 } 4600f4b3ec61Sdh155122 4601f4b3ec61Sdh155122 switch (iptype) { 4602f4b3ec61Sdh155122 case ZS_SHARED: 4603f4b3ec61Sdh155122 if (unconfigure_shared_network_interfaces(zlogp, 4604f4b3ec61Sdh155122 zoneid) != 0) { 4605f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "unable to unconfigure " 4606f4b3ec61Sdh155122 "network interfaces in zone"); 4607f4b3ec61Sdh155122 goto error; 4608f4b3ec61Sdh155122 } 4609f4b3ec61Sdh155122 break; 4610f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 4611f4b3ec61Sdh155122 if (unconfigure_exclusive_network_interfaces(zlogp, 4612f4b3ec61Sdh155122 zoneid) != 0) { 4613f4b3ec61Sdh155122 zerror(zlogp, B_FALSE, "unable to unconfigure " 4614f4b3ec61Sdh155122 "network interfaces in zone"); 4615f4b3ec61Sdh155122 goto error; 4616f4b3ec61Sdh155122 } 4617f4b3ec61Sdh155122 break; 4618f4b3ec61Sdh155122 } 4619f4b3ec61Sdh155122 } 46207c478bd9Sstevel@tonic-gate 4621108322fbScarlsonj if (!unmount_cmd && tcp_abort_connections(zlogp, zoneid) != 0) { 46227c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to abort TCP connections"); 46237c478bd9Sstevel@tonic-gate goto error; 46247c478bd9Sstevel@tonic-gate } 46257c478bd9Sstevel@tonic-gate 4626108322fbScarlsonj if (unmount_filesystems(zlogp, zoneid, unmount_cmd) != 0) { 46277c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, 46287c478bd9Sstevel@tonic-gate "unable to unmount file systems in zone"); 46297c478bd9Sstevel@tonic-gate goto error; 46307c478bd9Sstevel@tonic-gate } 46317c478bd9Sstevel@tonic-gate 46320209230bSgjelinek /* 4633cf6b13d2Sgjelinek * If we are rebooting then we normally don't want to destroy an 4634cf6b13d2Sgjelinek * existing temporary pool at this point so that we can just reuse it 4635cf6b13d2Sgjelinek * when the zone boots back up. However, it is also possible we were 4636cf6b13d2Sgjelinek * running with a temporary pool and the zone configuration has been 4637cf6b13d2Sgjelinek * modified to no longer use a temporary pool. In that case we need 4638cf6b13d2Sgjelinek * to destroy the temporary pool now. This case looks like the case 4639cf6b13d2Sgjelinek * where we never had a temporary pool configured but 4640cf6b13d2Sgjelinek * zonecfg_destroy_tmp_pool will do the right thing either way. 46410209230bSgjelinek */ 4642cf6b13d2Sgjelinek if (!unmount_cmd) { 4643cf6b13d2Sgjelinek boolean_t destroy_tmp_pool = B_TRUE; 4644cf6b13d2Sgjelinek 4645cf6b13d2Sgjelinek if (rebooting) { 4646cf6b13d2Sgjelinek struct zone_psettab pset_tab; 4647cf6b13d2Sgjelinek zone_dochandle_t handle; 4648cf6b13d2Sgjelinek 4649cf6b13d2Sgjelinek if ((handle = zonecfg_init_handle()) != NULL && 4650cf6b13d2Sgjelinek zonecfg_get_handle(zone_name, handle) == Z_OK && 4651cf6b13d2Sgjelinek zonecfg_lookup_pset(handle, &pset_tab) == Z_OK) 4652cf6b13d2Sgjelinek destroy_tmp_pool = B_FALSE; 4653e767a340Sgjelinek 4654e767a340Sgjelinek zonecfg_fini_handle(handle); 4655cf6b13d2Sgjelinek } 4656cf6b13d2Sgjelinek 4657cf6b13d2Sgjelinek if (destroy_tmp_pool) { 46580209230bSgjelinek if ((res = zonecfg_destroy_tmp_pool(zone_name, pool_err, 46590209230bSgjelinek sizeof (pool_err))) != Z_OK) { 46600209230bSgjelinek if (res == Z_POOL) 46610209230bSgjelinek zerror(zlogp, B_FALSE, pool_err); 46620209230bSgjelinek } 46630209230bSgjelinek } 4664cf6b13d2Sgjelinek } 46650209230bSgjelinek 466645916cd2Sjpk remove_mlps(zlogp, zoneid); 466745916cd2Sjpk 46687c478bd9Sstevel@tonic-gate if (zone_destroy(zoneid) != 0) { 46697c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "unable to destroy zone"); 46707c478bd9Sstevel@tonic-gate goto error; 46717c478bd9Sstevel@tonic-gate } 4672108322fbScarlsonj 4673108322fbScarlsonj /* 4674108322fbScarlsonj * Special teardown for alternate boot environments: remove the tmpfs 4675108322fbScarlsonj * root for the zone and then remove it from the map file. 4676108322fbScarlsonj */ 4677108322fbScarlsonj if (unmount_cmd && lu_root_teardown(zlogp) != 0) 4678108322fbScarlsonj goto error; 4679108322fbScarlsonj 4680108322fbScarlsonj lofs_discard_mnttab(); 46817c478bd9Sstevel@tonic-gate return (0); 46827c478bd9Sstevel@tonic-gate 46837c478bd9Sstevel@tonic-gate error: 4684108322fbScarlsonj lofs_discard_mnttab(); 46857c478bd9Sstevel@tonic-gate return (-1); 46867c478bd9Sstevel@tonic-gate } 4687