Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[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         struct pollfd *new;
101
102         if(n <= polls->size)
103                 return 0;
104
105         new = um_kmalloc_atomic(n * sizeof(struct pollfd));
106         if(new == NULL){
107                 printk("need_poll : failed to allocate new pollfds\n");
108                 return -ENOMEM;
109         }
110
111         memcpy(new, polls->poll, polls->used * sizeof(struct pollfd));
112         kfree(polls->poll);
113
114         polls->poll = new;
115         polls->size = n;
116         return 0;
117 }
118
119 /* Must be called with sigio_lock held, because it's needed by the marked
120  * critical section.
121  */
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 */
145         if(write_sigio_pid != -1)
146                 os_kill_process(write_sigio_pid, 1);
147         write_sigio_pid = -1;
148         close(sigio_private[0]);
149         close(sigio_private[1]);
150         close(write_sigio_fds[0]);
151         close(write_sigio_fds[1]);
152         /* Critical section end */
153         set_signals(flags);
154 }
155
156 int add_sigio_fd(int fd)
157 {
158         struct pollfd *p;
159         int err = 0, i, n;
160
161         sigio_lock();
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
171         for(i = 0; i < current_poll.used; i++){
172                 if(current_poll.poll[i].fd == fd)
173                         goto out;
174         }
175
176         n = current_poll.used;
177         err = need_poll(&next_poll, n + 1);
178         if(err)
179                 goto out;
180
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;
185         update_thread();
186  out:
187         sigio_unlock();
188         return err;
189 }
190
191 int ignore_sigio_fd(int fd)
192 {
193         struct pollfd *p;
194         int err = 0, i, n = 0;
195
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
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;
209
210         err = need_poll(&next_poll, current_poll.used - 1);
211         if(err)
212                 goto out;
213
214         for(i = 0; i < current_poll.used; i++){
215                 p = &current_poll.poll[i];
216                 if(p->fd != fd)
217                         next_poll.poll[n++] = *p;
218         }
219         next_poll.used = current_poll.used - 1;
220
221         update_thread();
222  out:
223         sigio_unlock();
224         return err;
225 }
226
227 static struct pollfd *setup_initial_poll(int fd)
228 {
229         struct pollfd *p;
230
231         p = um_kmalloc(sizeof(struct pollfd));
232         if (p == NULL) {
233                 printk("setup_initial_poll : failed to allocate poll\n");
234                 return NULL;
235         }
236         *p = ((struct pollfd) { .fd             = fd,
237                                 .events         = POLLIN,
238                                 .revents        = 0 });
239         return p;
240 }
241
242 static void write_sigio_workaround(void)
243 {
244         unsigned long stack;
245         struct pollfd *p;
246         int err;
247         int l_write_sigio_fds[2];
248         int l_sigio_private[2];
249         int l_write_sigio_pid;
250
251         /* We call this *tons* of times - and most ones we must just fail. */
252         sigio_lock();
253         l_write_sigio_pid = write_sigio_pid;
254         sigio_unlock();
255
256         if (l_write_sigio_pid != -1)
257                 return;
258
259         err = os_pipe(l_write_sigio_fds, 1, 1);
260         if(err < 0){
261                 printk("write_sigio_workaround - os_pipe 1 failed, "
262                        "err = %d\n", -err);
263                 return;
264         }
265         err = os_pipe(l_sigio_private, 1, 1);
266         if(err < 0){
267                 printk("write_sigio_workaround - os_pipe 2 failed, "
268                        "err = %d\n", -err);
269                 goto out_close1;
270         }
271
272         p = setup_initial_poll(l_sigio_private[1]);
273         if(!p)
274                 goto out_close2;
275
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)
281                 goto out_free;
282
283         current_poll = ((struct pollfds) { .poll        = p,
284                                            .used        = 1,
285                                            .size        = 1 });
286
287         if (write_sigio_irq(l_write_sigio_fds[0]))
288                 goto out_clear_poll;
289
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
293         write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
294                                             CLONE_FILES | CLONE_VM, &stack, 0);
295
296         if (write_sigio_pid < 0)
297                 goto out_clear;
298
299         sigio_unlock();
300         return;
301
302 out_clear:
303         write_sigio_pid = -1;
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:
313         sigio_unlock();
314         kfree(p);
315 out_close2:
316         close(l_sigio_private[0]);
317         close(l_sigio_private[1]);
318 out_close1:
319         close(l_write_sigio_fds[0]);
320         close(l_write_sigio_fds[1]);
321 }
322
323 void maybe_sigio_broken(int fd, int read)
324 {
325         int err;
326
327         if(!isatty(fd))
328                 return;
329
330         if((read || pty_output_sigio) && (!read || pty_close_sigio))
331                 return;
332
333         write_sigio_workaround();
334
335         sigio_lock();
336         err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1);
337         if(err){
338                 printk("maybe_sigio_broken - failed to add pollfd for "
339                        "descriptor %d\n", fd);
340                 goto out;
341         }
342
343         all_sigio_fds.poll[all_sigio_fds.used++] =
344                 ((struct pollfd) { .fd          = fd,
345                                    .events      = read ? POLLIN : POLLOUT,
346                                    .revents     = 0 });
347 out:
348         sigio_unlock();
349 }
350
351 static void sigio_cleanup(void)
352 {
353         if(write_sigio_pid != -1){
354                 os_kill_process(write_sigio_pid, 1);
355                 write_sigio_pid = -1;
356         }
357 }
358
359 __uml_exitcall(sigio_cleanup);