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"
23 /* Changed during early boot */
24 int pty_output_sigio
= 0;
25 int pty_close_sigio
= 0;
27 /* Used as a flag during SIGIO testing early in boot */
28 static volatile int got_sigio
= 0;
30 void __init
handler(int sig
)
41 static void openpty_cb(void *arg
)
43 struct openpty_arg
*info
= arg
;
46 if(openpty(&info
->master
, &info
->slave
, NULL
, NULL
, NULL
))
50 void __init
check_one_sigio(void (*proc
)(int, int))
52 struct sigaction old
, new;
53 struct openpty_arg pty
= { .master
= -1, .slave
= -1 };
54 int master
, slave
, err
;
56 initial_thread_cb(openpty_cb
, &pty
);
58 printk("openpty failed, errno = %d\n", -pty
.err
);
65 if((master
== -1) || (slave
== -1)){
66 printk("openpty failed to allocate a pty\n");
70 /* Not now, but complain so we now where we failed. */
73 panic("check_sigio : __raw failed, errno = %d\n", -err
);
75 err
= os_sigio_async(master
, slave
);
77 panic("tty_fds : sigio_async failed, err = %d\n", -err
);
79 if(sigaction(SIGIO
, NULL
, &old
) < 0)
80 panic("check_sigio : sigaction 1 failed, errno = %d\n", errno
);
82 new.sa_handler
= handler
;
83 if(sigaction(SIGIO
, &new, NULL
) < 0)
84 panic("check_sigio : sigaction 2 failed, errno = %d\n", errno
);
87 (*proc
)(master
, slave
);
89 os_close_file(master
);
92 if(sigaction(SIGIO
, &old
, NULL
) < 0)
93 panic("check_sigio : sigaction 3 failed, errno = %d\n", errno
);
96 static void tty_output(int master
, int slave
)
101 printk("Checking that host ptys support output SIGIO...");
103 memset(buf
, 0, sizeof(buf
));
105 while(os_write_file(master
, buf
, sizeof(buf
)) > 0) ;
107 panic("check_sigio : write failed, errno = %d\n", errno
);
108 while(((n
= os_read_file(slave
, buf
, sizeof(buf
))) > 0) && !got_sigio
) ;
112 pty_output_sigio
= 1;
113 } else if (n
== -EAGAIN
) {
114 printk("No, enabling workaround\n");
116 panic("check_sigio : read failed, err = %d\n", n
);
120 static void tty_close(int master
, int slave
)
122 printk("Checking that host ptys support SIGIO on close...");
124 os_close_file(slave
);
129 else printk("No, enabling workaround\n");
132 void __init
check_sigio(void)
134 if((os_access("/dev/ptmx", OS_ACC_R_OK
) < 0) &&
135 (os_access("/dev/ptyp0", OS_ACC_R_OK
) < 0)){
136 printk("No pseudo-terminals available - skipping pty SIGIO "
140 check_one_sigio(tty_output
);
141 check_one_sigio(tty_close
);
144 /* Protected by sigio_lock(), also used by sigio_cleanup, which is an
147 static int write_sigio_pid
= -1;
149 /* These arrays are initialized before the sigio thread is started, and
150 * the descriptors closed after it is killed. So, it can't see them change.
151 * On the UML side, they are changed under the sigio_lock.
153 static int write_sigio_fds
[2] = { -1, -1 };
154 static int sigio_private
[2] = { -1, -1 };
162 /* Protected by sigio_lock(). Used by the sigio thread, but the UML thread
163 * synchronizes with it.
165 struct pollfds current_poll
= {
171 struct pollfds next_poll
= {
177 static int write_sigio_thread(void *unused
)
179 struct pollfds
*fds
, tmp
;
181 int i
, n
, respond_fd
;
184 signal(SIGWINCH
, SIG_IGN
);
187 n
= poll(fds
->poll
, fds
->used
, -1);
189 if(errno
== EINTR
) continue;
190 printk("write_sigio_thread : poll returned %d, "
191 "errno = %d\n", n
, errno
);
193 for(i
= 0; i
< fds
->used
; i
++){
195 if(p
->revents
== 0) continue;
196 if(p
->fd
== sigio_private
[1]){
197 n
= os_read_file(sigio_private
[1], &c
, sizeof(c
));
199 printk("write_sigio_thread : "
200 "read failed, err = %d\n", -n
);
202 current_poll
= next_poll
;
204 respond_fd
= sigio_private
[1];
207 respond_fd
= write_sigio_fds
[1];
209 memmove(&fds
->poll
[i
], &fds
->poll
[i
+ 1],
210 (fds
->used
- i
) * sizeof(*fds
->poll
));
213 n
= os_write_file(respond_fd
, &c
, sizeof(c
));
215 printk("write_sigio_thread : write failed, "
221 static int need_poll(int n
)
223 if(n
<= next_poll
.size
){
227 kfree(next_poll
.poll
);
228 next_poll
.poll
= um_kmalloc_atomic(n
* sizeof(struct pollfd
));
229 if(next_poll
.poll
== NULL
){
230 printk("need_poll : failed to allocate new pollfds\n");
240 /* Must be called with sigio_lock held, because it's needed by the marked
241 * critical section. */
242 static void update_thread(void)
248 flags
= set_signals(0);
249 n
= os_write_file(sigio_private
[0], &c
, sizeof(c
));
251 printk("update_thread : write failed, err = %d\n", -n
);
255 n
= os_read_file(sigio_private
[0], &c
, sizeof(c
));
257 printk("update_thread : read failed, err = %d\n", -n
);
264 /* Critical section start */
265 if(write_sigio_pid
!= -1)
266 os_kill_process(write_sigio_pid
, 1);
267 write_sigio_pid
= -1;
268 os_close_file(sigio_private
[0]);
269 os_close_file(sigio_private
[1]);
270 os_close_file(write_sigio_fds
[0]);
271 os_close_file(write_sigio_fds
[1]);
272 /* Critical section end */
276 int add_sigio_fd(int fd
, int read
)
278 int err
= 0, i
, n
, events
;
281 for(i
= 0; i
< current_poll
.used
; i
++){
282 if(current_poll
.poll
[i
].fd
== fd
)
286 n
= current_poll
.used
+ 1;
291 for(i
= 0; i
< current_poll
.used
; i
++)
292 next_poll
.poll
[i
] = current_poll
.poll
[i
];
294 if(read
) events
= POLLIN
;
295 else events
= POLLOUT
;
297 next_poll
.poll
[n
- 1] = ((struct pollfd
) { .fd
= fd
,
306 int ignore_sigio_fd(int fd
)
309 int err
= 0, i
, n
= 0;
312 for(i
= 0; i
< current_poll
.used
; i
++){
313 if(current_poll
.poll
[i
].fd
== fd
) break;
315 if(i
== current_poll
.used
)
318 err
= need_poll(current_poll
.used
- 1);
322 for(i
= 0; i
< current_poll
.used
; i
++){
323 p
= ¤t_poll
.poll
[i
];
324 if(p
->fd
!= fd
) next_poll
.poll
[n
++] = current_poll
.poll
[i
];
327 printk("ignore_sigio_fd : fd %d not found\n", fd
);
338 static int setup_initial_poll(int fd
)
342 p
= um_kmalloc_atomic(sizeof(struct pollfd
));
344 printk("setup_initial_poll : failed to allocate poll\n");
347 *p
= ((struct pollfd
) { .fd
= fd
,
350 current_poll
= ((struct pollfds
) { .poll
= p
,
356 void write_sigio_workaround(void)
362 if(write_sigio_pid
!= -1)
365 err
= os_pipe(write_sigio_fds
, 1, 1);
367 printk("write_sigio_workaround - os_pipe 1 failed, "
371 err
= os_pipe(sigio_private
, 1, 1);
373 printk("write_sigio_workaround - os_pipe 2 failed, "
377 if(setup_initial_poll(sigio_private
[1]))
380 write_sigio_pid
= run_helper_thread(write_sigio_thread
, NULL
,
381 CLONE_FILES
| CLONE_VM
, &stack
, 0);
383 if(write_sigio_pid
< 0) goto out_close2
;
385 if(write_sigio_irq(write_sigio_fds
[0]))
393 os_kill_process(write_sigio_pid
, 1);
394 write_sigio_pid
= -1;
396 os_close_file(sigio_private
[0]);
397 os_close_file(sigio_private
[1]);
399 os_close_file(write_sigio_fds
[0]);
400 os_close_file(write_sigio_fds
[1]);
404 int read_sigio_fd(int fd
)
409 n
= os_read_file(fd
, &c
, sizeof(c
));
412 printk("read_sigio_fd - read failed, err = %d\n", -n
);
416 printk("read_sigio_fd - short read, bytes = %d\n", n
);
423 static void sigio_cleanup(void)
425 if (write_sigio_pid
!= -1) {
426 os_kill_process(write_sigio_pid
, 1);
427 write_sigio_pid
= -1;
431 __uml_exitcall(sigio_cleanup
);