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