17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
5ffbafc53Scomay * Common Development and Distribution License (the "License").
6ffbafc53Scomay * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
21ffbafc53Scomay
227c478bd9Sstevel@tonic-gate /*
239d5056eaSjv * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
247c478bd9Sstevel@tonic-gate * Use is subject to license terms.
25e1c90a83SJerry Jelinek * Copyright 2012 Joyent, Inc. All rights reserved.
26741343adSAlexander Eremin * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
277c478bd9Sstevel@tonic-gate */
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate * Console support for zones requires a significant infrastructure. The
317c478bd9Sstevel@tonic-gate * core pieces are contained in this file, but other portions of note
32*bbf21555SRichard Lowe * are in the zlogin(1) command, the zcons(4D) driver, and in the
33*bbf21555SRichard Lowe * devfsadm(8) misc_link generator.
347c478bd9Sstevel@tonic-gate *
357c478bd9Sstevel@tonic-gate * Care is taken to make the console behave in an "intuitive" fashion for
367c478bd9Sstevel@tonic-gate * administrators. Essentially, we try as much as possible to mimic the
377c478bd9Sstevel@tonic-gate * experience of using a system via a tip line and system controller.
387c478bd9Sstevel@tonic-gate *
397c478bd9Sstevel@tonic-gate * The zone console architecture looks like this:
407c478bd9Sstevel@tonic-gate *
417c478bd9Sstevel@tonic-gate * Global Zone | Non-Global Zone
427c478bd9Sstevel@tonic-gate * .--------------. |
437c478bd9Sstevel@tonic-gate * .-----------. | zoneadmd -z | | .--------. .---------.
447c478bd9Sstevel@tonic-gate * | zlogin -C | | myzone | | | ttymon | | syslogd |
457c478bd9Sstevel@tonic-gate * `-----------' `--------------' | `--------' `---------'
467c478bd9Sstevel@tonic-gate * | | | | | | |
477c478bd9Sstevel@tonic-gate * User | | | | | V V
487c478bd9Sstevel@tonic-gate * - - - - - - - - -|- - - -|- - - -|-|- - - - - - -|- - /dev/zconsole - - -
497c478bd9Sstevel@tonic-gate * Kernel V V | | |
507c478bd9Sstevel@tonic-gate * [AF_UNIX Socket] | `--------. .-------------'
517c478bd9Sstevel@tonic-gate * | | |
527c478bd9Sstevel@tonic-gate * | V V
537c478bd9Sstevel@tonic-gate * | +-----------+
547c478bd9Sstevel@tonic-gate * | | ldterm, |
557c478bd9Sstevel@tonic-gate * | | etc. |
567c478bd9Sstevel@tonic-gate * | +-----------+
577c478bd9Sstevel@tonic-gate * | +-[Anchor]--+
587c478bd9Sstevel@tonic-gate * | | ptem |
597c478bd9Sstevel@tonic-gate * V +-----------+
601fa2a664SJoshua M. Clulow * +---manager--+-subsidiary+
617c478bd9Sstevel@tonic-gate * | |
627c478bd9Sstevel@tonic-gate * | zcons driver |
637c478bd9Sstevel@tonic-gate * | zonename="myzone" |
647c478bd9Sstevel@tonic-gate * +------------------------+
657c478bd9Sstevel@tonic-gate *
669d5056eaSjv * There are basically two major tasks which the console subsystem in
677c478bd9Sstevel@tonic-gate * zoneadmd accomplishes:
687c478bd9Sstevel@tonic-gate *
697c478bd9Sstevel@tonic-gate * - Setup and teardown of zcons driver instances. One zcons instance
707c478bd9Sstevel@tonic-gate * is maintained per zone; we take advantage of the libdevice APIs
717c478bd9Sstevel@tonic-gate * to online new instances of zcons as needed. Care is taken to
727c478bd9Sstevel@tonic-gate * prune and manage these appropriately; see init_console_dev() and
737c478bd9Sstevel@tonic-gate * destroy_console_dev(). The end result is the creation of the
74*bbf21555SRichard Lowe * zcons(4D) instance and an open file descriptor to the manager side.
757c478bd9Sstevel@tonic-gate * zcons instances are associated with zones via their zonename device
767c478bd9Sstevel@tonic-gate * property. This the console instance to persist across reboots,
777c478bd9Sstevel@tonic-gate * and while the zone is halted.
787c478bd9Sstevel@tonic-gate *
797c478bd9Sstevel@tonic-gate * - Acting as a server for 'zlogin -C' instances. When zlogin -C is
807c478bd9Sstevel@tonic-gate * run, zlogin connects to zoneadmd via unix domain socket. zoneadmd
817c478bd9Sstevel@tonic-gate * functions as a two-way proxy for console I/O, relaying user input
821fa2a664SJoshua M. Clulow * to the manager side of the console, and relaying output from the
837c478bd9Sstevel@tonic-gate * zone to the user.
847c478bd9Sstevel@tonic-gate */
857c478bd9Sstevel@tonic-gate
867c478bd9Sstevel@tonic-gate #include <sys/types.h>
877c478bd9Sstevel@tonic-gate #include <sys/socket.h>
887c478bd9Sstevel@tonic-gate #include <sys/stat.h>
897c478bd9Sstevel@tonic-gate #include <sys/termios.h>
907c478bd9Sstevel@tonic-gate #include <sys/zcons.h>
91facf4a8dSllai #include <sys/mkdev.h>
927c478bd9Sstevel@tonic-gate
937c478bd9Sstevel@tonic-gate #include <assert.h>
947c478bd9Sstevel@tonic-gate #include <ctype.h>
957c478bd9Sstevel@tonic-gate #include <errno.h>
967c478bd9Sstevel@tonic-gate #include <fcntl.h>
977c478bd9Sstevel@tonic-gate #include <stdarg.h>
987c478bd9Sstevel@tonic-gate #include <stdio.h>
997c478bd9Sstevel@tonic-gate #include <stdlib.h>
1007c478bd9Sstevel@tonic-gate #include <strings.h>
1017c478bd9Sstevel@tonic-gate #include <stropts.h>
1027c478bd9Sstevel@tonic-gate #include <thread.h>
1037c478bd9Sstevel@tonic-gate #include <ucred.h>
1047c478bd9Sstevel@tonic-gate #include <unistd.h>
1057c478bd9Sstevel@tonic-gate #include <zone.h>
1067c478bd9Sstevel@tonic-gate
1077c478bd9Sstevel@tonic-gate #include <libdevinfo.h>
1087c478bd9Sstevel@tonic-gate #include <libdevice.h>
1097c478bd9Sstevel@tonic-gate #include <libzonecfg.h>
1107c478bd9Sstevel@tonic-gate
1117c478bd9Sstevel@tonic-gate #include <syslog.h>
112facf4a8dSllai #include <sys/modctl.h>
1137c478bd9Sstevel@tonic-gate
1147c478bd9Sstevel@tonic-gate #include "zoneadmd.h"
1157c478bd9Sstevel@tonic-gate
1167c478bd9Sstevel@tonic-gate #define ZCONSNEX_DEVTREEPATH "/pseudo/zconsnex@1"
1177c478bd9Sstevel@tonic-gate #define ZCONSNEX_FILEPATH "/devices/pseudo/zconsnex@1"
1187c478bd9Sstevel@tonic-gate
1197c478bd9Sstevel@tonic-gate #define CONSOLE_SOCKPATH ZONES_TMPDIR "/%s.console_sock"
1207c478bd9Sstevel@tonic-gate
1217c478bd9Sstevel@tonic-gate static int serverfd = -1; /* console server unix domain socket fd */
1223f2f09c1Sdp char boot_args[BOOTARGS_MAX];
1233f2f09c1Sdp char bad_boot_arg[BOOTARGS_MAX];
1247c478bd9Sstevel@tonic-gate
1257c478bd9Sstevel@tonic-gate /*
1267c478bd9Sstevel@tonic-gate * The eventstream is a simple one-directional flow of messages from the
1277c478bd9Sstevel@tonic-gate * door server to the console subsystem, implemented with a pipe.
1287c478bd9Sstevel@tonic-gate * It is used to wake up the console poller when it needs to take action,
1297c478bd9Sstevel@tonic-gate * message the user, die off, etc.
1307c478bd9Sstevel@tonic-gate */
1317c478bd9Sstevel@tonic-gate static int eventstream[2];
1327c478bd9Sstevel@tonic-gate
1333f2f09c1Sdp
1343f2f09c1Sdp
1357c478bd9Sstevel@tonic-gate int
eventstream_init()1367c478bd9Sstevel@tonic-gate eventstream_init()
1377c478bd9Sstevel@tonic-gate {
1387c478bd9Sstevel@tonic-gate if (pipe(eventstream) == -1)
1397c478bd9Sstevel@tonic-gate return (-1);
1407c478bd9Sstevel@tonic-gate return (0);
1417c478bd9Sstevel@tonic-gate }
1427c478bd9Sstevel@tonic-gate
1437c478bd9Sstevel@tonic-gate void
eventstream_write(zone_evt_t evt)1447c478bd9Sstevel@tonic-gate eventstream_write(zone_evt_t evt)
1457c478bd9Sstevel@tonic-gate {
1467c478bd9Sstevel@tonic-gate (void) write(eventstream[0], &evt, sizeof (evt));
1477c478bd9Sstevel@tonic-gate }
1487c478bd9Sstevel@tonic-gate
1497c478bd9Sstevel@tonic-gate static zone_evt_t
eventstream_read(void)1507c478bd9Sstevel@tonic-gate eventstream_read(void)
1517c478bd9Sstevel@tonic-gate {
1527c478bd9Sstevel@tonic-gate zone_evt_t evt = Z_EVT_NULL;
1537c478bd9Sstevel@tonic-gate
1547c478bd9Sstevel@tonic-gate (void) read(eventstream[1], &evt, sizeof (evt));
1557c478bd9Sstevel@tonic-gate return (evt);
1567c478bd9Sstevel@tonic-gate }
1577c478bd9Sstevel@tonic-gate
1587c478bd9Sstevel@tonic-gate /*
1597c478bd9Sstevel@tonic-gate * count_console_devs() and its helper count_cb() do a walk of the
1607c478bd9Sstevel@tonic-gate * subtree of the device tree where zone console nodes are represented.
1617c478bd9Sstevel@tonic-gate * The goal is to count zone console instances already setup for a zone
1627c478bd9Sstevel@tonic-gate * with the given name. More than 1 is anomolous, and our caller will
1637c478bd9Sstevel@tonic-gate * have to deal with that if we find that's the case.
1647c478bd9Sstevel@tonic-gate *
1657c478bd9Sstevel@tonic-gate * Note: this algorithm is a linear search of nodes in the zconsnex subtree
1667c478bd9Sstevel@tonic-gate * of the device tree, and could be a scalability problem, but I don't see
1677c478bd9Sstevel@tonic-gate * how to avoid it.
1687c478bd9Sstevel@tonic-gate */
1697c478bd9Sstevel@tonic-gate
1707c478bd9Sstevel@tonic-gate /*
1717c478bd9Sstevel@tonic-gate * cb_data is shared by count_cb and destroy_cb for simplicity.
1727c478bd9Sstevel@tonic-gate */
1737c478bd9Sstevel@tonic-gate struct cb_data {
1747c478bd9Sstevel@tonic-gate zlog_t *zlogp;
1757c478bd9Sstevel@tonic-gate int found;
1767c478bd9Sstevel@tonic-gate int killed;
1777c478bd9Sstevel@tonic-gate };
1787c478bd9Sstevel@tonic-gate
1797c478bd9Sstevel@tonic-gate static int
count_cb(di_node_t node,void * arg)1807c478bd9Sstevel@tonic-gate count_cb(di_node_t node, void *arg)
1817c478bd9Sstevel@tonic-gate {
1827c478bd9Sstevel@tonic-gate struct cb_data *cb = (struct cb_data *)arg;
1837c478bd9Sstevel@tonic-gate char *prop_data;
1847c478bd9Sstevel@tonic-gate
1857c478bd9Sstevel@tonic-gate if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "zonename",
1867c478bd9Sstevel@tonic-gate &prop_data) != -1) {
1877c478bd9Sstevel@tonic-gate assert(prop_data != NULL);
1887c478bd9Sstevel@tonic-gate if (strcmp(prop_data, zone_name) == 0) {
1897c478bd9Sstevel@tonic-gate cb->found++;
1907c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE);
1917c478bd9Sstevel@tonic-gate }
1927c478bd9Sstevel@tonic-gate }
1937c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE);
1947c478bd9Sstevel@tonic-gate }
1957c478bd9Sstevel@tonic-gate
1967c478bd9Sstevel@tonic-gate static int
count_console_devs(zlog_t * zlogp)1977c478bd9Sstevel@tonic-gate count_console_devs(zlog_t *zlogp)
1987c478bd9Sstevel@tonic-gate {
1997c478bd9Sstevel@tonic-gate di_node_t root;
2007c478bd9Sstevel@tonic-gate struct cb_data cb;
2017c478bd9Sstevel@tonic-gate
2027c478bd9Sstevel@tonic-gate bzero(&cb, sizeof (cb));
2037c478bd9Sstevel@tonic-gate cb.zlogp = zlogp;
2047c478bd9Sstevel@tonic-gate
2057c478bd9Sstevel@tonic-gate if ((root = di_init(ZCONSNEX_DEVTREEPATH, DINFOCPYALL)) ==
2067c478bd9Sstevel@tonic-gate DI_NODE_NIL) {
2077c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "di_init");
2087c478bd9Sstevel@tonic-gate return (-1);
2097c478bd9Sstevel@tonic-gate }
2107c478bd9Sstevel@tonic-gate
2117c478bd9Sstevel@tonic-gate (void) di_walk_node(root, DI_WALK_CLDFIRST, (void *)&cb, count_cb);
2127c478bd9Sstevel@tonic-gate di_fini(root);
2137c478bd9Sstevel@tonic-gate return (cb.found);
2147c478bd9Sstevel@tonic-gate }
2157c478bd9Sstevel@tonic-gate
2167c478bd9Sstevel@tonic-gate /*
2177c478bd9Sstevel@tonic-gate * destroy_console_devs() and its helper destroy_cb() tears down any console
2187c478bd9Sstevel@tonic-gate * instances associated with this zone. If things went very wrong, we
2197c478bd9Sstevel@tonic-gate * might have more than one console instance hanging around. This routine
2207c478bd9Sstevel@tonic-gate * hunts down and tries to remove all of them. Of course, if the console
2217c478bd9Sstevel@tonic-gate * is open, the instance will not detach, which is a potential issue.
2227c478bd9Sstevel@tonic-gate */
2237c478bd9Sstevel@tonic-gate static int
destroy_cb(di_node_t node,void * arg)2247c478bd9Sstevel@tonic-gate destroy_cb(di_node_t node, void *arg)
2257c478bd9Sstevel@tonic-gate {
2267c478bd9Sstevel@tonic-gate struct cb_data *cb = (struct cb_data *)arg;
2277c478bd9Sstevel@tonic-gate char *prop_data;
2287c478bd9Sstevel@tonic-gate char *tmp;
2297c478bd9Sstevel@tonic-gate char devpath[MAXPATHLEN];
2307c478bd9Sstevel@tonic-gate devctl_hdl_t hdl;
2317c478bd9Sstevel@tonic-gate
2327c478bd9Sstevel@tonic-gate if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "zonename",
2337c478bd9Sstevel@tonic-gate &prop_data) == -1)
2347c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE);
2357c478bd9Sstevel@tonic-gate
2367c478bd9Sstevel@tonic-gate assert(prop_data != NULL);
2377c478bd9Sstevel@tonic-gate if (strcmp(prop_data, zone_name) != 0) {
2387c478bd9Sstevel@tonic-gate /* this is the console for a different zone */
2397c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE);
2407c478bd9Sstevel@tonic-gate }
2417c478bd9Sstevel@tonic-gate
2427c478bd9Sstevel@tonic-gate cb->found++;
2437c478bd9Sstevel@tonic-gate tmp = di_devfs_path(node);
2447c478bd9Sstevel@tonic-gate (void) snprintf(devpath, sizeof (devpath), "/devices/%s", tmp);
2457c478bd9Sstevel@tonic-gate di_devfs_path_free(tmp);
2467c478bd9Sstevel@tonic-gate
2477c478bd9Sstevel@tonic-gate if ((hdl = devctl_device_acquire(devpath, 0)) == NULL) {
2487c478bd9Sstevel@tonic-gate zerror(cb->zlogp, B_TRUE, "WARNING: console %s found, "
2497c478bd9Sstevel@tonic-gate "but it could not be controlled.", devpath);
2507c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE);
2517c478bd9Sstevel@tonic-gate }
2527c478bd9Sstevel@tonic-gate if (devctl_device_remove(hdl) == 0) {
2537c478bd9Sstevel@tonic-gate cb->killed++;
2547c478bd9Sstevel@tonic-gate } else {
2557c478bd9Sstevel@tonic-gate zerror(cb->zlogp, B_TRUE, "WARNING: console %s found, "
2567c478bd9Sstevel@tonic-gate "but it could not be removed.", devpath);
2577c478bd9Sstevel@tonic-gate }
2587c478bd9Sstevel@tonic-gate devctl_release(hdl);
2597c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE);
2607c478bd9Sstevel@tonic-gate }
2617c478bd9Sstevel@tonic-gate
2627c478bd9Sstevel@tonic-gate static int
destroy_console_devs(zlog_t * zlogp)2637c478bd9Sstevel@tonic-gate destroy_console_devs(zlog_t *zlogp)
2647c478bd9Sstevel@tonic-gate {
2659d5056eaSjv char conspath[MAXPATHLEN];
2667c478bd9Sstevel@tonic-gate di_node_t root;
2677c478bd9Sstevel@tonic-gate struct cb_data cb;
2681fa2a664SJoshua M. Clulow int managerfd;
2691fa2a664SJoshua M. Clulow int subfd;
2709d5056eaSjv
2719d5056eaSjv /*
2721fa2a664SJoshua M. Clulow * Signal the manager side to release its handle on the subsidiary side
2731fa2a664SJoshua M. Clulow * by issuing a ZC_RELEASESUBSID ioctl.
2749d5056eaSjv */
2759d5056eaSjv (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
2761fa2a664SJoshua M. Clulow zone_name, ZCONS_MANAGER_NAME);
2771fa2a664SJoshua M. Clulow if ((managerfd = open(conspath, O_RDWR | O_NOCTTY)) != -1) {
2789d5056eaSjv (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
2791fa2a664SJoshua M. Clulow zone_name, ZCONS_SUBSIDIARY_NAME);
2801fa2a664SJoshua M. Clulow if ((subfd = open(conspath, O_RDWR | O_NOCTTY)) != -1) {
2811fa2a664SJoshua M. Clulow if (ioctl(managerfd, ZC_RELEASESUBSID,
2821fa2a664SJoshua M. Clulow (caddr_t)(intptr_t)subfd) != 0)
2839d5056eaSjv zerror(zlogp, B_TRUE, "WARNING: error while "
2841fa2a664SJoshua M. Clulow "releasing subsidiary handle of zone "
2851fa2a664SJoshua M. Clulow "console for %s", zone_name);
2861fa2a664SJoshua M. Clulow (void) close(subfd);
2879d5056eaSjv } else {
2881fa2a664SJoshua M. Clulow zerror(zlogp, B_TRUE, "WARNING: could not open "
2891fa2a664SJoshua M. Clulow "subsidiary side of zone console for %s to "
2901fa2a664SJoshua M. Clulow "release subsidiary handle", zone_name);
2919d5056eaSjv }
2921fa2a664SJoshua M. Clulow (void) close(managerfd);
2939d5056eaSjv } else {
2941fa2a664SJoshua M. Clulow zerror(zlogp, B_TRUE, "WARNING: could not open manager side of "
2951fa2a664SJoshua M. Clulow "zone console for %s to release subsidiary handle",
2961fa2a664SJoshua M. Clulow zone_name);
2979d5056eaSjv }
2987c478bd9Sstevel@tonic-gate
2997c478bd9Sstevel@tonic-gate bzero(&cb, sizeof (cb));
3007c478bd9Sstevel@tonic-gate cb.zlogp = zlogp;
3017c478bd9Sstevel@tonic-gate
3027c478bd9Sstevel@tonic-gate if ((root = di_init(ZCONSNEX_DEVTREEPATH, DINFOCPYALL)) ==
3037c478bd9Sstevel@tonic-gate DI_NODE_NIL) {
3047c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "di_init");
3057c478bd9Sstevel@tonic-gate return (-1);
3067c478bd9Sstevel@tonic-gate }
3077c478bd9Sstevel@tonic-gate
3087c478bd9Sstevel@tonic-gate (void) di_walk_node(root, DI_WALK_CLDFIRST, (void *)&cb, destroy_cb);
3097c478bd9Sstevel@tonic-gate if (cb.found > 1) {
3107c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE, "WARNING: multiple zone console "
3117c478bd9Sstevel@tonic-gate "instances detected for zone '%s'; %d of %d "
3127c478bd9Sstevel@tonic-gate "successfully removed.",
3137c478bd9Sstevel@tonic-gate zone_name, cb.killed, cb.found);
3147c478bd9Sstevel@tonic-gate }
3157c478bd9Sstevel@tonic-gate
3167c478bd9Sstevel@tonic-gate di_fini(root);
3177c478bd9Sstevel@tonic-gate return (0);
3187c478bd9Sstevel@tonic-gate }
3197c478bd9Sstevel@tonic-gate
3207c478bd9Sstevel@tonic-gate /*
3217c478bd9Sstevel@tonic-gate * init_console_dev() drives the device-tree configuration of the zone
3227c478bd9Sstevel@tonic-gate * console device. The general strategy is to use the libdevice (devctl)
3237c478bd9Sstevel@tonic-gate * interfaces to instantiate a new zone console node. We do a lot of
3247c478bd9Sstevel@tonic-gate * sanity checking, and are careful to reuse a console if one exists.
3257c478bd9Sstevel@tonic-gate *
3267c478bd9Sstevel@tonic-gate * Once the device is in the device tree, we kick devfsadm via di_init_devs()
3271fa2a664SJoshua M. Clulow * to ensure that the appropriate symlinks (to the manager and subsidiary
3281fa2a664SJoshua M. Clulow * console devices) are placed in /dev in the global zone.
3297c478bd9Sstevel@tonic-gate */
3307c478bd9Sstevel@tonic-gate static int
init_console_dev(zlog_t * zlogp)3317c478bd9Sstevel@tonic-gate init_console_dev(zlog_t *zlogp)
3327c478bd9Sstevel@tonic-gate {
3339d5056eaSjv char conspath[MAXPATHLEN];
3349d5056eaSjv devctl_hdl_t bus_hdl = NULL;
3359d5056eaSjv devctl_hdl_t dev_hdl = NULL;
3367c478bd9Sstevel@tonic-gate devctl_ddef_t ddef_hdl = NULL;
3377c478bd9Sstevel@tonic-gate di_devlink_handle_t dl = NULL;
3389d5056eaSjv int rv = -1;
3399d5056eaSjv int ndevs;
3401fa2a664SJoshua M. Clulow int managerfd;
3411fa2a664SJoshua M. Clulow int subfd;
342e1c90a83SJerry Jelinek int i;
3437c478bd9Sstevel@tonic-gate
3447c478bd9Sstevel@tonic-gate /*
3457c478bd9Sstevel@tonic-gate * Don't re-setup console if it is working and ready already; just
3467c478bd9Sstevel@tonic-gate * skip ahead to making devlinks, which we do for sanity's sake.
3477c478bd9Sstevel@tonic-gate */
3487c478bd9Sstevel@tonic-gate ndevs = count_console_devs(zlogp);
3497c478bd9Sstevel@tonic-gate if (ndevs == 1) {
3507c478bd9Sstevel@tonic-gate goto devlinks;
3517c478bd9Sstevel@tonic-gate } else if (ndevs > 1 || ndevs == -1) {
3527c478bd9Sstevel@tonic-gate /*
3537c478bd9Sstevel@tonic-gate * For now, this seems like a reasonable but harsh punishment.
3547c478bd9Sstevel@tonic-gate * If needed, we could try to get clever and delete all but
3557c478bd9Sstevel@tonic-gate * the console which is pointed at by the current symlink.
3567c478bd9Sstevel@tonic-gate */
3577c478bd9Sstevel@tonic-gate if (destroy_console_devs(zlogp) == -1) {
3587c478bd9Sstevel@tonic-gate goto error;
3597c478bd9Sstevel@tonic-gate }
3607c478bd9Sstevel@tonic-gate }
3617c478bd9Sstevel@tonic-gate
3627c478bd9Sstevel@tonic-gate /*
3637c478bd9Sstevel@tonic-gate * Time to make the consoles!
3647c478bd9Sstevel@tonic-gate */
3657c478bd9Sstevel@tonic-gate if ((bus_hdl = devctl_bus_acquire(ZCONSNEX_FILEPATH, 0)) == NULL) {
3667c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "%s failed", "devctl_bus_acquire");
3677c478bd9Sstevel@tonic-gate goto error;
3687c478bd9Sstevel@tonic-gate }
3697c478bd9Sstevel@tonic-gate if ((ddef_hdl = devctl_ddef_alloc("zcons", 0)) == NULL) {
3707c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to allocate ddef handle");
3717c478bd9Sstevel@tonic-gate goto error;
3727c478bd9Sstevel@tonic-gate }
3737c478bd9Sstevel@tonic-gate /*
3747c478bd9Sstevel@tonic-gate * Set three properties on this node; the first is the name of the
3757c478bd9Sstevel@tonic-gate * zone; the second is a flag which lets pseudo know that it is
3767c478bd9Sstevel@tonic-gate * OK to automatically allocate an instance # for this device;
3777c478bd9Sstevel@tonic-gate * the third tells the device framework not to auto-detach this
3787c478bd9Sstevel@tonic-gate * node-- we need the node to still be there when we ask devfsadmd
3797c478bd9Sstevel@tonic-gate * to make links, and when we need to open it.
3807c478bd9Sstevel@tonic-gate */
3817c478bd9Sstevel@tonic-gate if (devctl_ddef_string(ddef_hdl, "zonename", zone_name) == -1) {
3827c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to create zonename property");
3837c478bd9Sstevel@tonic-gate goto error;
3847c478bd9Sstevel@tonic-gate }
3857c478bd9Sstevel@tonic-gate if (devctl_ddef_int(ddef_hdl, "auto-assign-instance", 1) == -1) {
3867c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to create auto-assign-instance "
3877c478bd9Sstevel@tonic-gate "property");
3887c478bd9Sstevel@tonic-gate goto error;
3897c478bd9Sstevel@tonic-gate }
3907c478bd9Sstevel@tonic-gate if (devctl_ddef_int(ddef_hdl, "ddi-no-autodetach", 1) == -1) {
3917c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to create ddi-no-auto-detach "
3927c478bd9Sstevel@tonic-gate "property");
3937c478bd9Sstevel@tonic-gate goto error;
3947c478bd9Sstevel@tonic-gate }
3957c478bd9Sstevel@tonic-gate if (devctl_bus_dev_create(bus_hdl, ddef_hdl, 0, &dev_hdl) == -1) {
3967c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to create console node");
3977c478bd9Sstevel@tonic-gate goto error;
3987c478bd9Sstevel@tonic-gate }
3997c478bd9Sstevel@tonic-gate
4007c478bd9Sstevel@tonic-gate devlinks:
4017c478bd9Sstevel@tonic-gate if ((dl = di_devlink_init("zcons", DI_MAKE_LINK)) != NULL) {
4027c478bd9Sstevel@tonic-gate (void) di_devlink_fini(&dl);
4037c478bd9Sstevel@tonic-gate } else {
4047c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to create devlinks");
4057c478bd9Sstevel@tonic-gate goto error;
4067c478bd9Sstevel@tonic-gate }
4077c478bd9Sstevel@tonic-gate
4087c478bd9Sstevel@tonic-gate /*
4091fa2a664SJoshua M. Clulow * Open the manager side of the console and issue the ZC_HOLDSUBSID
4101fa2a664SJoshua M. Clulow * ioctl, which will cause the manager to retain a reference to the
4111fa2a664SJoshua M. Clulow * subsidiary. This prevents ttymon from blowing through the
4121fa2a664SJoshua M. Clulow * subsidiary's STREAMS anchor.
4137c478bd9Sstevel@tonic-gate */
4149d5056eaSjv (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
4151fa2a664SJoshua M. Clulow zone_name, ZCONS_MANAGER_NAME);
4161fa2a664SJoshua M. Clulow if ((managerfd = open(conspath, O_RDWR | O_NOCTTY)) == -1) {
4171fa2a664SJoshua M. Clulow zerror(zlogp, B_TRUE, "ERROR: could not open manager side of "
4181fa2a664SJoshua M. Clulow "zone console for %s to acquire subsidiary handle",
4191fa2a664SJoshua M. Clulow zone_name);
4207c478bd9Sstevel@tonic-gate goto error;
4217c478bd9Sstevel@tonic-gate }
4229d5056eaSjv (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
4231fa2a664SJoshua M. Clulow zone_name, ZCONS_SUBSIDIARY_NAME);
4241fa2a664SJoshua M. Clulow if ((subfd = open(conspath, O_RDWR | O_NOCTTY)) == -1) {
4251fa2a664SJoshua M. Clulow zerror(zlogp, B_TRUE, "ERROR: could not open subsidiary side "
4261fa2a664SJoshua M. Clulow "of zone console for %s to acquire subsidiary handle",
4271fa2a664SJoshua M. Clulow zone_name);
4281fa2a664SJoshua M. Clulow (void) close(managerfd);
4297c478bd9Sstevel@tonic-gate goto error;
4307c478bd9Sstevel@tonic-gate }
431e1c90a83SJerry Jelinek /*
432e1c90a83SJerry Jelinek * This ioctl can occasionally return ENXIO if devfs doesn't have
433e1c90a83SJerry Jelinek * everything plumbed up yet due to heavy zone startup load. Wait for
434e1c90a83SJerry Jelinek * 1 sec. and retry a few times before we fail to boot the zone.
435e1c90a83SJerry Jelinek */
436e1c90a83SJerry Jelinek for (i = 0; i < 5; i++) {
4371fa2a664SJoshua M. Clulow if (ioctl(managerfd, ZC_HOLDSUBSID, (caddr_t)(intptr_t)subfd)
438e1c90a83SJerry Jelinek == 0) {
439e1c90a83SJerry Jelinek rv = 0;
440e1c90a83SJerry Jelinek break;
441e1c90a83SJerry Jelinek } else if (errno != ENXIO) {
442e1c90a83SJerry Jelinek break;
443e1c90a83SJerry Jelinek }
444e1c90a83SJerry Jelinek (void) sleep(1);
445e1c90a83SJerry Jelinek }
446e1c90a83SJerry Jelinek if (rv != 0)
4471fa2a664SJoshua M. Clulow zerror(zlogp, B_TRUE, "ERROR: error while acquiring "
4481fa2a664SJoshua M. Clulow "subsidiary handle of zone console for %s", zone_name);
449e1c90a83SJerry Jelinek
4501fa2a664SJoshua M. Clulow (void) close(subfd);
4511fa2a664SJoshua M. Clulow (void) close(managerfd);
4527c478bd9Sstevel@tonic-gate
4539d5056eaSjv error:
4549d5056eaSjv if (ddef_hdl)
4559d5056eaSjv devctl_ddef_free(ddef_hdl);
4569d5056eaSjv if (bus_hdl)
4579d5056eaSjv devctl_release(bus_hdl);
4589d5056eaSjv if (dev_hdl)
4599d5056eaSjv devctl_release(dev_hdl);
4609d5056eaSjv return (rv);
4617c478bd9Sstevel@tonic-gate }
4627c478bd9Sstevel@tonic-gate
4637c478bd9Sstevel@tonic-gate static int
init_console_sock(zlog_t * zlogp)4647c478bd9Sstevel@tonic-gate init_console_sock(zlog_t *zlogp)
4657c478bd9Sstevel@tonic-gate {
4667c478bd9Sstevel@tonic-gate int servfd;
4677c478bd9Sstevel@tonic-gate struct sockaddr_un servaddr;
4687c478bd9Sstevel@tonic-gate
4697c478bd9Sstevel@tonic-gate bzero(&servaddr, sizeof (servaddr));
4707c478bd9Sstevel@tonic-gate servaddr.sun_family = AF_UNIX;
4717c478bd9Sstevel@tonic-gate (void) snprintf(servaddr.sun_path, sizeof (servaddr.sun_path),
4727c478bd9Sstevel@tonic-gate CONSOLE_SOCKPATH, zone_name);
4737c478bd9Sstevel@tonic-gate
4747c478bd9Sstevel@tonic-gate if ((servfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
4757c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "console setup: could not create socket");
4767c478bd9Sstevel@tonic-gate return (-1);
4777c478bd9Sstevel@tonic-gate }
4787c478bd9Sstevel@tonic-gate (void) unlink(servaddr.sun_path);
4797c478bd9Sstevel@tonic-gate
4807c478bd9Sstevel@tonic-gate if (bind(servfd, (struct sockaddr *)&servaddr,
4817c478bd9Sstevel@tonic-gate sizeof (servaddr)) == -1) {
4827c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE,
4837c478bd9Sstevel@tonic-gate "console setup: could not bind to socket");
4847c478bd9Sstevel@tonic-gate goto out;
4857c478bd9Sstevel@tonic-gate }
4867c478bd9Sstevel@tonic-gate
4877c478bd9Sstevel@tonic-gate if (listen(servfd, 4) == -1) {
4887c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE,
4897c478bd9Sstevel@tonic-gate "console setup: could not listen on socket");
4907c478bd9Sstevel@tonic-gate goto out;
4917c478bd9Sstevel@tonic-gate }
4927c478bd9Sstevel@tonic-gate return (servfd);
4937c478bd9Sstevel@tonic-gate
4947c478bd9Sstevel@tonic-gate out:
4957c478bd9Sstevel@tonic-gate (void) unlink(servaddr.sun_path);
4967c478bd9Sstevel@tonic-gate (void) close(servfd);
4977c478bd9Sstevel@tonic-gate return (-1);
4987c478bd9Sstevel@tonic-gate }
4997c478bd9Sstevel@tonic-gate
5007c478bd9Sstevel@tonic-gate static void
destroy_console_sock(int servfd)5017c478bd9Sstevel@tonic-gate destroy_console_sock(int servfd)
5027c478bd9Sstevel@tonic-gate {
5037c478bd9Sstevel@tonic-gate char path[MAXPATHLEN];
5047c478bd9Sstevel@tonic-gate
5057c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), CONSOLE_SOCKPATH, zone_name);
5067c478bd9Sstevel@tonic-gate (void) unlink(path);
5077c478bd9Sstevel@tonic-gate (void) shutdown(servfd, SHUT_RDWR);
5087c478bd9Sstevel@tonic-gate (void) close(servfd);
5097c478bd9Sstevel@tonic-gate }
5107c478bd9Sstevel@tonic-gate
5117c478bd9Sstevel@tonic-gate /*
5127c478bd9Sstevel@tonic-gate * Read the "ident" string from the client's descriptor; this routine also
5137c478bd9Sstevel@tonic-gate * tolerates being called with pid=NULL, for times when you want to "eat"
5147c478bd9Sstevel@tonic-gate * the ident string from a client without saving it.
5157c478bd9Sstevel@tonic-gate */
5167c478bd9Sstevel@tonic-gate static int
get_client_ident(int clifd,pid_t * pid,char * locale,size_t locale_len,int * disconnect)517741343adSAlexander Eremin get_client_ident(int clifd, pid_t *pid, char *locale, size_t locale_len,
518c4567a61SPaul Dagnelie int *disconnect)
5197c478bd9Sstevel@tonic-gate {
5207c478bd9Sstevel@tonic-gate char buf[BUFSIZ], *bufp;
5217c478bd9Sstevel@tonic-gate size_t buflen = sizeof (buf);
5227c478bd9Sstevel@tonic-gate char c = '\0';
5237c478bd9Sstevel@tonic-gate int i = 0, r;
5247c478bd9Sstevel@tonic-gate
5257c478bd9Sstevel@tonic-gate /* "eat up the ident string" case, for simplicity */
5267c478bd9Sstevel@tonic-gate if (pid == NULL) {
5277c478bd9Sstevel@tonic-gate assert(locale == NULL && locale_len == 0);
5287c478bd9Sstevel@tonic-gate while (read(clifd, &c, 1) == 1) {
5297c478bd9Sstevel@tonic-gate if (c == '\n')
5307c478bd9Sstevel@tonic-gate return (0);
5317c478bd9Sstevel@tonic-gate }
5327c478bd9Sstevel@tonic-gate }
5337c478bd9Sstevel@tonic-gate
5347c478bd9Sstevel@tonic-gate bzero(buf, sizeof (buf));
5357c478bd9Sstevel@tonic-gate while ((buflen > 1) && (r = read(clifd, &c, 1)) == 1) {
5367c478bd9Sstevel@tonic-gate buflen--;
5377c478bd9Sstevel@tonic-gate if (c == '\n')
5387c478bd9Sstevel@tonic-gate break;
5397c478bd9Sstevel@tonic-gate
5407c478bd9Sstevel@tonic-gate buf[i] = c;
5417c478bd9Sstevel@tonic-gate i++;
5427c478bd9Sstevel@tonic-gate }
5437c478bd9Sstevel@tonic-gate if (r == -1)
5447c478bd9Sstevel@tonic-gate return (-1);
5457c478bd9Sstevel@tonic-gate
5467c478bd9Sstevel@tonic-gate /*
5477c478bd9Sstevel@tonic-gate * We've filled the buffer, but still haven't seen \n. Keep eating
5487c478bd9Sstevel@tonic-gate * until we find it; we don't expect this to happen, but this is
5497c478bd9Sstevel@tonic-gate * defensive.
5507c478bd9Sstevel@tonic-gate */
5517c478bd9Sstevel@tonic-gate if (c != '\n') {
5527c478bd9Sstevel@tonic-gate while ((r = read(clifd, &c, sizeof (c))) > 0)
5537c478bd9Sstevel@tonic-gate if (c == '\n')
5547c478bd9Sstevel@tonic-gate break;
5557c478bd9Sstevel@tonic-gate }
5567c478bd9Sstevel@tonic-gate
5577c478bd9Sstevel@tonic-gate /*
558741343adSAlexander Eremin * Parse buffer for message of the form:
559741343adSAlexander Eremin * IDENT <pid> <locale> <disconnect flag>
5607c478bd9Sstevel@tonic-gate */
5617c478bd9Sstevel@tonic-gate bufp = buf;
5627c478bd9Sstevel@tonic-gate if (strncmp(bufp, "IDENT ", 6) != 0)
5637c478bd9Sstevel@tonic-gate return (-1);
5647c478bd9Sstevel@tonic-gate bufp += 6;
5657c478bd9Sstevel@tonic-gate errno = 0;
5667c478bd9Sstevel@tonic-gate *pid = strtoll(bufp, &bufp, 10);
5677c478bd9Sstevel@tonic-gate if (errno != 0)
5687c478bd9Sstevel@tonic-gate return (-1);
5697c478bd9Sstevel@tonic-gate
5707c478bd9Sstevel@tonic-gate while (*bufp != '\0' && isspace(*bufp))
5717c478bd9Sstevel@tonic-gate bufp++;
572741343adSAlexander Eremin buflen = strlen(bufp) - 1;
573741343adSAlexander Eremin *disconnect = atoi(&bufp[buflen]);
574741343adSAlexander Eremin bufp[buflen - 1] = '\0';
5757c478bd9Sstevel@tonic-gate (void) strlcpy(locale, bufp, locale_len);
5767c478bd9Sstevel@tonic-gate
5777c478bd9Sstevel@tonic-gate return (0);
5787c478bd9Sstevel@tonic-gate }
5797c478bd9Sstevel@tonic-gate
5807c478bd9Sstevel@tonic-gate static int
accept_client(int servfd,pid_t * pid,char * locale,size_t locale_len,int * disconnect)581741343adSAlexander Eremin accept_client(int servfd, pid_t *pid, char *locale, size_t locale_len,
582c4567a61SPaul Dagnelie int *disconnect)
5837c478bd9Sstevel@tonic-gate {
5847c478bd9Sstevel@tonic-gate int connfd;
5857c478bd9Sstevel@tonic-gate struct sockaddr_un cliaddr;
5867c478bd9Sstevel@tonic-gate socklen_t clilen;
5877c478bd9Sstevel@tonic-gate
5887c478bd9Sstevel@tonic-gate clilen = sizeof (cliaddr);
5897c478bd9Sstevel@tonic-gate connfd = accept(servfd, (struct sockaddr *)&cliaddr, &clilen);
5907c478bd9Sstevel@tonic-gate if (connfd == -1)
5917c478bd9Sstevel@tonic-gate return (-1);
592741343adSAlexander Eremin if (get_client_ident(connfd, pid, locale, locale_len,
593741343adSAlexander Eremin disconnect) == -1) {
5947c478bd9Sstevel@tonic-gate (void) shutdown(connfd, SHUT_RDWR);
5957c478bd9Sstevel@tonic-gate (void) close(connfd);
5967c478bd9Sstevel@tonic-gate return (-1);
5977c478bd9Sstevel@tonic-gate }
5987c478bd9Sstevel@tonic-gate (void) write(connfd, "OK\n", 3);
5997c478bd9Sstevel@tonic-gate return (connfd);
6007c478bd9Sstevel@tonic-gate }
6017c478bd9Sstevel@tonic-gate
6027c478bd9Sstevel@tonic-gate static void
reject_client(int servfd,pid_t clientpid)6037c478bd9Sstevel@tonic-gate reject_client(int servfd, pid_t clientpid)
6047c478bd9Sstevel@tonic-gate {
6057c478bd9Sstevel@tonic-gate int connfd;
6067c478bd9Sstevel@tonic-gate struct sockaddr_un cliaddr;
6077c478bd9Sstevel@tonic-gate socklen_t clilen;
6087c478bd9Sstevel@tonic-gate char nak[MAXPATHLEN];
6097c478bd9Sstevel@tonic-gate
6107c478bd9Sstevel@tonic-gate clilen = sizeof (cliaddr);
6117c478bd9Sstevel@tonic-gate connfd = accept(servfd, (struct sockaddr *)&cliaddr, &clilen);
6127c478bd9Sstevel@tonic-gate
6137c478bd9Sstevel@tonic-gate /*
6147c478bd9Sstevel@tonic-gate * After hear its ident string, tell client to get lost.
6157c478bd9Sstevel@tonic-gate */
616741343adSAlexander Eremin if (get_client_ident(connfd, NULL, NULL, 0, NULL) == 0) {
6177c478bd9Sstevel@tonic-gate (void) snprintf(nak, sizeof (nak), "%lu\n",
6187c478bd9Sstevel@tonic-gate clientpid);
6197c478bd9Sstevel@tonic-gate (void) write(connfd, nak, strlen(nak));
6207c478bd9Sstevel@tonic-gate }
6217c478bd9Sstevel@tonic-gate (void) shutdown(connfd, SHUT_RDWR);
6227c478bd9Sstevel@tonic-gate (void) close(connfd);
6237c478bd9Sstevel@tonic-gate }
6247c478bd9Sstevel@tonic-gate
6257c478bd9Sstevel@tonic-gate static void
event_message(int clifd,char * clilocale,zone_evt_t evt,int dflag)626741343adSAlexander Eremin event_message(int clifd, char *clilocale, zone_evt_t evt, int dflag)
6277c478bd9Sstevel@tonic-gate {
6283f2f09c1Sdp char *str, *lstr = NULL;
6293f2f09c1Sdp char lmsg[BUFSIZ];
6303f2f09c1Sdp char outbuf[BUFSIZ];
6317c478bd9Sstevel@tonic-gate
6327c478bd9Sstevel@tonic-gate if (clifd == -1)
6337c478bd9Sstevel@tonic-gate return;
6347c478bd9Sstevel@tonic-gate
6357c478bd9Sstevel@tonic-gate switch (evt) {
6367c478bd9Sstevel@tonic-gate case Z_EVT_ZONE_BOOTING:
6373f2f09c1Sdp if (*boot_args == '\0') {
6383f2f09c1Sdp str = "NOTICE: Zone booting up";
6393f2f09c1Sdp break;
6403f2f09c1Sdp }
6413f2f09c1Sdp /*LINTED*/
6423f2f09c1Sdp (void) snprintf(lmsg, sizeof (lmsg), localize_msg(clilocale,
6433f2f09c1Sdp "NOTICE: Zone booting up with arguments: %s"), boot_args);
6443f2f09c1Sdp lstr = lmsg;
6457c478bd9Sstevel@tonic-gate break;
6467c478bd9Sstevel@tonic-gate case Z_EVT_ZONE_READIED:
6473f2f09c1Sdp str = "NOTICE: Zone readied";
6487c478bd9Sstevel@tonic-gate break;
6497c478bd9Sstevel@tonic-gate case Z_EVT_ZONE_HALTED:
650741343adSAlexander Eremin if (dflag)
651741343adSAlexander Eremin str = "NOTICE: Zone halted. Disconnecting...";
652741343adSAlexander Eremin else
653741343adSAlexander Eremin str = "NOTICE: Zone halted";
6547c478bd9Sstevel@tonic-gate break;
6557c478bd9Sstevel@tonic-gate case Z_EVT_ZONE_REBOOTING:
6563f2f09c1Sdp if (*boot_args == '\0') {
6573f2f09c1Sdp str = "NOTICE: Zone rebooting";
6583f2f09c1Sdp break;
6593f2f09c1Sdp }
6603f2f09c1Sdp /*LINTED*/
6613f2f09c1Sdp (void) snprintf(lmsg, sizeof (lmsg), localize_msg(clilocale,
6623f2f09c1Sdp "NOTICE: Zone rebooting with arguments: %s"), boot_args);
6633f2f09c1Sdp lstr = lmsg;
6647c478bd9Sstevel@tonic-gate break;
6657c478bd9Sstevel@tonic-gate case Z_EVT_ZONE_UNINSTALLING:
6663f2f09c1Sdp str = "NOTICE: Zone is being uninstalled. Disconnecting...";
6677c478bd9Sstevel@tonic-gate break;
668ffbafc53Scomay case Z_EVT_ZONE_BOOTFAILED:
669741343adSAlexander Eremin if (dflag)
670741343adSAlexander Eremin str = "NOTICE: Zone boot failed. Disconnecting...";
671741343adSAlexander Eremin else
672741343adSAlexander Eremin str = "NOTICE: Zone boot failed";
6733f2f09c1Sdp break;
6743f2f09c1Sdp case Z_EVT_ZONE_BADARGS:
6753f2f09c1Sdp /*LINTED*/
6763f2f09c1Sdp (void) snprintf(lmsg, sizeof (lmsg),
6773f2f09c1Sdp localize_msg(clilocale,
6783f2f09c1Sdp "WARNING: Ignoring invalid boot arguments: %s"),
6793f2f09c1Sdp bad_boot_arg);
6803f2f09c1Sdp lstr = lmsg;
681ffbafc53Scomay break;
6827c478bd9Sstevel@tonic-gate default:
6837c478bd9Sstevel@tonic-gate return;
6847c478bd9Sstevel@tonic-gate }
6853f2f09c1Sdp
6863f2f09c1Sdp if (lstr == NULL)
6873f2f09c1Sdp lstr = localize_msg(clilocale, str);
6883f2f09c1Sdp (void) snprintf(outbuf, sizeof (outbuf), "\r\n[%s]\r\n", lstr);
6893f2f09c1Sdp (void) write(clifd, outbuf, strlen(outbuf));
6907c478bd9Sstevel@tonic-gate }
6917c478bd9Sstevel@tonic-gate
6927c478bd9Sstevel@tonic-gate /*
6937c478bd9Sstevel@tonic-gate * Check to see if the client at the other end of the socket is still
6947c478bd9Sstevel@tonic-gate * alive; we know it is not if it throws EPIPE at us when we try to write
6957c478bd9Sstevel@tonic-gate * an otherwise harmless 0-length message to it.
6967c478bd9Sstevel@tonic-gate */
6977c478bd9Sstevel@tonic-gate static int
test_client(int clifd)6987c478bd9Sstevel@tonic-gate test_client(int clifd)
6997c478bd9Sstevel@tonic-gate {
7007c478bd9Sstevel@tonic-gate if ((write(clifd, "", 0) == -1) && errno == EPIPE)
7017c478bd9Sstevel@tonic-gate return (-1);
7027c478bd9Sstevel@tonic-gate return (0);
7037c478bd9Sstevel@tonic-gate }
7047c478bd9Sstevel@tonic-gate
7057c478bd9Sstevel@tonic-gate /*
7067c478bd9Sstevel@tonic-gate * This routine drives the console I/O loop. It polls for input from the
7071fa2a664SJoshua M. Clulow * manager side of the console (output to the console), and from the client
7087c478bd9Sstevel@tonic-gate * (input from the console user). Additionally, it polls on the server fd,
7097c478bd9Sstevel@tonic-gate * and disconnects any clients that might try to hook up with the zone while
7107c478bd9Sstevel@tonic-gate * the console is in use.
7117c478bd9Sstevel@tonic-gate *
7127c478bd9Sstevel@tonic-gate * When the client first calls us up, it is expected to send a line giving
7137c478bd9Sstevel@tonic-gate * its "identity"; this consists of the string 'IDENT <pid> <locale>'.
7147c478bd9Sstevel@tonic-gate * This is so that we can report that the console is busy along with
7157c478bd9Sstevel@tonic-gate * some diagnostics about who has it busy; the locale is used so that
7167c478bd9Sstevel@tonic-gate * asynchronous messages about zone state (like the NOTICE: zone halted
7177c478bd9Sstevel@tonic-gate * messages) can be output in the user's locale.
7187c478bd9Sstevel@tonic-gate */
7197c478bd9Sstevel@tonic-gate static void
do_console_io(zlog_t * zlogp,int consfd,int servfd)7207c478bd9Sstevel@tonic-gate do_console_io(zlog_t *zlogp, int consfd, int servfd)
7217c478bd9Sstevel@tonic-gate {
7227c478bd9Sstevel@tonic-gate struct pollfd pollfds[4];
7237c478bd9Sstevel@tonic-gate char ibuf[BUFSIZ];
7247c478bd9Sstevel@tonic-gate int cc, ret;
7257c478bd9Sstevel@tonic-gate int clifd = -1;
7267c478bd9Sstevel@tonic-gate int pollerr = 0;
7277c478bd9Sstevel@tonic-gate char clilocale[MAXPATHLEN];
7287c478bd9Sstevel@tonic-gate pid_t clipid = 0;
729741343adSAlexander Eremin int disconnect = 0;
7307c478bd9Sstevel@tonic-gate
7317c478bd9Sstevel@tonic-gate /* console side, watch for read events */
7327c478bd9Sstevel@tonic-gate pollfds[0].fd = consfd;
7337c478bd9Sstevel@tonic-gate pollfds[0].events = POLLIN | POLLRDNORM | POLLRDBAND |
7347c478bd9Sstevel@tonic-gate POLLPRI | POLLERR | POLLHUP | POLLNVAL;
7357c478bd9Sstevel@tonic-gate
7367c478bd9Sstevel@tonic-gate /* client side, watch for read events */
7377c478bd9Sstevel@tonic-gate pollfds[1].fd = clifd;
7387c478bd9Sstevel@tonic-gate pollfds[1].events = pollfds[0].events;
7397c478bd9Sstevel@tonic-gate
7407c478bd9Sstevel@tonic-gate /* the server socket; watch for events (new connections) */
7417c478bd9Sstevel@tonic-gate pollfds[2].fd = servfd;
7427c478bd9Sstevel@tonic-gate pollfds[2].events = pollfds[0].events;
7437c478bd9Sstevel@tonic-gate
7447c478bd9Sstevel@tonic-gate /* the eventstram; watch for events (e.g.: zone halted) */
7457c478bd9Sstevel@tonic-gate pollfds[3].fd = eventstream[1];
7467c478bd9Sstevel@tonic-gate pollfds[3].events = pollfds[0].events;
7477c478bd9Sstevel@tonic-gate
7487c478bd9Sstevel@tonic-gate for (;;) {
7497c478bd9Sstevel@tonic-gate pollfds[0].revents = pollfds[1].revents = 0;
7507c478bd9Sstevel@tonic-gate pollfds[2].revents = pollfds[3].revents = 0;
7517c478bd9Sstevel@tonic-gate
7527c478bd9Sstevel@tonic-gate ret = poll(pollfds,
7537c478bd9Sstevel@tonic-gate sizeof (pollfds) / sizeof (struct pollfd), -1);
7547c478bd9Sstevel@tonic-gate if (ret == -1 && errno != EINTR) {
7557c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "poll failed");
7567c478bd9Sstevel@tonic-gate /* we are hosed, close connection */
7577c478bd9Sstevel@tonic-gate break;
7587c478bd9Sstevel@tonic-gate }
7597c478bd9Sstevel@tonic-gate
7607c478bd9Sstevel@tonic-gate /* event from console side */
7617c478bd9Sstevel@tonic-gate if (pollfds[0].revents) {
7627c478bd9Sstevel@tonic-gate if (pollfds[0].revents &
7637c478bd9Sstevel@tonic-gate (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) {
7647c478bd9Sstevel@tonic-gate errno = 0;
7657c478bd9Sstevel@tonic-gate cc = read(consfd, ibuf, BUFSIZ);
7667c478bd9Sstevel@tonic-gate if (cc <= 0 && (errno != EINTR) &&
7677c478bd9Sstevel@tonic-gate (errno != EAGAIN))
7687c478bd9Sstevel@tonic-gate break;
7697c478bd9Sstevel@tonic-gate /*
7707c478bd9Sstevel@tonic-gate * Lose I/O if no one is listening
7717c478bd9Sstevel@tonic-gate */
7727c478bd9Sstevel@tonic-gate if (clifd != -1 && cc > 0)
7737c478bd9Sstevel@tonic-gate (void) write(clifd, ibuf, cc);
7747c478bd9Sstevel@tonic-gate } else {
7757c478bd9Sstevel@tonic-gate pollerr = pollfds[0].revents;
7767c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE,
7777c478bd9Sstevel@tonic-gate "closing connection with (console) "
7787c478bd9Sstevel@tonic-gate "pollerr %d\n", pollerr);
7797c478bd9Sstevel@tonic-gate break;
7807c478bd9Sstevel@tonic-gate }
7817c478bd9Sstevel@tonic-gate }
7827c478bd9Sstevel@tonic-gate
7837c478bd9Sstevel@tonic-gate /* event from client side */
7847c478bd9Sstevel@tonic-gate if (pollfds[1].revents) {
7857c478bd9Sstevel@tonic-gate if (pollfds[1].revents &
7867c478bd9Sstevel@tonic-gate (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) {
7877c478bd9Sstevel@tonic-gate errno = 0;
7887c478bd9Sstevel@tonic-gate cc = read(clifd, ibuf, BUFSIZ);
7897c478bd9Sstevel@tonic-gate if (cc <= 0 && (errno != EINTR) &&
7907c478bd9Sstevel@tonic-gate (errno != EAGAIN))
7917c478bd9Sstevel@tonic-gate break;
7927c478bd9Sstevel@tonic-gate (void) write(consfd, ibuf, cc);
7937c478bd9Sstevel@tonic-gate } else {
7947c478bd9Sstevel@tonic-gate pollerr = pollfds[1].revents;
7957c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE,
7967c478bd9Sstevel@tonic-gate "closing connection with (client) "
7977c478bd9Sstevel@tonic-gate "pollerr %d\n", pollerr);
7987c478bd9Sstevel@tonic-gate break;
7997c478bd9Sstevel@tonic-gate }
8007c478bd9Sstevel@tonic-gate }
8017c478bd9Sstevel@tonic-gate
8027c478bd9Sstevel@tonic-gate /* event from server socket */
8037c478bd9Sstevel@tonic-gate if (pollfds[2].revents &&
8047c478bd9Sstevel@tonic-gate (pollfds[2].revents & (POLLIN | POLLRDNORM))) {
8057c478bd9Sstevel@tonic-gate if (clifd != -1) {
8067c478bd9Sstevel@tonic-gate /*
8077c478bd9Sstevel@tonic-gate * Test the client to see if it is really
8087c478bd9Sstevel@tonic-gate * still alive. If it has died but we
8097c478bd9Sstevel@tonic-gate * haven't yet detected that, we might
8107c478bd9Sstevel@tonic-gate * deny a legitimate connect attempt. If it
8117c478bd9Sstevel@tonic-gate * is dead, we break out; once we tear down
8127c478bd9Sstevel@tonic-gate * the old connection, the new connection
8137c478bd9Sstevel@tonic-gate * will happen.
8147c478bd9Sstevel@tonic-gate */
8157c478bd9Sstevel@tonic-gate if (test_client(clifd) == -1) {
8167c478bd9Sstevel@tonic-gate break;
8177c478bd9Sstevel@tonic-gate }
8187c478bd9Sstevel@tonic-gate /* we're already handling a client */
8197c478bd9Sstevel@tonic-gate reject_client(servfd, clipid);
8207c478bd9Sstevel@tonic-gate
8217c478bd9Sstevel@tonic-gate
8227c478bd9Sstevel@tonic-gate } else if ((clifd = accept_client(servfd, &clipid,
823741343adSAlexander Eremin clilocale, sizeof (clilocale),
824741343adSAlexander Eremin &disconnect)) != -1) {
8257c478bd9Sstevel@tonic-gate pollfds[1].fd = clifd;
8267c478bd9Sstevel@tonic-gate
8277c478bd9Sstevel@tonic-gate } else {
8287c478bd9Sstevel@tonic-gate break;
8297c478bd9Sstevel@tonic-gate }
8307c478bd9Sstevel@tonic-gate }
8317c478bd9Sstevel@tonic-gate
8327c478bd9Sstevel@tonic-gate /*
8337c478bd9Sstevel@tonic-gate * Watch for events on the eventstream. This is how we get
8347c478bd9Sstevel@tonic-gate * notified of the zone halting, etc. It provides us a
8357c478bd9Sstevel@tonic-gate * "wakeup" from poll when important things happen, which
8367c478bd9Sstevel@tonic-gate * is good.
8377c478bd9Sstevel@tonic-gate */
8387c478bd9Sstevel@tonic-gate if (pollfds[3].revents) {
8397c478bd9Sstevel@tonic-gate int evt = eventstream_read();
8407c478bd9Sstevel@tonic-gate /*
8417c478bd9Sstevel@tonic-gate * After we drain out the event, if we aren't servicing
8427c478bd9Sstevel@tonic-gate * a console client, we hop back out to our caller,
8437c478bd9Sstevel@tonic-gate * which will check to see if it is time to shutdown
8447c478bd9Sstevel@tonic-gate * the daemon, or if we should take another console
8457c478bd9Sstevel@tonic-gate * service lap.
8467c478bd9Sstevel@tonic-gate */
8477c478bd9Sstevel@tonic-gate if (clifd == -1) {
8487c478bd9Sstevel@tonic-gate break;
8497c478bd9Sstevel@tonic-gate }
850741343adSAlexander Eremin event_message(clifd, clilocale, evt, disconnect);
8517c478bd9Sstevel@tonic-gate /*
8527c478bd9Sstevel@tonic-gate * Special handling for the message that the zone is
8537c478bd9Sstevel@tonic-gate * uninstalling; we boot the client, then break out
8547c478bd9Sstevel@tonic-gate * of this function. When we return to the
8557c478bd9Sstevel@tonic-gate * serve_console loop, we will see that the zone is
8567c478bd9Sstevel@tonic-gate * in a state < READY, and so zoneadmd will shutdown.
8577c478bd9Sstevel@tonic-gate */
8587c478bd9Sstevel@tonic-gate if (evt == Z_EVT_ZONE_UNINSTALLING) {
8597c478bd9Sstevel@tonic-gate break;
8607c478bd9Sstevel@tonic-gate }
861741343adSAlexander Eremin /*
862741343adSAlexander Eremin * Diconnect if -C and -d options were specified and
863741343adSAlexander Eremin * zone was halted or failed to boot.
864741343adSAlexander Eremin */
865741343adSAlexander Eremin if ((evt == Z_EVT_ZONE_HALTED ||
866741343adSAlexander Eremin evt == Z_EVT_ZONE_BOOTFAILED) && disconnect) {
867741343adSAlexander Eremin break;
868741343adSAlexander Eremin }
8697c478bd9Sstevel@tonic-gate }
8707c478bd9Sstevel@tonic-gate
8717c478bd9Sstevel@tonic-gate }
8727c478bd9Sstevel@tonic-gate
8737c478bd9Sstevel@tonic-gate if (clifd != -1) {
8747c478bd9Sstevel@tonic-gate (void) shutdown(clifd, SHUT_RDWR);
8757c478bd9Sstevel@tonic-gate (void) close(clifd);
8767c478bd9Sstevel@tonic-gate }
8777c478bd9Sstevel@tonic-gate }
8787c478bd9Sstevel@tonic-gate
8797c478bd9Sstevel@tonic-gate int
init_console(zlog_t * zlogp)8807c478bd9Sstevel@tonic-gate init_console(zlog_t *zlogp)
8817c478bd9Sstevel@tonic-gate {
8827c478bd9Sstevel@tonic-gate if (init_console_dev(zlogp) == -1) {
8837c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE,
8847c478bd9Sstevel@tonic-gate "console setup: device initialization failed");
8857c478bd9Sstevel@tonic-gate return (-1);
8867c478bd9Sstevel@tonic-gate }
8877c478bd9Sstevel@tonic-gate
8887c478bd9Sstevel@tonic-gate if ((serverfd = init_console_sock(zlogp)) == -1) {
8897c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE,
8907c478bd9Sstevel@tonic-gate "console setup: socket initialization failed");
8917c478bd9Sstevel@tonic-gate return (-1);
8927c478bd9Sstevel@tonic-gate }
8937c478bd9Sstevel@tonic-gate return (0);
8947c478bd9Sstevel@tonic-gate }
8957c478bd9Sstevel@tonic-gate
8967c478bd9Sstevel@tonic-gate /*
8977c478bd9Sstevel@tonic-gate * serve_console() is the master loop for driving console I/O. It is also the
8987c478bd9Sstevel@tonic-gate * routine which is ultimately responsible for "pulling the plug" on zoneadmd
8997c478bd9Sstevel@tonic-gate * when it realizes that the daemon should shut down.
9007c478bd9Sstevel@tonic-gate *
9017c478bd9Sstevel@tonic-gate * The rules for shutdown are: there must be no console client, and the zone
9027c478bd9Sstevel@tonic-gate * state must be < ready. However, we need to give things a chance to actually
9037c478bd9Sstevel@tonic-gate * get going when the daemon starts up-- otherwise the daemon would immediately
9047c478bd9Sstevel@tonic-gate * exit on startup if the zone was in the installed state, so we first drop
9057c478bd9Sstevel@tonic-gate * into the do_console_io() loop in order to give *something* a chance to
9067c478bd9Sstevel@tonic-gate * happen.
9077c478bd9Sstevel@tonic-gate */
9087c478bd9Sstevel@tonic-gate void
serve_console(zlog_t * zlogp)9097c478bd9Sstevel@tonic-gate serve_console(zlog_t *zlogp)
9107c478bd9Sstevel@tonic-gate {
9111fa2a664SJoshua M. Clulow int managerfd;
9127c478bd9Sstevel@tonic-gate zone_state_t zstate;
9137c478bd9Sstevel@tonic-gate char conspath[MAXPATHLEN];
9147c478bd9Sstevel@tonic-gate
9157c478bd9Sstevel@tonic-gate (void) snprintf(conspath, sizeof (conspath),
9161fa2a664SJoshua M. Clulow "/dev/zcons/%s/%s", zone_name, ZCONS_MANAGER_NAME);
9177c478bd9Sstevel@tonic-gate
9187c478bd9Sstevel@tonic-gate for (;;) {
9191fa2a664SJoshua M. Clulow managerfd = open(conspath, O_RDWR|O_NONBLOCK|O_NOCTTY);
9201fa2a664SJoshua M. Clulow if (managerfd == -1) {
9211fa2a664SJoshua M. Clulow zerror(zlogp, B_TRUE, "failed to open console manager");
9227c478bd9Sstevel@tonic-gate (void) mutex_lock(&lock);
9237c478bd9Sstevel@tonic-gate goto death;
9247c478bd9Sstevel@tonic-gate }
9257c478bd9Sstevel@tonic-gate
9267c478bd9Sstevel@tonic-gate /*
9277c478bd9Sstevel@tonic-gate * Setting RPROTDIS on the stream means that the control
9287c478bd9Sstevel@tonic-gate * portion of messages received (which we don't care about)
9297c478bd9Sstevel@tonic-gate * will be discarded by the stream head. If we allowed such
9307c478bd9Sstevel@tonic-gate * messages, we wouldn't be able to use read(2), as it fails
9317c478bd9Sstevel@tonic-gate * (EBADMSG) when a message with a control element is received.
9327c478bd9Sstevel@tonic-gate */
9331fa2a664SJoshua M. Clulow if (ioctl(managerfd, I_SRDOPT, RNORM|RPROTDIS) == -1) {
9347c478bd9Sstevel@tonic-gate zerror(zlogp, B_TRUE, "failed to set options on "
9351fa2a664SJoshua M. Clulow "console manager");
9367c478bd9Sstevel@tonic-gate (void) mutex_lock(&lock);
9377c478bd9Sstevel@tonic-gate goto death;
9387c478bd9Sstevel@tonic-gate }
9397c478bd9Sstevel@tonic-gate
9401fa2a664SJoshua M. Clulow do_console_io(zlogp, managerfd, serverfd);
9417c478bd9Sstevel@tonic-gate
9427c478bd9Sstevel@tonic-gate /*
9437c478bd9Sstevel@tonic-gate * We would prefer not to do this, but hostile zone processes
9447c478bd9Sstevel@tonic-gate * can cause the stream to become tainted, and reads will
9457c478bd9Sstevel@tonic-gate * fail. So, in case something has gone seriously ill,
9467c478bd9Sstevel@tonic-gate * we dismantle the stream and reopen the console when we
9477c478bd9Sstevel@tonic-gate * take another lap.
9487c478bd9Sstevel@tonic-gate */
9491fa2a664SJoshua M. Clulow (void) close(managerfd);
9507c478bd9Sstevel@tonic-gate
9517c478bd9Sstevel@tonic-gate (void) mutex_lock(&lock);
9527c478bd9Sstevel@tonic-gate /*
9537c478bd9Sstevel@tonic-gate * We need to set death_throes (see below) atomically with
9547c478bd9Sstevel@tonic-gate * respect to noticing that (a) we have no console client and
9557c478bd9Sstevel@tonic-gate * (b) the zone is not installed. Otherwise we could get a
9567c478bd9Sstevel@tonic-gate * request to boot during this time. Once we set death_throes,
9577c478bd9Sstevel@tonic-gate * any incoming door stuff will be turned away.
9587c478bd9Sstevel@tonic-gate */
9597c478bd9Sstevel@tonic-gate if (zone_get_state(zone_name, &zstate) == Z_OK) {
9607c478bd9Sstevel@tonic-gate if (zstate < ZONE_STATE_READY)
9617c478bd9Sstevel@tonic-gate goto death;
9627c478bd9Sstevel@tonic-gate } else {
9637c478bd9Sstevel@tonic-gate zerror(zlogp, B_FALSE,
9647c478bd9Sstevel@tonic-gate "unable to determine state of zone");
9657c478bd9Sstevel@tonic-gate goto death;
9667c478bd9Sstevel@tonic-gate }
9677c478bd9Sstevel@tonic-gate /*
9687c478bd9Sstevel@tonic-gate * Even if zone_get_state() fails, stay conservative, and
9697c478bd9Sstevel@tonic-gate * take another lap.
9707c478bd9Sstevel@tonic-gate */
9717c478bd9Sstevel@tonic-gate (void) mutex_unlock(&lock);
9727c478bd9Sstevel@tonic-gate }
9737c478bd9Sstevel@tonic-gate
9747c478bd9Sstevel@tonic-gate death:
9757c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&lock));
9767c478bd9Sstevel@tonic-gate in_death_throes = B_TRUE;
9777c478bd9Sstevel@tonic-gate (void) mutex_unlock(&lock);
9787c478bd9Sstevel@tonic-gate
9797c478bd9Sstevel@tonic-gate destroy_console_sock(serverfd);
9807c478bd9Sstevel@tonic-gate (void) destroy_console_devs(zlogp);
9817c478bd9Sstevel@tonic-gate }
982