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