diff -r 56ca95a1d07b tools/console/client/main.c --- a/tools/console/client/main.c Mon Jan 15 15:03:07 2007 +0000 +++ b/tools/console/client/main.c Mon Jan 15 15:52:03 2007 +0000 @@ -71,6 +71,43 @@ static void usage(const char *program) { , program); } +static int get_pty_fd(struct xs_handle *xs, char *path, int seconds) +/* Check for a pty in xenstore, open it and return its fd. + * Assumes there is already a watch set in the store for this path. */ +{ + struct timeval tv; + fd_set watch_fdset; + int xs_fd = xs_fileno(xs), pty_fd = -1; + int start, now; + unsigned int len = 0; + char *pty_path, **watch_paths;; + + start = now = time(NULL); + do { + tv.tv_usec = 0; + tv.tv_sec = (start + seconds) - now; + FD_ZERO(&watch_fdset); + FD_SET(xs_fd, &watch_fdset); + if (select(xs_fd + 1, &watch_fdset, NULL, NULL, &tv)) { + /* Read the watch to drain the buffer */ + watch_paths = xs_read_watch(xs, &len); + free(watch_paths); + /* We only watch for one thing, so no need to + * disambiguate: just read the pty path */ + pty_path = xs_read(xs, XBT_NULL, path, &len); + if (pty_path != NULL) { + pty_fd = open(pty_path, O_RDWR | O_NOCTTY); + if (pty_fd == -1) + err(errno, "Could not open tty `%s'", + pty_path); + free(pty_path); + } + } + } while (pty_fd == -1 && (now = time(NULL)) < start + seconds); + return pty_fd; +} + + /* don't worry too much if setting terminal attributes fail */ static void init_term(int fd, struct termios *old) { @@ -91,23 +128,37 @@ static void restore_term(int fd, struct tcsetattr(fd, TCSAFLUSH, old); } -static int console_loop(int fd) -{ - int ret; +static int console_loop(int fd, struct xs_handle *xs, char *pty_path) +{ + int ret, xs_fd = xs_fileno(xs), max_fd; do { fd_set fds; FD_ZERO(&fds); FD_SET(STDIN_FILENO, &fds); - FD_SET(fd, &fds); - - ret = select(fd + 1, &fds, NULL, NULL, NULL); + max_fd = STDIN_FILENO; + FD_SET(xs_fd, &fds); + if (xs_fd > max_fd) max_fd = xs_fd; + if (fd != -1) FD_SET(fd, &fds); + if (fd > max_fd) max_fd = fd; + + ret = select(max_fd + 1, &fds, NULL, NULL, NULL); if (ret == -1) { if (errno == EINTR || errno == EAGAIN) { continue; } return -1; + } + + if (FD_ISSET(xs_fileno(xs), &fds)) { + int newfd = get_pty_fd(xs, pty_path, 0); + close(fd); + if (newfd == -1) + /* Console PTY has become invalid */ + return 0; + fd = newfd; + continue; } if (FD_ISSET(STDIN_FILENO, &fds)) { @@ -128,12 +179,13 @@ static int console_loop(int fd) } if (!write_sync(fd, msg, len)) { - perror("write() failed"); - return -1; - } - } - - if (FD_ISSET(fd, &fds)) { + close(fd); + fd = -1; + continue; + } + } + + if (fd != -1 && FD_ISSET(fd, &fds)) { ssize_t len; char msg[512]; @@ -143,7 +195,9 @@ static int console_loop(int fd) (errno == EINTR || errno == EAGAIN)) { continue; } - return -1; + close(fd); + fd = -1; + continue; } if (!write_sync(STDOUT_FILENO, msg, len)) { @@ -168,12 +222,10 @@ int main(int argc, char **argv) { 0 }, }; - char *str_pty, *path; - int spty; - unsigned int len = 0; + char *path; + int spty, xsfd; struct xs_handle *xs; char *end; - time_t now; while((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { switch(ch) { @@ -213,7 +265,6 @@ int main(int argc, char **argv) if (path == NULL) err(ENOMEM, "realloc"); strcat(path, "/console/tty"); - str_pty = xs_read(xs, XBT_NULL, path, &len); /* FIXME consoled currently does not assume domain-0 doesn't have a console which is good when we break domain-0 up. To keep us @@ -224,38 +275,24 @@ int main(int argc, char **argv) exit(EINVAL); } + /* Set a watch on this domain's console pty */ + if (!xs_watch(xs, path, "")) + err(errno, "Can't set watch for console pty"); + xsfd = xs_fileno(xs); + /* Wait a little bit for tty to appear. There is a race - condition that occurs after xend creates a domain. This - code might be running before consoled has noticed the new - domain and setup a pty for it. - - A xenstore watch would slightly improve responsiveness but - a timeout would still be needed since we don't want to - block forever if given an invalid domain or worse yet, a - domain that someone else has connected to. */ - - now = time(0); - while (str_pty == NULL && (now + 5) > time(0)) { - struct timeval tv = { 0, 250000 }; - select(0, NULL, NULL, NULL, &tv); /* pause briefly */ - - str_pty = xs_read(xs, XBT_NULL, path, &len); - } - - if (str_pty == NULL) { + condition that occurs after xend creates a domain. This code + might be running before consoled has noticed the new domain + and setup a pty for it. */ + spty = get_pty_fd(xs, path, 5); + if (spty == -1) { err(errno, "Could not read tty from store"); } - spty = open(str_pty, O_RDWR | O_NOCTTY); - if (spty == -1) { - err(errno, "Could not open tty `%s'", str_pty); - } - free(str_pty); + init_term(STDIN_FILENO, &attr); + console_loop(spty, xs, path); + restore_term(STDIN_FILENO, &attr); + free(path); - - init_term(STDIN_FILENO, &attr); - console_loop(spty); - restore_term(STDIN_FILENO, &attr); - return 0; } diff -r 56ca95a1d07b tools/misc/xend --- a/tools/misc/xend Mon Jan 15 15:03:07 2007 +0000 +++ b/tools/misc/xend Mon Jan 15 15:03:13 2007 +0000 @@ -44,7 +44,7 @@ for p in ['python%s' % sys.version[:3], if os.path.exists(os.path.join(d, AUXBIN)): sys.path.append(d) import xen.util.auxbin - libpath = xen.util.auxbin.libpath() + libpath = os.path.join(xen.util.auxbin.libpath(), p) sys.path = sys.path[:-1] sys.path.append(libpath) break diff -r 56ca95a1d07b tools/python/xen/xend/XendBootloader.py --- a/tools/python/xen/xend/XendBootloader.py Mon Jan 15 15:03:07 2007 +0000 +++ b/tools/python/xen/xend/XendBootloader.py Mon Jan 15 15:27:00 2007 +0000 @@ -21,12 +21,15 @@ from XendLogging import log from XendLogging import log from XendError import VmError -def bootloader(blexec, disk, quiet = False, blargs = '', kernel = '', +import pty, ptsname, termios, fcntl + +def bootloader(blexec, disk, dom, quiet = False, blargs = '', kernel = '', ramdisk = '', kernel_args = ''): """Run the boot loader executable on the given disk and return a config image. @param blexec Binary to use as the boot loader @param disk Disk to run the boot loader on. + @param dom DomainInfo representing the domain being booted. @param quiet Run in non-interactive mode, just booting the default. @param blargs Arguments to pass to the bootloader.""" @@ -50,7 +53,28 @@ def bootloader(blexec, disk, quiet = Fal raise break - child = os.fork() + # We need to present the bootloader's tty as a pty slave that xenconsole + # can access. Since the bootloader itself needs a pty slave, + # we end up with a connection like this: + # + # xenconsole -- (slave pty1 master) <-> (master pty2 slave) -- bootloader + # + # where we copy characters between the two master fds, as well as + # listening on the bootloader's fifo for the results. + + # Termios runes for very raw access to the pty master fds. + attr = [ 0, 0, termios.CS8 | termios.CREAD | termios.CLOCAL, + 0, 0, 0, [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] ] + + (m1, s1) = pty.openpty() + termios.tcsetattr(m1, termios.TCSANOW, attr) + fcntl.fcntl(m1, fcntl.F_SETFL, os.O_NDELAY); + os.close(s1) + slavename = ptsname.ptsname(m1) + dom.storeDom("console/tty", slavename) + + (child, m2) = pty.fork() if (not child): args = [ blexec ] if kernel: @@ -74,6 +98,8 @@ def bootloader(blexec, disk, quiet = Fal pass os._exit(1) + termios.tcsetattr(m2, termios.TCSANOW, attr) + fcntl.fcntl(m2, fcntl.F_SETFL, os.O_NDELAY); while True: try: r = os.open(fifo, os.O_RDONLY) @@ -82,15 +108,40 @@ def bootloader(blexec, disk, quiet = Fal continue break ret = "" + inbuf=""; outbuf=""; while True: - select.select([r], [], []) - s = os.read(r, 1024) - ret = ret + s - if len(s) == 0: - break - + sel = select.select([r, m1, m2], [m1, m2], []) + try: + if m1 in sel[0]: + s = os.read(m1, 1) + inbuf += s + if m2 in sel[1] and len(inbuf) != 0: + os.write(m2, inbuf[0]) + inbuf = inbuf[1:] + except OSError, e: + if e.errno == errno.EIO: + pass + try: + if m2 in sel[0]: + s = os.read(m2, 1) + outbuf += s + if m1 in sel[1] and len(outbuf) != 0: + os.write(m1, outbuf[0]) + outbuf = outbuf[1:] + except OSError, e: + if e.errno == errno.EIO: + pass + if r in sel[0]: + s = os.read(r, 1) + ret = ret + s + if len(s) == 0: + break + del inbuf + del outbuf os.waitpid(child, 0) os.close(r) + os.close(m2) + os.close(m1) os.unlink(fifo) if len(ret) == 0: diff -r 56ca95a1d07b tools/python/xen/xend/XendDomainInfo.py --- a/tools/python/xen/xend/XendDomainInfo.py Mon Jan 15 15:03:07 2007 +0000 +++ b/tools/python/xen/xend/XendDomainInfo.py Mon Jan 15 15:27:04 2007 +0000 @@ -1615,7 +1615,7 @@ class XendDomainInfo: fn = BOOTLOADER_LOOPBACK_DEVICE try: - blcfg = bootloader(blexec, fn, True, + blcfg = bootloader(blexec, fn, self, False, bootloader_args, kernel, ramdisk, args) finally: if mounted: diff -r 56ca95a1d07b tools/python/xen/xm/create.py --- a/tools/python/xen/xm/create.py Mon Jan 15 15:03:07 2007 +0000 +++ b/tools/python/xen/xm/create.py Mon Jan 15 15:03:13 2007 +0000 @@ -704,26 +704,6 @@ def configure_hvm(config_image, vals): config_image.append([a, vals.__dict__[a]]) config_image.append(['vncpasswd', vals.vncpasswd]) -def run_bootloader(vals, config_image): - if not os.access(vals.bootloader, os.F_OK): - err("Bootloader '%s' does not exist" % vals.bootloader) - if not os.access(vals.bootloader, os.X_OK): - err("Bootloader '%s' isn't executable" % vals.bootloader) - if len(vals.disk) < 1: - err("No disks configured and boot loader requested") - (uname, dev, mode, backend) = vals.disk[0] - file = blkif.blkdev_uname_to_file(uname) - - if vals.bootentry: - warn("The bootentry option is deprecated. Use bootargs and pass " - "--entry= directly.") - vals.bootargs = "--entry=%s" %(vals.bootentry,) - - kernel = sxp.child_value(config_image, 'kernel') - ramdisk = sxp.child_value(config_image, 'ramdisk') - args = sxp.child_value(config_image, 'args') - return bootloader(vals.bootloader, file, not vals.console_autoconnect, - vals.bootargs, kernel, ramdisk, args) def make_config(vals): """Create the domain configuration. @@ -766,11 +746,6 @@ def make_config(vals): if vals.bootloader == "pygrub": vals.bootloader = osdep.pygrub_path - # if a kernel is specified, we're using the bootloader - # non-interactively, and need to let xend run it so we preserve the - # real kernel choice. - if not vals.kernel: - config_image = run_bootloader(vals, config_image) config.append(['bootloader', vals.bootloader]) if vals.bootargs: config.append(['bootloader_args', vals.bootargs])