1 /* 2 * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) 3 * Licensed under the GPL 4 */ 5 6 #include <unistd.h> 7 #include <errno.h> 8 #include <fcntl.h> 9 #include <poll.h> 10 #include <pty.h> 11 #include <sched.h> 12 #include <signal.h> 13 #include <string.h> 14 #include "kern_constants.h" 15 #include "kern_util.h" 16 #include "init.h" 17 #include "os.h" 18 #include "sigio.h" 19 #include "um_malloc.h" 20 #include "user.h" 21 22 /* 23 * Protected by sigio_lock(), also used by sigio_cleanup, which is an 24 * exitcall. 25 */ 26 static int write_sigio_pid = -1; 27 static unsigned long write_sigio_stack; 28 29 /* 30 * These arrays are initialized before the sigio thread is started, and 31 * the descriptors closed after it is killed. So, it can't see them change. 32 * On the UML side, they are changed under the sigio_lock. 33 */ 34 #define SIGIO_FDS_INIT {-1, -1} 35 36 static int write_sigio_fds[2] = SIGIO_FDS_INIT; 37 static int sigio_private[2] = SIGIO_FDS_INIT; 38 39 struct pollfds { 40 struct pollfd *poll; 41 int size; 42 int used; 43 }; 44 45 /* 46 * Protected by sigio_lock(). Used by the sigio thread, but the UML thread 47 * synchronizes with it. 48 */ 49 static struct pollfds current_poll; 50 static struct pollfds next_poll; 51 static struct pollfds all_sigio_fds; 52 53 static int write_sigio_thread(void *unused) 54 { 55 struct pollfds *fds, tmp; 56 struct pollfd *p; 57 int i, n, respond_fd; 58 char c; 59 60 signal(SIGWINCH, SIG_IGN); 61 fds = ¤t_poll; 62 while (1) { 63 n = poll(fds->poll, fds->used, -1); 64 if (n < 0) { 65 if (errno == EINTR) 66 continue; 67 printk(UM_KERN_ERR "write_sigio_thread : poll returned " 68 "%d, errno = %d\n", n, errno); 69 } 70 for (i = 0; i < fds->used; i++) { 71 p = &fds->poll[i]; 72 if (p->revents == 0) 73 continue; 74 if (p->fd == sigio_private[1]) { 75 CATCH_EINTR(n = read(sigio_private[1], &c, 76 sizeof(c))); 77 if (n != sizeof(c)) 78 printk(UM_KERN_ERR 79 "write_sigio_thread : " 80 "read on socket failed, " 81 "err = %d\n", errno); 82 tmp = current_poll; 83 current_poll = next_poll; 84 next_poll = tmp; 85 respond_fd = sigio_private[1]; 86 } 87 else { 88 respond_fd = write_sigio_fds[1]; 89 fds->used--; 90 memmove(&fds->poll[i], &fds->poll[i + 1], 91 (fds->used - i) * sizeof(*fds->poll)); 92 } 93 94 CATCH_EINTR(n = write(respond_fd, &c, sizeof(c))); 95 if (n != sizeof(c)) 96 printk(UM_KERN_ERR "write_sigio_thread : " 97 "write on socket failed, err = %d\n", 98 errno); 99 } 100 } 101 102 return 0; 103 } 104 105 static int need_poll(struct pollfds *polls, int n) 106 { 107 struct pollfd *new; 108 109 if (n <= polls->size) 110 return 0; 111 112 new = kmalloc(n * sizeof(struct pollfd), UM_GFP_ATOMIC); 113 if (new == NULL) { 114 printk(UM_KERN_ERR "need_poll : failed to allocate new " 115 "pollfds\n"); 116 return -ENOMEM; 117 } 118 119 memcpy(new, polls->poll, polls->used * sizeof(struct pollfd)); 120 kfree(polls->poll); 121 122 polls->poll = new; 123 polls->size = n; 124 return 0; 125 } 126 127 /* 128 * Must be called with sigio_lock held, because it's needed by the marked 129 * critical section. 130 */ 131 static void update_thread(void) 132 { 133 unsigned long flags; 134 int n; 135 char c; 136 137 flags = set_signals(0); 138 CATCH_EINTR(n = write(sigio_private[0], &c, sizeof(c))); 139 if (n != sizeof(c)) { 140 printk(UM_KERN_ERR "update_thread : write failed, err = %d\n", 141 errno); 142 goto fail; 143 } 144 145 CATCH_EINTR(n = read(sigio_private[0], &c, sizeof(c))); 146 if (n != sizeof(c)) { 147 printk(UM_KERN_ERR "update_thread : read failed, err = %d\n", 148 errno); 149 goto fail; 150 } 151 152 set_signals(flags); 153 return; 154 fail: 155 /* Critical section start */ 156 if (write_sigio_pid != -1) { 157 os_kill_process(write_sigio_pid, 1); 158 free_stack(write_sigio_stack, 0); 159 } 160 write_sigio_pid = -1; 161 close(sigio_private[0]); 162 close(sigio_private[1]); 163 close(write_sigio_fds[0]); 164 close(write_sigio_fds[1]); 165 /* Critical section end */ 166 set_signals(flags); 167 } 168 169 int add_sigio_fd(int fd) 170 { 171 struct pollfd *p; 172 int err = 0, i, n; 173 174 sigio_lock(); 175 for (i = 0; i < all_sigio_fds.used; i++) { 176 if (all_sigio_fds.poll[i].fd == fd) 177 break; 178 } 179 if (i == all_sigio_fds.used) 180 goto out; 181 182 p = &all_sigio_fds.poll[i]; 183 184 for (i = 0; i < current_poll.used; i++) { 185 if (current_poll.poll[i].fd == fd) 186 goto out; 187 } 188 189 n = current_poll.used; 190 err = need_poll(&next_poll, n + 1); 191 if (err) 192 goto out; 193 194 memcpy(next_poll.poll, current_poll.poll, 195 current_poll.used * sizeof(struct pollfd)); 196 next_poll.poll[n] = *p; 197 next_poll.used = n + 1; 198 update_thread(); 199 out: 200 sigio_unlock(); 201 return err; 202 } 203 204 int ignore_sigio_fd(int fd) 205 { 206 struct pollfd *p; 207 int err = 0, i, n = 0; 208 209 /* 210 * This is called from exitcalls elsewhere in UML - if 211 * sigio_cleanup has already run, then update_thread will hang 212 * or fail because the thread is no longer running. 213 */ 214 if (write_sigio_pid == -1) 215 return -EIO; 216 217 sigio_lock(); 218 for (i = 0; i < current_poll.used; i++) { 219 if (current_poll.poll[i].fd == fd) 220 break; 221 } 222 if (i == current_poll.used) 223 goto out; 224 225 err = need_poll(&next_poll, current_poll.used - 1); 226 if (err) 227 goto out; 228 229 for (i = 0; i < current_poll.used; i++) { 230 p = ¤t_poll.poll[i]; 231 if (p->fd != fd) 232 next_poll.poll[n++] = *p; 233 } 234 next_poll.used = current_poll.used - 1; 235 236 update_thread(); 237 out: 238 sigio_unlock(); 239 return err; 240 } 241 242 static struct pollfd *setup_initial_poll(int fd) 243 { 244 struct pollfd *p; 245 246 p = kmalloc(sizeof(struct pollfd), UM_GFP_KERNEL); 247 if (p == NULL) { 248 printk(UM_KERN_ERR "setup_initial_poll : failed to allocate " 249 "poll\n"); 250 return NULL; 251 } 252 *p = ((struct pollfd) { .fd = fd, 253 .events = POLLIN, 254 .revents = 0 }); 255 return p; 256 } 257 258 static void write_sigio_workaround(void) 259 { 260 struct pollfd *p; 261 int err; 262 int l_write_sigio_fds[2]; 263 int l_sigio_private[2]; 264 int l_write_sigio_pid; 265 266 /* We call this *tons* of times - and most ones we must just fail. */ 267 sigio_lock(); 268 l_write_sigio_pid = write_sigio_pid; 269 sigio_unlock(); 270 271 if (l_write_sigio_pid != -1) 272 return; 273 274 err = os_pipe(l_write_sigio_fds, 1, 1); 275 if (err < 0) { 276 printk(UM_KERN_ERR "write_sigio_workaround - os_pipe 1 failed, " 277 "err = %d\n", -err); 278 return; 279 } 280 err = os_pipe(l_sigio_private, 1, 1); 281 if (err < 0) { 282 printk(UM_KERN_ERR "write_sigio_workaround - os_pipe 2 failed, " 283 "err = %d\n", -err); 284 goto out_close1; 285 } 286 287 p = setup_initial_poll(l_sigio_private[1]); 288 if (!p) 289 goto out_close2; 290 291 sigio_lock(); 292 293 /* 294 * Did we race? Don't try to optimize this, please, it's not so likely 295 * to happen, and no more than once at the boot. 296 */ 297 if (write_sigio_pid != -1) 298 goto out_free; 299 300 current_poll = ((struct pollfds) { .poll = p, 301 .used = 1, 302 .size = 1 }); 303 304 if (write_sigio_irq(l_write_sigio_fds[0])) 305 goto out_clear_poll; 306 307 memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds)); 308 memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private)); 309 310 write_sigio_pid = run_helper_thread(write_sigio_thread, NULL, 311 CLONE_FILES | CLONE_VM, 312 &write_sigio_stack); 313 314 if (write_sigio_pid < 0) 315 goto out_clear; 316 317 sigio_unlock(); 318 return; 319 320 out_clear: 321 write_sigio_pid = -1; 322 write_sigio_fds[0] = -1; 323 write_sigio_fds[1] = -1; 324 sigio_private[0] = -1; 325 sigio_private[1] = -1; 326 out_clear_poll: 327 current_poll = ((struct pollfds) { .poll = NULL, 328 .size = 0, 329 .used = 0 }); 330 out_free: 331 sigio_unlock(); 332 kfree(p); 333 out_close2: 334 close(l_sigio_private[0]); 335 close(l_sigio_private[1]); 336 out_close1: 337 close(l_write_sigio_fds[0]); 338 close(l_write_sigio_fds[1]); 339 } 340 341 /* Changed during early boot */ 342 static int pty_output_sigio = 0; 343 static int pty_close_sigio = 0; 344 345 void maybe_sigio_broken(int fd, int read) 346 { 347 int err; 348 349 if (!isatty(fd)) 350 return; 351 352 if ((read || pty_output_sigio) && (!read || pty_close_sigio)) 353 return; 354 355 write_sigio_workaround(); 356 357 sigio_lock(); 358 err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1); 359 if (err) { 360 printk(UM_KERN_ERR "maybe_sigio_broken - failed to add pollfd " 361 "for descriptor %d\n", fd); 362 goto out; 363 } 364 365 all_sigio_fds.poll[all_sigio_fds.used++] = 366 ((struct pollfd) { .fd = fd, 367 .events = read ? POLLIN : POLLOUT, 368 .revents = 0 }); 369 out: 370 sigio_unlock(); 371 } 372 373 static void sigio_cleanup(void) 374 { 375 if (write_sigio_pid == -1) 376 return; 377 378 os_kill_process(write_sigio_pid, 1); 379 free_stack(write_sigio_stack, 0); 380 write_sigio_pid = -1; 381 } 382 383 __uml_exitcall(sigio_cleanup); 384 385 /* Used as a flag during SIGIO testing early in boot */ 386 static volatile int got_sigio = 0; 387 388 static void __init handler(int sig) 389 { 390 got_sigio = 1; 391 } 392 393 struct openpty_arg { 394 int master; 395 int slave; 396 int err; 397 }; 398 399 static void openpty_cb(void *arg) 400 { 401 struct openpty_arg *info = arg; 402 403 info->err = 0; 404 if (openpty(&info->master, &info->slave, NULL, NULL, NULL)) 405 info->err = -errno; 406 } 407 408 static int async_pty(int master, int slave) 409 { 410 int flags; 411 412 flags = fcntl(master, F_GETFL); 413 if (flags < 0) 414 return -errno; 415 416 if ((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) || 417 (fcntl(master, F_SETOWN, os_getpid()) < 0)) 418 return -errno; 419 420 if ((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0)) 421 return -errno; 422 423 return 0; 424 } 425 426 static void __init check_one_sigio(void (*proc)(int, int)) 427 { 428 struct sigaction old, new; 429 struct openpty_arg pty = { .master = -1, .slave = -1 }; 430 int master, slave, err; 431 432 initial_thread_cb(openpty_cb, &pty); 433 if (pty.err) { 434 printk(UM_KERN_ERR "check_one_sigio failed, errno = %d\n", 435 -pty.err); 436 return; 437 } 438 439 master = pty.master; 440 slave = pty.slave; 441 442 if ((master == -1) || (slave == -1)) { 443 printk(UM_KERN_ERR "check_one_sigio failed to allocate a " 444 "pty\n"); 445 return; 446 } 447 448 /* Not now, but complain so we now where we failed. */ 449 err = raw(master); 450 if (err < 0) { 451 printk(UM_KERN_ERR "check_one_sigio : raw failed, errno = %d\n", 452 -err); 453 return; 454 } 455 456 err = async_pty(master, slave); 457 if (err < 0) { 458 printk(UM_KERN_ERR "check_one_sigio : sigio_async failed, " 459 "err = %d\n", -err); 460 return; 461 } 462 463 if (sigaction(SIGIO, NULL, &old) < 0) { 464 printk(UM_KERN_ERR "check_one_sigio : sigaction 1 failed, " 465 "errno = %d\n", errno); 466 return; 467 } 468 469 new = old; 470 new.sa_handler = handler; 471 if (sigaction(SIGIO, &new, NULL) < 0) { 472 printk(UM_KERN_ERR "check_one_sigio : sigaction 2 failed, " 473 "errno = %d\n", errno); 474 return; 475 } 476 477 got_sigio = 0; 478 (*proc)(master, slave); 479 480 close(master); 481 close(slave); 482 483 if (sigaction(SIGIO, &old, NULL) < 0) 484 printk(UM_KERN_ERR "check_one_sigio : sigaction 3 failed, " 485 "errno = %d\n", errno); 486 } 487 488 static void tty_output(int master, int slave) 489 { 490 int n; 491 char buf[512]; 492 493 printk(UM_KERN_INFO "Checking that host ptys support output SIGIO..."); 494 495 memset(buf, 0, sizeof(buf)); 496 497 while (write(master, buf, sizeof(buf)) > 0) ; 498 if (errno != EAGAIN) 499 printk(UM_KERN_ERR "tty_output : write failed, errno = %d\n", 500 errno); 501 while (((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio) 502 ; 503 504 if (got_sigio) { 505 printk(UM_KERN_CONT "Yes\n"); 506 pty_output_sigio = 1; 507 } else if (n == -EAGAIN) 508 printk(UM_KERN_CONT "No, enabling workaround\n"); 509 else 510 printk(UM_KERN_CONT "tty_output : read failed, err = %d\n", n); 511 } 512 513 static void tty_close(int master, int slave) 514 { 515 printk(UM_KERN_INFO "Checking that host ptys support SIGIO on " 516 "close..."); 517 518 close(slave); 519 if (got_sigio) { 520 printk(UM_KERN_CONT "Yes\n"); 521 pty_close_sigio = 1; 522 } else 523 printk(UM_KERN_CONT "No, enabling workaround\n"); 524 } 525 526 void __init check_sigio(void) 527 { 528 if ((access("/dev/ptmx", R_OK) < 0) && 529 (access("/dev/ptyp0", R_OK) < 0)) { 530 printk(UM_KERN_WARNING "No pseudo-terminals available - " 531 "skipping pty SIGIO check\n"); 532 return; 533 } 534 check_one_sigio(tty_output); 535 check_one_sigio(tty_close); 536 } 537 538 /* Here because it only does the SIGIO testing for now */ 539 void __init os_check_bugs(void) 540 { 541 check_sigio(); 542 } 543