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);