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