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