blob: dc03e9cccb630146c0d62504d5ff4ea5e2c14b50 [file] [log] [blame]
Jeff Dike8e367062006-03-27 01:14:32 -08001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
3 * Licensed under the GPL
4 */
5
6#include <unistd.h>
7#include <stdlib.h>
8#include <termios.h>
9#include <pty.h>
10#include <signal.h>
Jeff Dikec65badb2007-05-06 14:51:06 -070011#include <fcntl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <errno.h>
13#include <string.h>
14#include <sched.h>
15#include <sys/socket.h>
16#include <sys/poll.h>
17#include "init.h"
18#include "user.h"
19#include "kern_util.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "sigio.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "os.h"
Paolo 'Blaisorblade' Giarrussoc13e5692006-10-19 23:28:20 -070022#include "um_malloc.h"
Jeff Dikec65badb2007-05-06 14:51:06 -070023#include "init.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Jeff Dikef206aab2006-03-27 01:14:33 -080025/* Protected by sigio_lock(), also used by sigio_cleanup, which is an
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 * exitcall.
27 */
28static int write_sigio_pid = -1;
Jeff Dikec4399012007-07-15 23:38:56 -070029static unsigned long write_sigio_stack;
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31/* These arrays are initialized before the sigio thread is started, and
32 * the descriptors closed after it is killed. So, it can't see them change.
33 * On the UML side, they are changed under the sigio_lock.
34 */
Jeff Dike5f4e8fd2006-03-27 01:14:40 -080035#define SIGIO_FDS_INIT {-1, -1}
36
37static int write_sigio_fds[2] = SIGIO_FDS_INIT;
38static int sigio_private[2] = SIGIO_FDS_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40struct pollfds {
41 struct pollfd *poll;
42 int size;
43 int used;
44};
45
46/* Protected by sigio_lock(). Used by the sigio thread, but the UML thread
47 * synchronizes with it.
48 */
Jeff Dike19bdf042006-09-25 23:33:04 -070049static struct pollfds current_poll;
50static struct pollfds next_poll;
51static struct pollfds all_sigio_fds;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53static int write_sigio_thread(void *unused)
54{
55 struct pollfds *fds, tmp;
56 struct pollfd *p;
57 int i, n, respond_fd;
58 char c;
59
Jeff Dikecd2ee4a2005-05-05 16:15:32 -070060 signal(SIGWINCH, SIG_IGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 fds = &current_poll;
62 while(1){
63 n = poll(fds->poll, fds->used, -1);
64 if(n < 0){
65 if(errno == EINTR) continue;
66 printk("write_sigio_thread : poll returned %d, "
67 "errno = %d\n", n, errno);
68 }
69 for(i = 0; i < fds->used; i++){
70 p = &fds->poll[i];
71 if(p->revents == 0) continue;
72 if(p->fd == sigio_private[1]){
Jeff Dikea61f3342007-05-06 14:51:35 -070073 CATCH_EINTR(n = read(sigio_private[1], &c,
74 sizeof(c)));
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 if(n != sizeof(c))
76 printk("write_sigio_thread : "
Jeff Dike19bdf042006-09-25 23:33:04 -070077 "read on socket failed, "
Jeff Dikea61f3342007-05-06 14:51:35 -070078 "err = %d\n", errno);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 tmp = current_poll;
80 current_poll = next_poll;
81 next_poll = tmp;
82 respond_fd = sigio_private[1];
83 }
84 else {
85 respond_fd = write_sigio_fds[1];
86 fds->used--;
87 memmove(&fds->poll[i], &fds->poll[i + 1],
88 (fds->used - i) * sizeof(*fds->poll));
89 }
90
Jeff Dikea61f3342007-05-06 14:51:35 -070091 CATCH_EINTR(n = write(respond_fd, &c, sizeof(c)));
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 if(n != sizeof(c))
Jeff Dike19bdf042006-09-25 23:33:04 -070093 printk("write_sigio_thread : write on socket "
Jeff Dikea61f3342007-05-06 14:51:35 -070094 "failed, err = %d\n", errno);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 }
96 }
Jeff Dike1b57e9c2006-01-06 00:18:49 -080097
98 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099}
100
Jeff Dike19bdf042006-09-25 23:33:04 -0700101static int need_poll(struct pollfds *polls, int n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
Jeff Dike838e56a2007-02-16 01:27:21 -0800103 struct pollfd *new;
104
105 if(n <= polls->size)
Jeff Dike19bdf042006-09-25 23:33:04 -0700106 return 0;
Jeff Dike838e56a2007-02-16 01:27:21 -0800107
Jeff Dikee4c4bf92007-07-15 23:38:56 -0700108 new = kmalloc(n * sizeof(struct pollfd), UM_GFP_ATOMIC);
Jeff Dike838e56a2007-02-16 01:27:21 -0800109 if(new == NULL){
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 printk("need_poll : failed to allocate new pollfds\n");
Jeff Dike19bdf042006-09-25 23:33:04 -0700111 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 }
Jeff Dike838e56a2007-02-16 01:27:21 -0800113
114 memcpy(new, polls->poll, polls->used * sizeof(struct pollfd));
115 kfree(polls->poll);
116
117 polls->poll = new;
Jeff Dike19bdf042006-09-25 23:33:04 -0700118 polls->size = n;
Jeff Dike19bdf042006-09-25 23:33:04 -0700119 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120}
121
122/* Must be called with sigio_lock held, because it's needed by the marked
Jeff Dike19bdf042006-09-25 23:33:04 -0700123 * critical section.
124 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static void update_thread(void)
126{
127 unsigned long flags;
128 int n;
129 char c;
130
131 flags = set_signals(0);
Jeff Dikea61f3342007-05-06 14:51:35 -0700132 n = write(sigio_private[0], &c, sizeof(c));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 if(n != sizeof(c)){
Jeff Dikea61f3342007-05-06 14:51:35 -0700134 printk("update_thread : write failed, err = %d\n", errno);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 goto fail;
136 }
137
Jeff Dikea61f3342007-05-06 14:51:35 -0700138 CATCH_EINTR(n = read(sigio_private[0], &c, sizeof(c)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 if(n != sizeof(c)){
Jeff Dikea61f3342007-05-06 14:51:35 -0700140 printk("update_thread : read failed, err = %d\n", errno);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 goto fail;
142 }
143
144 set_signals(flags);
145 return;
146 fail:
147 /* Critical section start */
Jeff Dikec4399012007-07-15 23:38:56 -0700148 if (write_sigio_pid != -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 os_kill_process(write_sigio_pid, 1);
Jeff Dikec4399012007-07-15 23:38:56 -0700150 free_stack(write_sigio_stack, 0);
151 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 write_sigio_pid = -1;
Jeff Dike8e367062006-03-27 01:14:32 -0800153 close(sigio_private[0]);
154 close(sigio_private[1]);
155 close(write_sigio_fds[0]);
156 close(write_sigio_fds[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 /* Critical section end */
158 set_signals(flags);
159}
160
Jeff Dike19bdf042006-09-25 23:33:04 -0700161int add_sigio_fd(int fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
Jeff Dike19bdf042006-09-25 23:33:04 -0700163 struct pollfd *p;
164 int err = 0, i, n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166 sigio_lock();
Jeff Dike19bdf042006-09-25 23:33:04 -0700167 for(i = 0; i < all_sigio_fds.used; i++){
168 if(all_sigio_fds.poll[i].fd == fd)
169 break;
170 }
171 if(i == all_sigio_fds.used)
172 goto out;
173
174 p = &all_sigio_fds.poll[i];
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 for(i = 0; i < current_poll.used; i++){
Jeff Dikef206aab2006-03-27 01:14:33 -0800177 if(current_poll.poll[i].fd == fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 goto out;
179 }
180
Jeff Dike838e56a2007-02-16 01:27:21 -0800181 n = current_poll.used;
182 err = need_poll(&next_poll, n + 1);
Jeff Dikef206aab2006-03-27 01:14:33 -0800183 if(err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 goto out;
185
Jeff Dike838e56a2007-02-16 01:27:21 -0800186 memcpy(next_poll.poll, current_poll.poll,
187 current_poll.used * sizeof(struct pollfd));
188 next_poll.poll[n] = *p;
189 next_poll.used = n + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 update_thread();
191 out:
192 sigio_unlock();
Jeff Dike19bdf042006-09-25 23:33:04 -0700193 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194}
195
196int ignore_sigio_fd(int fd)
197{
198 struct pollfd *p;
199 int err = 0, i, n = 0;
200
Jeff Dike61232f22006-07-10 04:45:11 -0700201 /* This is called from exitcalls elsewhere in UML - if
202 * sigio_cleanup has already run, then update_thread will hang
203 * or fail because the thread is no longer running.
204 */
205 if(write_sigio_pid == -1)
206 return -EIO;
207
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 sigio_lock();
209 for(i = 0; i < current_poll.used; i++){
210 if(current_poll.poll[i].fd == fd) break;
211 }
212 if(i == current_poll.used)
213 goto out;
Jeff Dikef206aab2006-03-27 01:14:33 -0800214
Jeff Dike19bdf042006-09-25 23:33:04 -0700215 err = need_poll(&next_poll, current_poll.used - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 if(err)
217 goto out;
218
219 for(i = 0; i < current_poll.used; i++){
220 p = &current_poll.poll[i];
Jeff Dike19bdf042006-09-25 23:33:04 -0700221 if(p->fd != fd)
222 next_poll.poll[n++] = *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 }
Jeff Dike838e56a2007-02-16 01:27:21 -0800224 next_poll.used = current_poll.used - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 update_thread();
227 out:
228 sigio_unlock();
Jeff Dike61232f22006-07-10 04:45:11 -0700229 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230}
231
Jeff Dikef206aab2006-03-27 01:14:33 -0800232static struct pollfd *setup_initial_poll(int fd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
234 struct pollfd *p;
235
Jeff Dikee4c4bf92007-07-15 23:38:56 -0700236 p = kmalloc(sizeof(struct pollfd), UM_GFP_KERNEL);
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800237 if (p == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 printk("setup_initial_poll : failed to allocate poll\n");
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800239 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 }
Jeff Dike19bdf042006-09-25 23:33:04 -0700241 *p = ((struct pollfd) { .fd = fd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 .events = POLLIN,
243 .revents = 0 });
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800244 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
246
Jeff Dike8e64d96a2006-07-10 04:45:11 -0700247static void write_sigio_workaround(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248{
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800249 struct pollfd *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 int err;
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800251 int l_write_sigio_fds[2];
252 int l_sigio_private[2];
253 int l_write_sigio_pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800255 /* We call this *tons* of times - and most ones we must just fail. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 sigio_lock();
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800257 l_write_sigio_pid = write_sigio_pid;
258 sigio_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800260 if (l_write_sigio_pid != -1)
261 return;
262
263 err = os_pipe(l_write_sigio_fds, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 if(err < 0){
265 printk("write_sigio_workaround - os_pipe 1 failed, "
266 "err = %d\n", -err);
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800267 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 }
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800269 err = os_pipe(l_sigio_private, 1, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 if(err < 0){
Jeff Dikef206aab2006-03-27 01:14:33 -0800271 printk("write_sigio_workaround - os_pipe 2 failed, "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 "err = %d\n", -err);
273 goto out_close1;
274 }
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800275
276 p = setup_initial_poll(l_sigio_private[1]);
277 if(!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 goto out_close2;
279
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800280 sigio_lock();
281
282 /* Did we race? Don't try to optimize this, please, it's not so likely
283 * to happen, and no more than once at the boot. */
284 if(write_sigio_pid != -1)
Jeff Dike5f4e8fd2006-03-27 01:14:40 -0800285 goto out_free;
286
287 current_poll = ((struct pollfds) { .poll = p,
288 .used = 1,
289 .size = 1 });
290
291 if (write_sigio_irq(l_write_sigio_fds[0]))
292 goto out_clear_poll;
293
294 memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
295 memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800296
297 write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
Jeff Dikec4399012007-07-15 23:38:56 -0700298 CLONE_FILES | CLONE_VM,
299 &write_sigio_stack);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
Paolo 'Blaisorblade' Giarrussob6a2b132006-01-18 17:42:57 -0800301 if (write_sigio_pid < 0)
302 goto out_clear;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 sigio_unlock();
305 return;
306
Jeff Dike5f4e8fd2006-03-27 01:14:40 -0800307out_clear:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 write_sigio_pid = -1;
Jeff Dike5f4e8fd2006-03-27 01:14:40 -0800309 write_sigio_fds[0] = -1;
310 write_sigio_fds[1] = -1;
311 sigio_private[0] = -1;
312 sigio_private[1] = -1;
313out_clear_poll:
314 current_poll = ((struct pollfds) { .poll = NULL,
315 .size = 0,
316 .used = 0 });
317out_free:
Jeff Dike5f4e8fd2006-03-27 01:14:40 -0800318 sigio_unlock();
Paolo 'Blaisorblade' Giarrussoe6fb54a2006-04-10 22:53:36 -0700319 kfree(p);
Jeff Dike5f4e8fd2006-03-27 01:14:40 -0800320out_close2:
Jeff Dike8e367062006-03-27 01:14:32 -0800321 close(l_sigio_private[0]);
322 close(l_sigio_private[1]);
Jeff Dike5f4e8fd2006-03-27 01:14:40 -0800323out_close1:
Jeff Dike8e367062006-03-27 01:14:32 -0800324 close(l_write_sigio_fds[0]);
325 close(l_write_sigio_fds[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
Jeff Dikec65badb2007-05-06 14:51:06 -0700328/* Changed during early boot */
329static int pty_output_sigio = 0;
330static int pty_close_sigio = 0;
331
Jeff Dike8e64d96a2006-07-10 04:45:11 -0700332void maybe_sigio_broken(int fd, int read)
333{
Jeff Dike19bdf042006-09-25 23:33:04 -0700334 int err;
335
Jeff Dike8e64d96a2006-07-10 04:45:11 -0700336 if(!isatty(fd))
337 return;
338
339 if((read || pty_output_sigio) && (!read || pty_close_sigio))
340 return;
341
342 write_sigio_workaround();
Jeff Dike19bdf042006-09-25 23:33:04 -0700343
344 sigio_lock();
345 err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1);
Jeff Dike04a51e62007-02-28 20:13:11 -0800346 if(err){
347 printk("maybe_sigio_broken - failed to add pollfd for "
348 "descriptor %d\n", fd);
Jeff Dike19bdf042006-09-25 23:33:04 -0700349 goto out;
Jeff Dike04a51e62007-02-28 20:13:11 -0800350 }
Jeff Dike838e56a2007-02-16 01:27:21 -0800351
Jeff Dike19bdf042006-09-25 23:33:04 -0700352 all_sigio_fds.poll[all_sigio_fds.used++] =
353 ((struct pollfd) { .fd = fd,
354 .events = read ? POLLIN : POLLOUT,
355 .revents = 0 });
356out:
357 sigio_unlock();
Jeff Dike8e64d96a2006-07-10 04:45:11 -0700358}
359
Jeff Dike29ac1c22006-07-10 04:45:12 -0700360static void sigio_cleanup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
Jeff Dikec4399012007-07-15 23:38:56 -0700362 if (write_sigio_pid == -1)
363 return;
364
365 os_kill_process(write_sigio_pid, 1);
366 free_stack(write_sigio_stack, 0);
367 write_sigio_pid = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368}
Jeff Dike29ac1c22006-07-10 04:45:12 -0700369
370__uml_exitcall(sigio_cleanup);
Jeff Dikec65badb2007-05-06 14:51:06 -0700371
372/* Used as a flag during SIGIO testing early in boot */
373static volatile int got_sigio = 0;
374
375static void __init handler(int sig)
376{
377 got_sigio = 1;
378}
379
380struct openpty_arg {
381 int master;
382 int slave;
383 int err;
384};
385
386static void openpty_cb(void *arg)
387{
388 struct openpty_arg *info = arg;
389
390 info->err = 0;
391 if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
392 info->err = -errno;
393}
394
395static int async_pty(int master, int slave)
396{
397 int flags;
398
399 flags = fcntl(master, F_GETFL);
400 if(flags < 0)
401 return -errno;
402
403 if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
404 (fcntl(master, F_SETOWN, os_getpid()) < 0))
405 return -errno;
406
407 if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0))
408 return -errno;
409
410 return(0);
411}
412
413static void __init check_one_sigio(void (*proc)(int, int))
414{
415 struct sigaction old, new;
416 struct openpty_arg pty = { .master = -1, .slave = -1 };
417 int master, slave, err;
418
419 initial_thread_cb(openpty_cb, &pty);
420 if(pty.err){
421 printk("openpty failed, errno = %d\n", -pty.err);
422 return;
423 }
424
425 master = pty.master;
426 slave = pty.slave;
427
428 if((master == -1) || (slave == -1)){
429 printk("openpty failed to allocate a pty\n");
430 return;
431 }
432
433 /* Not now, but complain so we now where we failed. */
434 err = raw(master);
435 if (err < 0)
436 panic("check_sigio : __raw failed, errno = %d\n", -err);
437
438 err = async_pty(master, slave);
439 if(err < 0)
440 panic("tty_fds : sigio_async failed, err = %d\n", -err);
441
442 if(sigaction(SIGIO, NULL, &old) < 0)
443 panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
444 new = old;
445 new.sa_handler = handler;
446 if(sigaction(SIGIO, &new, NULL) < 0)
447 panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
448
449 got_sigio = 0;
450 (*proc)(master, slave);
451
452 close(master);
453 close(slave);
454
455 if(sigaction(SIGIO, &old, NULL) < 0)
456 panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
457}
458
459static void tty_output(int master, int slave)
460{
461 int n;
462 char buf[512];
463
464 printk("Checking that host ptys support output SIGIO...");
465
466 memset(buf, 0, sizeof(buf));
467
Jeff Dikea61f3342007-05-06 14:51:35 -0700468 while(write(master, buf, sizeof(buf)) > 0) ;
Jeff Dikec65badb2007-05-06 14:51:06 -0700469 if(errno != EAGAIN)
Jeff Dikeef0470c2007-05-06 14:51:33 -0700470 panic("tty_output : write failed, errno = %d\n", errno);
Jeff Dikea61f3342007-05-06 14:51:35 -0700471 while(((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
Jeff Dikec65badb2007-05-06 14:51:06 -0700472
473 if(got_sigio){
474 printk("Yes\n");
475 pty_output_sigio = 1;
476 }
Jeff Dikeef0470c2007-05-06 14:51:33 -0700477 else if(n == -EAGAIN)
478 printk("No, enabling workaround\n");
479 else panic("tty_output : read failed, err = %d\n", n);
Jeff Dikec65badb2007-05-06 14:51:06 -0700480}
481
482static void tty_close(int master, int slave)
483{
484 printk("Checking that host ptys support SIGIO on close...");
485
486 close(slave);
487 if(got_sigio){
488 printk("Yes\n");
489 pty_close_sigio = 1;
490 }
491 else printk("No, enabling workaround\n");
492}
493
494void __init check_sigio(void)
495{
496 if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
497 (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
498 printk("No pseudo-terminals available - skipping pty SIGIO "
499 "check\n");
500 return;
501 }
502 check_one_sigio(tty_output);
503 check_one_sigio(tty_close);
504}
505
506/* Here because it only does the SIGIO testing for now */
507void __init os_check_bugs(void)
508{
509 check_sigio();
510}