Commit | Line | Data |
---|---|---|
8e367065 | 1 | /* |
1da177e4 LT |
2 | * 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> | |
11 | #include <errno.h> | |
12 | #include <string.h> | |
13 | #include <sched.h> | |
14 | #include <sys/socket.h> | |
15 | #include <sys/poll.h> | |
16 | #include "init.h" | |
17 | #include "user.h" | |
18 | #include "kern_util.h" | |
19 | #include "user_util.h" | |
20 | #include "sigio.h" | |
1da177e4 | 21 | #include "os.h" |
c13e5690 | 22 | #include "um_malloc.h" |
1da177e4 | 23 | |
f206aabb | 24 | /* Protected by sigio_lock(), also used by sigio_cleanup, which is an |
1da177e4 LT |
25 | * exitcall. |
26 | */ | |
27 | static int write_sigio_pid = -1; | |
28 | ||
29 | /* These arrays are initialized before the sigio thread is started, and | |
30 | * the descriptors closed after it is killed. So, it can't see them change. | |
31 | * On the UML side, they are changed under the sigio_lock. | |
32 | */ | |
5f4e8fd0 JD |
33 | #define SIGIO_FDS_INIT {-1, -1} |
34 | ||
35 | static int write_sigio_fds[2] = SIGIO_FDS_INIT; | |
36 | static int sigio_private[2] = SIGIO_FDS_INIT; | |
1da177e4 LT |
37 | |
38 | struct pollfds { | |
39 | struct pollfd *poll; | |
40 | int size; | |
41 | int used; | |
42 | }; | |
43 | ||
44 | /* Protected by sigio_lock(). Used by the sigio thread, but the UML thread | |
45 | * synchronizes with it. | |
46 | */ | |
19bdf040 JD |
47 | static struct pollfds current_poll; |
48 | static struct pollfds next_poll; | |
49 | static struct pollfds all_sigio_fds; | |
1da177e4 LT |
50 | |
51 | static int write_sigio_thread(void *unused) | |
52 | { | |
53 | struct pollfds *fds, tmp; | |
54 | struct pollfd *p; | |
55 | int i, n, respond_fd; | |
56 | char c; | |
57 | ||
cd2ee4a3 | 58 | signal(SIGWINCH, SIG_IGN); |
1da177e4 LT |
59 | fds = ¤t_poll; |
60 | while(1){ | |
61 | n = poll(fds->poll, fds->used, -1); | |
62 | if(n < 0){ | |
63 | if(errno == EINTR) continue; | |
64 | printk("write_sigio_thread : poll returned %d, " | |
65 | "errno = %d\n", n, errno); | |
66 | } | |
67 | for(i = 0; i < fds->used; i++){ | |
68 | p = &fds->poll[i]; | |
69 | if(p->revents == 0) continue; | |
70 | if(p->fd == sigio_private[1]){ | |
71 | n = os_read_file(sigio_private[1], &c, sizeof(c)); | |
72 | if(n != sizeof(c)) | |
73 | printk("write_sigio_thread : " | |
19bdf040 JD |
74 | "read on socket failed, " |
75 | "err = %d\n", -n); | |
1da177e4 LT |
76 | tmp = current_poll; |
77 | current_poll = next_poll; | |
78 | next_poll = tmp; | |
79 | respond_fd = sigio_private[1]; | |
80 | } | |
81 | else { | |
82 | respond_fd = write_sigio_fds[1]; | |
83 | fds->used--; | |
84 | memmove(&fds->poll[i], &fds->poll[i + 1], | |
85 | (fds->used - i) * sizeof(*fds->poll)); | |
86 | } | |
87 | ||
88 | n = os_write_file(respond_fd, &c, sizeof(c)); | |
89 | if(n != sizeof(c)) | |
19bdf040 JD |
90 | printk("write_sigio_thread : write on socket " |
91 | "failed, err = %d\n", -n); | |
1da177e4 LT |
92 | } |
93 | } | |
1b57e9c2 JD |
94 | |
95 | return 0; | |
1da177e4 LT |
96 | } |
97 | ||
19bdf040 | 98 | static int need_poll(struct pollfds *polls, int n) |
1da177e4 | 99 | { |
838e56a1 JD |
100 | struct pollfd *new; |
101 | ||
102 | if(n <= polls->size) | |
19bdf040 | 103 | return 0; |
838e56a1 JD |
104 | |
105 | new = um_kmalloc_atomic(n * sizeof(struct pollfd)); | |
106 | if(new == NULL){ | |
1da177e4 | 107 | printk("need_poll : failed to allocate new pollfds\n"); |
19bdf040 | 108 | return -ENOMEM; |
1da177e4 | 109 | } |
838e56a1 JD |
110 | |
111 | memcpy(new, polls->poll, polls->used * sizeof(struct pollfd)); | |
112 | kfree(polls->poll); | |
113 | ||
114 | polls->poll = new; | |
19bdf040 | 115 | polls->size = n; |
19bdf040 | 116 | return 0; |
1da177e4 LT |
117 | } |
118 | ||
119 | /* Must be called with sigio_lock held, because it's needed by the marked | |
19bdf040 JD |
120 | * critical section. |
121 | */ | |
1da177e4 LT |
122 | static void update_thread(void) |
123 | { | |
124 | unsigned long flags; | |
125 | int n; | |
126 | char c; | |
127 | ||
128 | flags = set_signals(0); | |
129 | n = os_write_file(sigio_private[0], &c, sizeof(c)); | |
130 | if(n != sizeof(c)){ | |
131 | printk("update_thread : write failed, err = %d\n", -n); | |
132 | goto fail; | |
133 | } | |
134 | ||
135 | n = os_read_file(sigio_private[0], &c, sizeof(c)); | |
136 | if(n != sizeof(c)){ | |
137 | printk("update_thread : read failed, err = %d\n", -n); | |
138 | goto fail; | |
139 | } | |
140 | ||
141 | set_signals(flags); | |
142 | return; | |
143 | fail: | |
144 | /* Critical section start */ | |
f206aabb | 145 | if(write_sigio_pid != -1) |
1da177e4 LT |
146 | os_kill_process(write_sigio_pid, 1); |
147 | write_sigio_pid = -1; | |
8e367065 JD |
148 | close(sigio_private[0]); |
149 | close(sigio_private[1]); | |
150 | close(write_sigio_fds[0]); | |
151 | close(write_sigio_fds[1]); | |
1da177e4 LT |
152 | /* Critical section end */ |
153 | set_signals(flags); | |
154 | } | |
155 | ||
19bdf040 | 156 | int add_sigio_fd(int fd) |
1da177e4 | 157 | { |
19bdf040 JD |
158 | struct pollfd *p; |
159 | int err = 0, i, n; | |
1da177e4 LT |
160 | |
161 | sigio_lock(); | |
19bdf040 JD |
162 | for(i = 0; i < all_sigio_fds.used; i++){ |
163 | if(all_sigio_fds.poll[i].fd == fd) | |
164 | break; | |
165 | } | |
166 | if(i == all_sigio_fds.used) | |
167 | goto out; | |
168 | ||
169 | p = &all_sigio_fds.poll[i]; | |
170 | ||
1da177e4 | 171 | for(i = 0; i < current_poll.used; i++){ |
f206aabb | 172 | if(current_poll.poll[i].fd == fd) |
1da177e4 LT |
173 | goto out; |
174 | } | |
175 | ||
838e56a1 JD |
176 | n = current_poll.used; |
177 | err = need_poll(&next_poll, n + 1); | |
f206aabb | 178 | if(err) |
1da177e4 LT |
179 | goto out; |
180 | ||
838e56a1 JD |
181 | memcpy(next_poll.poll, current_poll.poll, |
182 | current_poll.used * sizeof(struct pollfd)); | |
183 | next_poll.poll[n] = *p; | |
184 | next_poll.used = n + 1; | |
1da177e4 LT |
185 | update_thread(); |
186 | out: | |
187 | sigio_unlock(); | |
19bdf040 | 188 | return err; |
1da177e4 LT |
189 | } |
190 | ||
191 | int ignore_sigio_fd(int fd) | |
192 | { | |
193 | struct pollfd *p; | |
194 | int err = 0, i, n = 0; | |
195 | ||
61232f2f JD |
196 | /* This is called from exitcalls elsewhere in UML - if |
197 | * sigio_cleanup has already run, then update_thread will hang | |
198 | * or fail because the thread is no longer running. | |
199 | */ | |
200 | if(write_sigio_pid == -1) | |
201 | return -EIO; | |
202 | ||
1da177e4 LT |
203 | sigio_lock(); |
204 | for(i = 0; i < current_poll.used; i++){ | |
205 | if(current_poll.poll[i].fd == fd) break; | |
206 | } | |
207 | if(i == current_poll.used) | |
208 | goto out; | |
f206aabb | 209 | |
19bdf040 | 210 | err = need_poll(&next_poll, current_poll.used - 1); |
1da177e4 LT |
211 | if(err) |
212 | goto out; | |
213 | ||
214 | for(i = 0; i < current_poll.used; i++){ | |
215 | p = ¤t_poll.poll[i]; | |
19bdf040 JD |
216 | if(p->fd != fd) |
217 | next_poll.poll[n++] = *p; | |
1da177e4 | 218 | } |
838e56a1 | 219 | next_poll.used = current_poll.used - 1; |
1da177e4 LT |
220 | |
221 | update_thread(); | |
222 | out: | |
223 | sigio_unlock(); | |
61232f2f | 224 | return err; |
1da177e4 LT |
225 | } |
226 | ||
f206aabb | 227 | static struct pollfd *setup_initial_poll(int fd) |
1da177e4 LT |
228 | { |
229 | struct pollfd *p; | |
230 | ||
b6a2b137 PBG |
231 | p = um_kmalloc(sizeof(struct pollfd)); |
232 | if (p == NULL) { | |
1da177e4 | 233 | printk("setup_initial_poll : failed to allocate poll\n"); |
b6a2b137 | 234 | return NULL; |
1da177e4 | 235 | } |
19bdf040 | 236 | *p = ((struct pollfd) { .fd = fd, |
1da177e4 LT |
237 | .events = POLLIN, |
238 | .revents = 0 }); | |
b6a2b137 | 239 | return p; |
1da177e4 LT |
240 | } |
241 | ||
8e64d96a | 242 | static void write_sigio_workaround(void) |
1da177e4 LT |
243 | { |
244 | unsigned long stack; | |
b6a2b137 | 245 | struct pollfd *p; |
1da177e4 | 246 | int err; |
b6a2b137 PBG |
247 | int l_write_sigio_fds[2]; |
248 | int l_sigio_private[2]; | |
249 | int l_write_sigio_pid; | |
1da177e4 | 250 | |
b6a2b137 | 251 | /* We call this *tons* of times - and most ones we must just fail. */ |
1da177e4 | 252 | sigio_lock(); |
b6a2b137 PBG |
253 | l_write_sigio_pid = write_sigio_pid; |
254 | sigio_unlock(); | |
1da177e4 | 255 | |
b6a2b137 PBG |
256 | if (l_write_sigio_pid != -1) |
257 | return; | |
258 | ||
259 | err = os_pipe(l_write_sigio_fds, 1, 1); | |
1da177e4 LT |
260 | if(err < 0){ |
261 | printk("write_sigio_workaround - os_pipe 1 failed, " | |
262 | "err = %d\n", -err); | |
b6a2b137 | 263 | return; |
1da177e4 | 264 | } |
b6a2b137 | 265 | err = os_pipe(l_sigio_private, 1, 1); |
1da177e4 | 266 | if(err < 0){ |
f206aabb | 267 | printk("write_sigio_workaround - os_pipe 2 failed, " |
1da177e4 LT |
268 | "err = %d\n", -err); |
269 | goto out_close1; | |
270 | } | |
b6a2b137 PBG |
271 | |
272 | p = setup_initial_poll(l_sigio_private[1]); | |
273 | if(!p) | |
1da177e4 LT |
274 | goto out_close2; |
275 | ||
b6a2b137 PBG |
276 | sigio_lock(); |
277 | ||
278 | /* Did we race? Don't try to optimize this, please, it's not so likely | |
279 | * to happen, and no more than once at the boot. */ | |
280 | if(write_sigio_pid != -1) | |
5f4e8fd0 | 281 | goto out_free; |
1da177e4 | 282 | |
5f4e8fd0 JD |
283 | current_poll = ((struct pollfds) { .poll = p, |
284 | .used = 1, | |
285 | .size = 1 }); | |
1da177e4 | 286 | |
b6a2b137 | 287 | if (write_sigio_irq(l_write_sigio_fds[0])) |
5f4e8fd0 | 288 | goto out_clear_poll; |
1da177e4 | 289 | |
b6a2b137 PBG |
290 | memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds)); |
291 | memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private)); | |
292 | ||
5f4e8fd0 JD |
293 | write_sigio_pid = run_helper_thread(write_sigio_thread, NULL, |
294 | CLONE_FILES | CLONE_VM, &stack, 0); | |
b6a2b137 | 295 | |
5f4e8fd0 JD |
296 | if (write_sigio_pid < 0) |
297 | goto out_clear; | |
1da177e4 | 298 | |
b6a2b137 | 299 | sigio_unlock(); |
5f4e8fd0 | 300 | return; |
b6a2b137 | 301 | |
5f4e8fd0 | 302 | out_clear: |
b6a2b137 | 303 | write_sigio_pid = -1; |
5f4e8fd0 JD |
304 | write_sigio_fds[0] = -1; |
305 | write_sigio_fds[1] = -1; | |
306 | sigio_private[0] = -1; | |
307 | sigio_private[1] = -1; | |
308 | out_clear_poll: | |
309 | current_poll = ((struct pollfds) { .poll = NULL, | |
310 | .size = 0, | |
311 | .used = 0 }); | |
312 | out_free: | |
5f4e8fd0 | 313 | sigio_unlock(); |
e6fb54ab | 314 | kfree(p); |
5f4e8fd0 | 315 | out_close2: |
8e367065 JD |
316 | close(l_sigio_private[0]); |
317 | close(l_sigio_private[1]); | |
5f4e8fd0 | 318 | out_close1: |
8e367065 JD |
319 | close(l_write_sigio_fds[0]); |
320 | close(l_write_sigio_fds[1]); | |
1da177e4 LT |
321 | } |
322 | ||
8e64d96a JD |
323 | void maybe_sigio_broken(int fd, int read) |
324 | { | |
19bdf040 JD |
325 | int err; |
326 | ||
8e64d96a JD |
327 | if(!isatty(fd)) |
328 | return; | |
329 | ||
330 | if((read || pty_output_sigio) && (!read || pty_close_sigio)) | |
331 | return; | |
332 | ||
333 | write_sigio_workaround(); | |
19bdf040 JD |
334 | |
335 | sigio_lock(); | |
336 | err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1); | |
838e56a1 | 337 | if(err) |
19bdf040 | 338 | goto out; |
838e56a1 | 339 | |
19bdf040 JD |
340 | all_sigio_fds.poll[all_sigio_fds.used++] = |
341 | ((struct pollfd) { .fd = fd, | |
342 | .events = read ? POLLIN : POLLOUT, | |
343 | .revents = 0 }); | |
344 | out: | |
345 | sigio_unlock(); | |
8e64d96a JD |
346 | } |
347 | ||
29ac1c21 | 348 | static void sigio_cleanup(void) |
1da177e4 | 349 | { |
f206aabb | 350 | if(write_sigio_pid != -1){ |
1da177e4 LT |
351 | os_kill_process(write_sigio_pid, 1); |
352 | write_sigio_pid = -1; | |
353 | } | |
354 | } | |
29ac1c21 JD |
355 | |
356 | __uml_exitcall(sigio_cleanup); |