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 = ¤t_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 = ¤t_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); 360