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