uml: tidy recently-moved code
[linux-2.6.git] / 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 }