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 23 /* Protected by sigio_lock(), also used by sigio_cleanup, which is an 24 * exitcall. 25 */ 26 static int write_sigio_pid = -1; 27 28 /* These arrays are initialized before the sigio thread is started, and 29 * the descriptors closed after it is killed. So, it can't see them change. 30 * On the UML side, they are changed under the sigio_lock. 31 */ 32 static int write_sigio_fds[2] = { -1, -1 }; 33 static int sigio_private[2] = { -1, -1 }; 34 35 struct pollfds { 36 struct pollfd *poll; 37 int size; 38 int used; 39 }; 40 41 /* Protected by sigio_lock(). Used by the sigio thread, but the UML thread 42 * synchronizes with it. 43 */ 44 struct pollfds current_poll = { 45 .poll = NULL, 46 .size = 0, 47 .used = 0 48 }; 49 50 struct pollfds next_poll = { 51 .poll = NULL, 52 .size = 0, 53 .used = 0 54 }; 55 56 static int write_sigio_thread(void *unused) 57 { 58 struct pollfds *fds, tmp; 59 struct pollfd *p; 60 int i, n, respond_fd; 61 char c; 62 63 signal(SIGWINCH, SIG_IGN); 64 fds = ¤t_poll; 65 while(1){ 66 n = poll(fds->poll, fds->used, -1); 67 if(n < 0){ 68 if(errno == EINTR) continue; 69 printk("write_sigio_thread : poll returned %d, " 70 "errno = %d\n", n, errno); 71 } 72 for(i = 0; i < fds->used; i++){ 73 p = &fds->poll[i]; 74 if(p->revents == 0) continue; 75 if(p->fd == sigio_private[1]){ 76 n = os_read_file(sigio_private[1], &c, sizeof(c)); 77 if(n != sizeof(c)) 78 printk("write_sigio_thread : " 79 "read failed, err = %d\n", -n); 80 tmp = current_poll; 81 current_poll = next_poll; 82 next_poll = tmp; 83 respond_fd = sigio_private[1]; 84 } 85 else { 86 respond_fd = write_sigio_fds[1]; 87 fds->used--; 88 memmove(&fds->poll[i], &fds->poll[i + 1], 89 (fds->used - i) * sizeof(*fds->poll)); 90 } 91 92 n = os_write_file(respond_fd, &c, sizeof(c)); 93 if(n != sizeof(c)) 94 printk("write_sigio_thread : write failed, " 95 "err = %d\n", -n); 96 } 97 } 98 99 return 0; 100 } 101 102 static int need_poll(int n) 103 { 104 if(n <= next_poll.size){ 105 next_poll.used = n; 106 return(0); 107 } 108 kfree(next_poll.poll); 109 next_poll.poll = um_kmalloc_atomic(n * sizeof(struct pollfd)); 110 if(next_poll.poll == NULL){ 111 printk("need_poll : failed to allocate new pollfds\n"); 112 next_poll.size = 0; 113 next_poll.used = 0; 114 return(-1); 115 } 116 next_poll.size = n; 117 next_poll.used = n; 118 return(0); 119 } 120 121 /* Must be called with sigio_lock held, because it's needed by the marked 122 * critical section. */ 123 static void update_thread(void) 124 { 125 unsigned long flags; 126 int n; 127 char c; 128 129 flags = set_signals(0); 130 n = os_write_file(sigio_private[0], &c, sizeof(c)); 131 if(n != sizeof(c)){ 132 printk("update_thread : write failed, err = %d\n", -n); 133 goto fail; 134 } 135 136 n = os_read_file(sigio_private[0], &c, sizeof(c)); 137 if(n != sizeof(c)){ 138 printk("update_thread : read failed, err = %d\n", -n); 139 goto fail; 140 } 141 142 set_signals(flags); 143 return; 144 fail: 145 /* Critical section start */ 146 if(write_sigio_pid != -1) 147 os_kill_process(write_sigio_pid, 1); 148 write_sigio_pid = -1; 149 close(sigio_private[0]); 150 close(sigio_private[1]); 151 close(write_sigio_fds[0]); 152 close(write_sigio_fds[1]); 153 /* Critical section end */ 154 set_signals(flags); 155 } 156 157 int add_sigio_fd(int fd, int read) 158 { 159 int err = 0, i, n, events; 160 161 sigio_lock(); 162 for(i = 0; i < current_poll.used; i++){ 163 if(current_poll.poll[i].fd == fd) 164 goto out; 165 } 166 167 n = current_poll.used + 1; 168 err = need_poll(n); 169 if(err) 170 goto out; 171 172 for(i = 0; i < current_poll.used; i++) 173 next_poll.poll[i] = current_poll.poll[i]; 174 175 if(read) events = POLLIN; 176 else events = POLLOUT; 177 178 next_poll.poll[n - 1] = ((struct pollfd) { .fd = fd, 179 .events = events, 180 .revents = 0 }); 181 update_thread(); 182 out: 183 sigio_unlock(); 184 return(err); 185 } 186 187 int ignore_sigio_fd(int fd) 188 { 189 struct pollfd *p; 190 int err = 0, i, n = 0; 191 192 sigio_lock(); 193 for(i = 0; i < current_poll.used; i++){ 194 if(current_poll.poll[i].fd == fd) break; 195 } 196 if(i == current_poll.used) 197 goto out; 198 199 err = need_poll(current_poll.used - 1); 200 if(err) 201 goto out; 202 203 for(i = 0; i < current_poll.used; i++){ 204 p = ¤t_poll.poll[i]; 205 if(p->fd != fd) next_poll.poll[n++] = current_poll.poll[i]; 206 } 207 if(n == i){ 208 printk("ignore_sigio_fd : fd %d not found\n", fd); 209 err = -1; 210 goto out; 211 } 212 213 update_thread(); 214 out: 215 sigio_unlock(); 216 return(err); 217 } 218 219 static struct pollfd *setup_initial_poll(int fd) 220 { 221 struct pollfd *p; 222 223 p = um_kmalloc(sizeof(struct pollfd)); 224 if (p == NULL) { 225 printk("setup_initial_poll : failed to allocate poll\n"); 226 return NULL; 227 } 228 *p = ((struct pollfd) { .fd = fd, 229 .events = POLLIN, 230 .revents = 0 }); 231 return p; 232 } 233 234 void write_sigio_workaround(void) 235 { 236 unsigned long stack; 237 struct pollfd *p; 238 int err; 239 int l_write_sigio_fds[2]; 240 int l_sigio_private[2]; 241 int l_write_sigio_pid; 242 243 /* We call this *tons* of times - and most ones we must just fail. */ 244 sigio_lock(); 245 l_write_sigio_pid = write_sigio_pid; 246 sigio_unlock(); 247 248 if (l_write_sigio_pid != -1) 249 return; 250 251 err = os_pipe(l_write_sigio_fds, 1, 1); 252 if(err < 0){ 253 printk("write_sigio_workaround - os_pipe 1 failed, " 254 "err = %d\n", -err); 255 return; 256 } 257 err = os_pipe(l_sigio_private, 1, 1); 258 if(err < 0){ 259 printk("write_sigio_workaround - os_pipe 2 failed, " 260 "err = %d\n", -err); 261 goto out_close1; 262 } 263 264 p = setup_initial_poll(l_sigio_private[1]); 265 if(!p) 266 goto out_close2; 267 268 sigio_lock(); 269 270 /* Did we race? Don't try to optimize this, please, it's not so likely 271 * to happen, and no more than once at the boot. */ 272 if(write_sigio_pid != -1) 273 goto out_unlock; 274 275 write_sigio_pid = run_helper_thread(write_sigio_thread, NULL, 276 CLONE_FILES | CLONE_VM, &stack, 0); 277 278 if (write_sigio_pid < 0) 279 goto out_clear; 280 281 if (write_sigio_irq(l_write_sigio_fds[0])) 282 goto out_kill; 283 284 /* Success, finally. */ 285 memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds)); 286 memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private)); 287 288 current_poll = ((struct pollfds) { .poll = p, 289 .used = 1, 290 .size = 1 }); 291 292 sigio_unlock(); 293 return; 294 295 out_kill: 296 l_write_sigio_pid = write_sigio_pid; 297 write_sigio_pid = -1; 298 sigio_unlock(); 299 /* Going to call waitpid, avoid holding the lock. */ 300 os_kill_process(l_write_sigio_pid, 1); 301 goto out_free; 302 303 out_clear: 304 write_sigio_pid = -1; 305 out_unlock: 306 sigio_unlock(); 307 out_free: 308 kfree(p); 309 out_close2: 310 close(l_sigio_private[0]); 311 close(l_sigio_private[1]); 312 out_close1: 313 close(l_write_sigio_fds[0]); 314 close(l_write_sigio_fds[1]); 315 return; 316 } 317 318 void sigio_cleanup(void) 319 { 320 if(write_sigio_pid != -1){ 321 os_kill_process(write_sigio_pid, 1); 322 write_sigio_pid = -1; 323 } 324 } 325