Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/agpgart
[linux-2.6] / arch / um / os-Linux / sigio.c
1 /*
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"
21 #include "os.h"
22 #include "um_malloc.h"
23
24 /* Protected by sigio_lock(), also used by sigio_cleanup, which is an
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  */
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;
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  */
47 static struct pollfds current_poll;
48 static struct pollfds next_poll;
49 static struct pollfds all_sigio_fds;
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
58         signal(SIGWINCH, SIG_IGN);
59         fds = &current_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 : "
74                                                "read on socket failed, "
75                                                "err = %d\n", -n);
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))
90                                 printk("write_sigio_thread : write on socket "
91                                        "failed, err = %d\n", -n);
92                 }
93         }
94
95         return 0;
96 }
97
98 static int need_poll(struct pollfds *polls, int n)
99 {
100         if(n <= polls->size){
101                 polls->used = n;
102                 return 0;
103         }
104         kfree(polls->poll);
105         polls->poll = um_kmalloc_atomic(n * sizeof(struct pollfd));
106         if(polls->poll == NULL){
107                 printk("need_poll : failed to allocate new pollfds\n");
108                 polls->size = 0;
109                 polls->used = 0;
110                 return -ENOMEM;
111         }
112         polls->size = n;
113         polls->used = n;
114         return 0;
115 }
116
117 /* Must be called with sigio_lock held, because it's needed by the marked
118  * critical section.
119  */
120 static void update_thread(void)
121 {
122         unsigned long flags;
123         int n;
124         char c;
125
126         flags = set_signals(0);
127         n = os_write_file(sigio_private[0], &c, sizeof(c));
128         if(n != sizeof(c)){
129                 printk("update_thread : write failed, err = %d\n", -n);
130                 goto fail;
131         }
132
133         n = os_read_file(sigio_private[0], &c, sizeof(c));
134         if(n != sizeof(c)){
135                 printk("update_thread : read failed, err = %d\n", -n);
136                 goto fail;
137         }
138
139         set_signals(flags);
140         return;
141  fail:
142         /* Critical section start */
143         if(write_sigio_pid != -1)
144                 os_kill_process(write_sigio_pid, 1);
145         write_sigio_pid = -1;
146         close(sigio_private[0]);
147         close(sigio_private[1]);
148         close(write_sigio_fds[0]);
149         close(write_sigio_fds[1]);
150         /* Critical section end */
151         set_signals(flags);
152 }
153
154 int add_sigio_fd(int fd)
155 {
156         struct pollfd *p;
157         int err = 0, i, n;
158
159         sigio_lock();
160         for(i = 0; i < all_sigio_fds.used; i++){
161                 if(all_sigio_fds.poll[i].fd == fd)
162                         break;
163         }
164         if(i == all_sigio_fds.used)
165                 goto out;
166
167         p = &all_sigio_fds.poll[i];
168
169         for(i = 0; i < current_poll.used; i++){
170                 if(current_poll.poll[i].fd == fd)
171                         goto out;
172         }
173
174         n = current_poll.used + 1;
175         err = need_poll(&next_poll, n);
176         if(err)
177                 goto out;
178
179         for(i = 0; i < current_poll.used; i++)
180                 next_poll.poll[i] = current_poll.poll[i];
181
182         next_poll.poll[n - 1] = *p;
183         update_thread();
184  out:
185         sigio_unlock();
186         return err;
187 }
188
189 int ignore_sigio_fd(int fd)
190 {
191         struct pollfd *p;
192         int err = 0, i, n = 0;
193
194         /* This is called from exitcalls elsewhere in UML - if
195          * sigio_cleanup has already run, then update_thread will hang
196          * or fail because the thread is no longer running.
197          */
198         if(write_sigio_pid == -1)
199                 return -EIO;
200
201         sigio_lock();
202         for(i = 0; i < current_poll.used; i++){
203                 if(current_poll.poll[i].fd == fd) break;
204         }
205         if(i == current_poll.used)
206                 goto out;
207
208         err = need_poll(&next_poll, current_poll.used - 1);
209         if(err)
210                 goto out;
211
212         for(i = 0; i < current_poll.used; i++){
213                 p = &current_poll.poll[i];
214                 if(p->fd != fd)
215                         next_poll.poll[n++] = *p;
216         }
217
218         update_thread();
219  out:
220         sigio_unlock();
221         return err;
222 }
223
224 static struct pollfd *setup_initial_poll(int fd)
225 {
226         struct pollfd *p;
227
228         p = um_kmalloc(sizeof(struct pollfd));
229         if (p == NULL) {
230                 printk("setup_initial_poll : failed to allocate poll\n");
231                 return NULL;
232         }
233         *p = ((struct pollfd) { .fd             = fd,
234                                 .events         = POLLIN,
235                                 .revents        = 0 });
236         return p;
237 }
238
239 static void write_sigio_workaround(void)
240 {
241         unsigned long stack;
242         struct pollfd *p;
243         int err;
244         int l_write_sigio_fds[2];
245         int l_sigio_private[2];
246         int l_write_sigio_pid;
247
248         /* We call this *tons* of times - and most ones we must just fail. */
249         sigio_lock();
250         l_write_sigio_pid = write_sigio_pid;
251         sigio_unlock();
252
253         if (l_write_sigio_pid != -1)
254                 return;
255
256         err = os_pipe(l_write_sigio_fds, 1, 1);
257         if(err < 0){
258                 printk("write_sigio_workaround - os_pipe 1 failed, "
259                        "err = %d\n", -err);
260                 return;
261         }
262         err = os_pipe(l_sigio_private, 1, 1);
263         if(err < 0){
264                 printk("write_sigio_workaround - os_pipe 2 failed, "
265                        "err = %d\n", -err);
266                 goto out_close1;
267         }
268
269         p = setup_initial_poll(l_sigio_private[1]);
270         if(!p)
271                 goto out_close2;
272
273         sigio_lock();
274
275         /* Did we race? Don't try to optimize this, please, it's not so likely
276          * to happen, and no more than once at the boot. */
277         if(write_sigio_pid != -1)
278                 goto out_free;
279
280         current_poll = ((struct pollfds) { .poll        = p,
281                                            .used        = 1,
282                                            .size        = 1 });
283
284         if (write_sigio_irq(l_write_sigio_fds[0]))
285                 goto out_clear_poll;
286
287         memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
288         memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));
289
290         write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
291                                             CLONE_FILES | CLONE_VM, &stack, 0);
292
293         if (write_sigio_pid < 0)
294                 goto out_clear;
295
296         sigio_unlock();
297         return;
298
299 out_clear:
300         write_sigio_pid = -1;
301         write_sigio_fds[0] = -1;
302         write_sigio_fds[1] = -1;
303         sigio_private[0] = -1;
304         sigio_private[1] = -1;
305 out_clear_poll:
306         current_poll = ((struct pollfds) { .poll        = NULL,
307                                            .size        = 0,
308                                            .used        = 0 });
309 out_free:
310         sigio_unlock();
311         kfree(p);
312 out_close2:
313         close(l_sigio_private[0]);
314         close(l_sigio_private[1]);
315 out_close1:
316         close(l_write_sigio_fds[0]);
317         close(l_write_sigio_fds[1]);
318 }
319
320 void maybe_sigio_broken(int fd, int read)
321 {
322         int err;
323
324         if(!isatty(fd))
325                 return;
326
327         if((read || pty_output_sigio) && (!read || pty_close_sigio))
328                 return;
329
330         write_sigio_workaround();
331
332         sigio_lock();
333         err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1);
334         if(err){
335                 printk("maybe_sigio_broken - failed to add pollfd\n");
336                 goto out;
337         }
338         all_sigio_fds.poll[all_sigio_fds.used++] =
339                 ((struct pollfd) { .fd          = fd,
340                                    .events      = read ? POLLIN : POLLOUT,
341                                    .revents     = 0 });
342 out:
343         sigio_unlock();
344 }
345
346 static void sigio_cleanup(void)
347 {
348         if(write_sigio_pid != -1){
349                 os_kill_process(write_sigio_pid, 1);
350                 write_sigio_pid = -1;
351         }
352 }
353
354 __uml_exitcall(sigio_cleanup);