arch/um/drivers/chan_user.c

   1 /*
   2  * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include <unistd.h>
   7 #include <stdlib.h>
   8 #include <errno.h>
   9 #include <termios.h>
  10 #include <string.h>
  11 #include <signal.h>
  12 #include <sched.h>
  13 #include <sys/stat.h>
  14 #include <sys/ioctl.h>
  15 #include <sys/socket.h>
  16 #include "kern_util.h"
  17 #include "chan_user.h"
  18 #include "user.h"
  19 #include "os.h"
  20 #include "choose-mode.h"
  21 #include "mode.h"
  22 #include "um_malloc.h"
  23
  24 void generic_close(int fd, void *unused)
  25 {
  26         close(fd);
  27 }
  28
  29 int generic_read(int fd, char *c_out, void *unused)
  30 {
  31         int n;
  32
  33         n = read(fd, c_out, sizeof(*c_out));
  34         if (n > 0)
  35                 return n;
  36         else if (errno == EAGAIN)
  37                 return 0;
  38         else if (n == 0)
  39                 return -EIO;
  40         return -errno;
  41 }
  42
  43 /* XXX Trivial wrapper around write */
  44
  45 int generic_write(int fd, const char *buf, int n, void *unused)
  46 {
  47         return write(fd, buf, n);
  48 }
  49
  50 int generic_window_size(int fd, void *unused, unsigned short *rows_out,
  51                         unsigned short *cols_out)
  52 {
  53         struct winsize size;
  54         int ret;
  55
  56         if(ioctl(fd, TIOCGWINSZ, &size) < 0)
  57                 return -errno;
  58
  59         ret = ((*rows_out != size.ws_row) || (*cols_out != size.ws_col));
  60
  61         *rows_out = size.ws_row;
  62         *cols_out = size.ws_col;
  63
  64         return ret;
  65 }
  66
  67 void generic_free(void *data)
  68 {
  69         kfree(data);
  70 }
  71
  72 int generic_console_write(int fd, const char *buf, int n)
  73 {
  74         struct termios save, new;
  75         int err;
  76
  77         if(isatty(fd)){
  78                 CATCH_EINTR(err = tcgetattr(fd, &save));
  79                 if (err)
  80                         goto error;
  81                 new = save;
  82                 /* The terminal becomes a bit less raw, to handle \n also as
  83                  * "Carriage Return", not only as "New Line". Otherwise, the new
  84                  * line won't start at the first column.*/
  85                 new.c_oflag |= OPOST;
  86                 CATCH_EINTR(err = tcsetattr(fd, TCSAFLUSH, &new));
  87                 if (err)
  88                         goto error;
  89         }
  90         err = generic_write(fd, buf, n, NULL);
  91         /* Restore raw mode, in any case; we *must* ignore any error apart
  92          * EINTR, except for debug.*/
  93         if(isatty(fd))
  94                 CATCH_EINTR(tcsetattr(fd, TCSAFLUSH, &save));
  95         return(err);
  96 error:
  97         return(-errno);
  98 }
  99
 100 /*
 101  * UML SIGWINCH handling
 102  *
 103  * The point of this is to handle SIGWINCH on consoles which have host
 104  * ttys and relay them inside UML to whatever might be running on the
 105  * console and cares about the window size (since SIGWINCH notifies
 106  * about terminal size changes).
 107  *
 108  * So, we have a separate thread for each host tty attached to a UML
 109  * device (side-issue - I'm annoyed that one thread can't have
 110  * multiple controlling ttys for the purpose of handling SIGWINCH, but
 111  * I imagine there are other reasons that doesn't make any sense).
 112  *
 113  * SIGWINCH can't be received synchronously, so you have to set up to
 114  * receive it as a signal.  That being the case, if you are going to
 115  * wait for it, it is convenient to sit in sigsuspend() and wait for
 116  * the signal to bounce you out of it (see below for how we make sure
 117  * to exit only on SIGWINCH).
 118  */
 119
 120 static void winch_handler(int sig)
 121 {
 122 }
 123
 124 struct winch_data {
 125         int pty_fd;
 126         int pipe_fd;
 127 };
 128
 129 static int winch_thread(void *arg)
 130 {
 131         struct winch_data *data = arg;
 132         sigset_t sigs;
 133         int pty_fd, pipe_fd;
 134         int count, err;
 135         char c = 1;
 136
 137         pty_fd = data->pty_fd;
 138         pipe_fd = data->pipe_fd;
 139         count = os_write_file(pipe_fd, &c, sizeof(c));
 140         if(count != sizeof(c))
 141                 printk("winch_thread : failed to write synchronization "
 142                        "byte, err = %d\n", -count);
 143
 144         /* We are not using SIG_IGN on purpose, so don't fix it as I thought to
 145          * do! If using SIG_IGN, the sigsuspend() call below would not stop on
 146          * SIGWINCH. */
 147
 148         signal(SIGWINCH, winch_handler);
 149         sigfillset(&sigs);
 150         /* Block all signals possible. */
 151         if(sigprocmask(SIG_SETMASK, &sigs, NULL) < 0){
 152                 printk("winch_thread : sigprocmask failed, errno = %d\n",
 153                        errno);
 154                 exit(1);
 155         }
 156         /* In sigsuspend(), block anything else than SIGWINCH. */
 157         sigdelset(&sigs, SIGWINCH);
 158
 159         if(setsid() < 0){
 160                 printk("winch_thread : setsid failed, errno = %d\n", errno);
 161                 exit(1);
 162         }
 163
 164         err = os_new_tty_pgrp(pty_fd, os_getpid());
 165         if(err < 0){
 166                 printk("winch_thread : new_tty_pgrp failed on fd %d, "
 167                        "err = %d\n", pty_fd, -err);
 168                 exit(1);
 169         }
 170
 171         /* These are synchronization calls between various UML threads on the
 172          * host - since they are not different kernel threads, we cannot use
 173          * kernel semaphores. We don't use SysV semaphores because they are
 174          * persistent. */
 175         count = os_read_file(pipe_fd, &c, sizeof(c));
 176         if(count != sizeof(c))
 177                 printk("winch_thread : failed to read synchronization byte, "
 178                        "err = %d\n", -count);
 179
 180         while(1){
 181                 /* This will be interrupted by SIGWINCH only, since
 182                  * other signals are blocked.
 183                  */
 184                 sigsuspend(&sigs);
 185
 186                 count = os_write_file(pipe_fd, &c, sizeof(c));
 187                 if(count != sizeof(c))
 188                         printk("winch_thread : write failed, err = %d\n",
 189                                -count);
 190         }
 191 }
 192
 193 static int winch_tramp(int fd, struct tty_struct *tty, int *fd_out,
 194                        unsigned long *stack_out)
 195 {
 196         struct winch_data data;
 197         int fds[2], n, err;
 198         char c;
 199
 200         err = os_pipe(fds, 1, 1);
 201         if(err < 0){
 202                 printk("winch_tramp : os_pipe failed, err = %d\n", -err);
 203                 goto out;
 204         }
 205
 206         data = ((struct winch_data) { .pty_fd           = fd,
 207                                       .pipe_fd          = fds[1] } );
 208         /* CLONE_FILES so this thread doesn't hold open files which are open
 209          * now, but later closed in a different thread.  This is a
 210          * problem with /dev/net/tun, which if held open by this
 211          * thread, prevents the TUN/TAP device from being reused.
 212          */
 213         err = run_helper_thread(winch_thread, &data, CLONE_FILES, stack_out);
 214         if(err < 0){
 215                 printk("fork of winch_thread failed - errno = %d\n", -err);
 216                 goto out_close;
 217         }
 218
 219         *fd_out = fds[0];
 220         n = os_read_file(fds[0], &c, sizeof(c));
 221         if(n != sizeof(c)){
 222                 printk("winch_tramp : failed to read synchronization byte\n");
 223                 printk("read failed, err = %d\n", -n);
 224                 printk("fd %d will not support SIGWINCH\n", fd);
 225                 err = -EINVAL;
 226                 goto out_close;
 227         }
 228
 229         if (os_set_fd_block(*fd_out, 0)) {
 230                 printk("winch_tramp: failed to set thread_fd non-blocking.\n");
 231                 goto out_close;
 232         }
 233
 234         return err;
 235
 236  out_close:
 237         os_close_file(fds[1]);
 238         os_close_file(fds[0]);
 239  out:
 240         return err;
 241 }
 242
 243 void register_winch(int fd, struct tty_struct *tty)
 244 {
 245         unsigned long stack;
 246         int pid, thread, count, thread_fd = -1;
 247         char c = 1;
 248
 249         if(!isatty(fd))
 250                 return;
 251
 252         pid = tcgetpgrp(fd);
 253         if (!CHOOSE_MODE_PROC(is_tracer_winch, is_skas_winch, pid, fd, tty) &&
 254             (pid == -1)) {
 255                 thread = winch_tramp(fd, tty, &thread_fd, &stack);
 256                 if (thread < 0)
 257                         return;
 258
 259                 register_winch_irq(thread_fd, fd, thread, tty, stack);
 260
 261                 count = os_write_file(thread_fd, &c, sizeof(c));
 262                 if(count != sizeof(c))
 263                         printk("register_winch : failed to write "
 264                                "synchronization byte, err = %d\n", -count);
 265         }
 266 }