xref: /titanic_50/usr/src/cmd/zoneadmd/vplat.c (revision f9329705048b07efa10c698cdd8e0936788f8e6f)
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