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                 goto out;
 339
 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();
 346 }
 347
 348 static void sigio_cleanup(void)
 349 {
 350         if(write_sigio_pid != -1){
 351                 os_kill_process(write_sigio_pid, 1);
 352                 write_sigio_pid = -1;
 353         }
 354 }
 355
 356 __uml_exitcall(sigio_cleanup);