2 * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
3 * Licensed under the GPL
14 #include <sys/socket.h>
18 #include "kern_util.h"
19 #include "user_util.h"
24 /* Changed during early boot */
25 int pty_output_sigio = 0;
26 int pty_close_sigio = 0;
28 /* Used as a flag during SIGIO testing early in boot */
29 static volatile int got_sigio = 0;
31 void __init handler(int sig)
42 static void openpty_cb(void *arg)
44 struct openpty_arg *info = arg;
47 if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
51 void __init check_one_sigio(void (*proc)(int, int))
53 struct sigaction old, new;
54 struct openpty_arg pty = { .master = -1, .slave = -1 };
55 int master, slave, err;
57 initial_thread_cb(openpty_cb, &pty);
59 printk("openpty failed, errno = %d\n", -pty.err);
66 if((master == -1) || (slave == -1)){
67 printk("openpty failed to allocate a pty\n");
71 /* Not now, but complain so we now where we failed. */
74 panic("check_sigio : __raw failed, errno = %d\n", -err);
76 err = os_sigio_async(master, slave);
78 panic("tty_fds : sigio_async failed, err = %d\n", -err);
80 if(sigaction(SIGIO, NULL, &old) < 0)
81 panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
83 new.sa_handler = handler;
84 if(sigaction(SIGIO, &new, NULL) < 0)
85 panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
88 (*proc)(master, slave);
90 os_close_file(master);
93 if(sigaction(SIGIO, &old, NULL) < 0)
94 panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
97 static void tty_output(int master, int slave)
102 printk("Checking that host ptys support output SIGIO...");
104 memset(buf, 0, sizeof(buf));
106 while(os_write_file(master, buf, sizeof(buf)) > 0) ;
108 panic("check_sigio : write failed, errno = %d\n", errno);
109 while(((n = os_read_file(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
113 pty_output_sigio = 1;
115 else if(n == -EAGAIN) printk("No, enabling workaround\n");
116 else panic("check_sigio : read failed, err = %d\n", n);
119 static void tty_close(int master, int slave)
121 printk("Checking that host ptys support SIGIO on close...");
123 os_close_file(slave);
128 else printk("No, enabling workaround\n");
131 void __init check_sigio(void)
133 if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
134 (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
135 printk("No pseudo-terminals available - skipping pty SIGIO "
139 check_one_sigio(tty_output);
140 check_one_sigio(tty_close);
143 /* Protected by sigio_lock(), also used by sigio_cleanup, which is an
146 static int write_sigio_pid = -1;
148 /* These arrays are initialized before the sigio thread is started, and
149 * the descriptors closed after it is killed. So, it can't see them change.
150 * On the UML side, they are changed under the sigio_lock.
152 static int write_sigio_fds[2] = { -1, -1 };
153 static int sigio_private[2] = { -1, -1 };
161 /* Protected by sigio_lock(). Used by the sigio thread, but the UML thread
162 * synchronizes with it.
164 struct pollfds current_poll = {
170 struct pollfds next_poll = {
176 static int write_sigio_thread(void *unused)
178 struct pollfds *fds, tmp;
180 int i, n, respond_fd;
185 n = poll(fds->poll, fds->used, -1);
187 if(errno == EINTR) continue;
188 printk("write_sigio_thread : poll returned %d, "
189 "errno = %d\n", n, errno);
191 for(i = 0; i < fds->used; i++){
193 if(p->revents == 0) continue;
194 if(p->fd == sigio_private[1]){
195 n = os_read_file(sigio_private[1], &c, sizeof(c));
197 printk("write_sigio_thread : "
198 "read failed, err = %d\n", -n);
200 current_poll = next_poll;
202 respond_fd = sigio_private[1];
205 respond_fd = write_sigio_fds[1];
207 memmove(&fds->poll[i], &fds->poll[i + 1],
208 (fds->used - i) * sizeof(*fds->poll));
211 n = os_write_file(respond_fd, &c, sizeof(c));
213 printk("write_sigio_thread : write failed, "
219 static int need_poll(int n)
221 if(n <= next_poll.size){
225 if(next_poll.poll != NULL) kfree(next_poll.poll);
226 next_poll.poll = um_kmalloc_atomic(n * sizeof(struct pollfd));
227 if(next_poll.poll == NULL){
228 printk("need_poll : failed to allocate new pollfds\n");
238 static void update_thread(void)
244 flags = set_signals(0);
245 n = os_write_file(sigio_private[0], &c, sizeof(c));
247 printk("update_thread : write failed, err = %d\n", -n);
251 n = os_read_file(sigio_private[0], &c, sizeof(c));
253 printk("update_thread : read failed, err = %d\n", -n);
261 if(write_sigio_pid != -1)
262 os_kill_process(write_sigio_pid, 1);
263 write_sigio_pid = -1;
264 os_close_file(sigio_private[0]);
265 os_close_file(sigio_private[1]);
266 os_close_file(write_sigio_fds[0]);
267 os_close_file(write_sigio_fds[1]);
272 int add_sigio_fd(int fd, int read)
274 int err = 0, i, n, events;
277 for(i = 0; i < current_poll.used; i++){
278 if(current_poll.poll[i].fd == fd)
282 n = current_poll.used + 1;
287 for(i = 0; i < current_poll.used; i++)
288 next_poll.poll[i] = current_poll.poll[i];
290 if(read) events = POLLIN;
291 else events = POLLOUT;
293 next_poll.poll[n - 1] = ((struct pollfd) { .fd = fd,
302 int ignore_sigio_fd(int fd)
305 int err = 0, i, n = 0;
308 for(i = 0; i < current_poll.used; i++){
309 if(current_poll.poll[i].fd == fd) break;
311 if(i == current_poll.used)
314 err = need_poll(current_poll.used - 1);
318 for(i = 0; i < current_poll.used; i++){
319 p = ¤t_poll.poll[i];
320 if(p->fd != fd) next_poll.poll[n++] = current_poll.poll[i];
323 printk("ignore_sigio_fd : fd %d not found\n", fd);
334 static int setup_initial_poll(int fd)
338 p = um_kmalloc(sizeof(struct pollfd));
340 printk("setup_initial_poll : failed to allocate poll\n");
343 *p = ((struct pollfd) { .fd = fd,
346 current_poll = ((struct pollfds) { .poll = p,
352 void write_sigio_workaround(void)
358 if(write_sigio_pid != -1)
361 err = os_pipe(write_sigio_fds, 1, 1);
363 printk("write_sigio_workaround - os_pipe 1 failed, "
367 err = os_pipe(sigio_private, 1, 1);
369 printk("write_sigio_workaround - os_pipe 2 failed, "
373 if(setup_initial_poll(sigio_private[1]))
376 write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
377 CLONE_FILES | CLONE_VM, &stack, 0);
379 if(write_sigio_pid < 0) goto out_close2;
381 if(write_sigio_irq(write_sigio_fds[0]))
389 os_kill_process(write_sigio_pid, 1);
390 write_sigio_pid = -1;
392 os_close_file(sigio_private[0]);
393 os_close_file(sigio_private[1]);
395 os_close_file(write_sigio_fds[0]);
396 os_close_file(write_sigio_fds[1]);
400 int read_sigio_fd(int fd)
405 n = os_read_file(fd, &c, sizeof(c));
408 printk("read_sigio_fd - read failed, err = %d\n", -n);
412 printk("read_sigio_fd - short read, bytes = %d\n", n);
419 static void sigio_cleanup(void)
421 if(write_sigio_pid != -1)
422 os_kill_process(write_sigio_pid, 1);
425 __uml_exitcall(sigio_cleanup);
428 * Overrides for Emacs so that we follow Linus's tabbing style.
429 * Emacs will notice this stuff at the end of the file and automatically
430 * adjust the settings for this buffer only. This must remain at the end
432 * ---------------------------------------------------------------------------
434 * c-file-style: "linux"