1 /* Generic serial interface functions. 2 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2003, 4 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "serial.h" 23 #include "ser-base.h" 24 #include "event-loop.h" 25 26 #include "gdb_select.h" 27 #include "gdb_string.h" 28 #include <sys/time.h> 29 #ifdef USE_WIN32API 30 #include <winsock2.h> 31 #endif 32 33 34 static timer_handler_func push_event; 35 static handler_func fd_event; 36 37 /* Event handling for ASYNC serial code. 38 39 At any time the SERIAL device either: has an empty FIFO and is 40 waiting on a FD event; or has a non-empty FIFO/error condition and 41 is constantly scheduling timer events. 42 43 ASYNC only stops pestering its client when it is de-async'ed or it 44 is told to go away. */ 45 46 /* Value of scb->async_state: */ 47 enum { 48 /* >= 0 (TIMER_SCHEDULED) */ 49 /* The ID of the currently scheduled timer event. This state is 50 rarely encountered. Timer events are one-off so as soon as the 51 event is delivered the state is shanged to NOTHING_SCHEDULED. */ 52 FD_SCHEDULED = -1, 53 /* The fd_event() handler is scheduled. It is called when ever the 54 file descriptor becomes ready. */ 55 NOTHING_SCHEDULED = -2 56 /* Either no task is scheduled (just going into ASYNC mode) or a 57 timer event has just gone off and the current state has been 58 forced into nothing scheduled. */ 59 }; 60 61 /* Identify and schedule the next ASYNC task based on scb->async_state 62 and scb->buf* (the input FIFO). A state machine is used to avoid 63 the need to make redundant calls into the event-loop - the next 64 scheduled task is only changed when needed. */ 65 66 static void 67 reschedule (struct serial *scb) 68 { 69 if (serial_is_async_p (scb)) 70 { 71 int next_state; 72 73 switch (scb->async_state) 74 { 75 case FD_SCHEDULED: 76 if (scb->bufcnt == 0) 77 next_state = FD_SCHEDULED; 78 else 79 { 80 delete_file_handler (scb->fd); 81 next_state = create_timer (0, push_event, scb); 82 } 83 break; 84 case NOTHING_SCHEDULED: 85 if (scb->bufcnt == 0) 86 { 87 add_file_handler (scb->fd, fd_event, scb); 88 next_state = FD_SCHEDULED; 89 } 90 else 91 { 92 next_state = create_timer (0, push_event, scb); 93 } 94 break; 95 default: /* TIMER SCHEDULED */ 96 if (scb->bufcnt == 0) 97 { 98 delete_timer (scb->async_state); 99 add_file_handler (scb->fd, fd_event, scb); 100 next_state = FD_SCHEDULED; 101 } 102 else 103 next_state = scb->async_state; 104 break; 105 } 106 if (serial_debug_p (scb)) 107 { 108 switch (next_state) 109 { 110 case FD_SCHEDULED: 111 if (scb->async_state != FD_SCHEDULED) 112 fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n", 113 scb->fd); 114 break; 115 default: /* TIMER SCHEDULED */ 116 if (scb->async_state == FD_SCHEDULED) 117 fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n", 118 scb->fd); 119 break; 120 } 121 } 122 scb->async_state = next_state; 123 } 124 } 125 126 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there 127 is no pending error). As soon as data arrives, it is read into the 128 input FIFO and the client notified. The client should then drain 129 the FIFO using readchar(). If the FIFO isn't immediatly emptied, 130 push_event() is used to nag the client until it is. */ 131 132 static void 133 fd_event (int error, void *context) 134 { 135 struct serial *scb = context; 136 if (error != 0) 137 { 138 scb->bufcnt = SERIAL_ERROR; 139 } 140 else if (scb->bufcnt == 0) 141 { 142 /* Prime the input FIFO. The readchar() function is used to 143 pull characters out of the buffer. See also 144 generic_readchar(). */ 145 int nr; 146 nr = scb->ops->read_prim (scb, BUFSIZ); 147 if (nr == 0) 148 { 149 scb->bufcnt = SERIAL_EOF; 150 } 151 else if (nr > 0) 152 { 153 scb->bufcnt = nr; 154 scb->bufp = scb->buf; 155 } 156 else 157 { 158 scb->bufcnt = SERIAL_ERROR; 159 } 160 } 161 scb->async_handler (scb, scb->async_context); 162 reschedule (scb); 163 } 164 165 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending 166 error). Nag the client until all the data has been read. In the 167 case of errors, the client will need to close or de-async the 168 device before naging stops. */ 169 170 static void 171 push_event (void *context) 172 { 173 struct serial *scb = context; 174 175 scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */ 176 scb->async_handler (scb, scb->async_context); 177 /* re-schedule */ 178 reschedule (scb); 179 } 180 181 /* Wait for input on scb, with timeout seconds. Returns 0 on success, 182 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */ 183 184 static int 185 ser_base_wait_for (struct serial *scb, int timeout) 186 { 187 while (1) 188 { 189 int numfds; 190 struct timeval tv; 191 fd_set readfds, exceptfds; 192 193 /* NOTE: Some OS's can scramble the READFDS when the select() 194 call fails (ex the kernel with Red Hat 5.2). Initialize all 195 arguments before each call. */ 196 197 tv.tv_sec = timeout; 198 tv.tv_usec = 0; 199 200 FD_ZERO (&readfds); 201 FD_ZERO (&exceptfds); 202 FD_SET (scb->fd, &readfds); 203 FD_SET (scb->fd, &exceptfds); 204 205 if (timeout >= 0) 206 numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, &tv); 207 else 208 numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, 0); 209 210 if (numfds <= 0) 211 { 212 if (numfds == 0) 213 return SERIAL_TIMEOUT; 214 else if (errno == EINTR) 215 continue; 216 else 217 return SERIAL_ERROR; /* Got an error from select or poll */ 218 } 219 220 return 0; 221 } 222 } 223 224 /* Read a character with user-specified timeout. TIMEOUT is number of seconds 225 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns 226 char if successful. Returns -2 if timeout expired, EOF if line dropped 227 dead, or -3 for any other error (see errno in that case). */ 228 229 static int 230 do_ser_base_readchar (struct serial *scb, int timeout) 231 { 232 int status; 233 int delta; 234 235 /* We have to be able to keep the GUI alive here, so we break the 236 original timeout into steps of 1 second, running the "keep the 237 GUI alive" hook each time through the loop. 238 239 Also, timeout = 0 means to poll, so we just set the delta to 0, 240 so we will only go through the loop once. */ 241 242 delta = (timeout == 0 ? 0 : 1); 243 while (1) 244 { 245 /* N.B. The UI may destroy our world (for instance by calling 246 remote_stop,) in which case we want to get out of here as 247 quickly as possible. It is not safe to touch scb, since 248 someone else might have freed it. The 249 deprecated_ui_loop_hook signals that we should exit by 250 returning 1. */ 251 252 if (deprecated_ui_loop_hook) 253 { 254 if (deprecated_ui_loop_hook (0)) 255 return SERIAL_TIMEOUT; 256 } 257 258 status = ser_base_wait_for (scb, delta); 259 if (timeout > 0) 260 timeout -= delta; 261 262 /* If we got a character or an error back from wait_for, then we can 263 break from the loop before the timeout is completed. */ 264 if (status != SERIAL_TIMEOUT) 265 break; 266 267 /* If we have exhausted the original timeout, then generate 268 a SERIAL_TIMEOUT, and pass it out of the loop. */ 269 else if (timeout == 0) 270 { 271 status = SERIAL_TIMEOUT; 272 break; 273 } 274 } 275 276 if (status < 0) 277 return status; 278 279 status = scb->ops->read_prim (scb, BUFSIZ); 280 281 if (status <= 0) 282 { 283 if (status == 0) 284 return SERIAL_EOF; 285 else 286 /* Got an error from read. */ 287 return SERIAL_ERROR; 288 } 289 290 scb->bufcnt = status; 291 scb->bufcnt--; 292 scb->bufp = scb->buf; 293 return *scb->bufp++; 294 } 295 296 /* Perform operations common to both old and new readchar. */ 297 298 /* Return the next character from the input FIFO. If the FIFO is 299 empty, call the SERIAL specific routine to try and read in more 300 characters. 301 302 Initially data from the input FIFO is returned (fd_event() 303 pre-reads the input into that FIFO. Once that has been emptied, 304 further data is obtained by polling the input FD using the device 305 specific readchar() function. Note: reschedule() is called after 306 every read. This is because there is no guarentee that the lower 307 level fd_event() poll_event() code (which also calls reschedule()) 308 will be called. */ 309 310 int 311 generic_readchar (struct serial *scb, int timeout, 312 int (do_readchar) (struct serial *scb, int timeout)) 313 { 314 int ch; 315 if (scb->bufcnt > 0) 316 { 317 ch = *scb->bufp; 318 scb->bufcnt--; 319 scb->bufp++; 320 } 321 else if (scb->bufcnt < 0) 322 { 323 /* Some errors/eof are are sticky. */ 324 ch = scb->bufcnt; 325 } 326 else 327 { 328 ch = do_readchar (scb, timeout); 329 if (ch < 0) 330 { 331 switch ((enum serial_rc) ch) 332 { 333 case SERIAL_EOF: 334 case SERIAL_ERROR: 335 /* Make the error/eof stick. */ 336 scb->bufcnt = ch; 337 break; 338 case SERIAL_TIMEOUT: 339 scb->bufcnt = 0; 340 break; 341 } 342 } 343 } 344 /* Read any error output we might have. */ 345 if (scb->error_fd != -1) 346 { 347 ssize_t s; 348 char buf[81]; 349 350 for (;;) 351 { 352 char *current; 353 char *newline; 354 int to_read = 80; 355 356 int num_bytes = -1; 357 if (scb->ops->avail) 358 num_bytes = (scb->ops->avail)(scb, scb->error_fd); 359 if (num_bytes != -1) 360 to_read = (num_bytes < to_read) ? num_bytes : to_read; 361 362 if (to_read == 0) 363 break; 364 365 s = read (scb->error_fd, &buf, to_read); 366 if (s == -1) 367 break; 368 if (s == 0) 369 { 370 /* EOF */ 371 close (scb->error_fd); 372 scb->error_fd = -1; 373 break; 374 } 375 376 /* In theory, embedded newlines are not a problem. 377 But for MI, we want each output line to have just 378 one newline for legibility. So output things 379 in newline chunks. */ 380 buf[s] = '\0'; 381 current = buf; 382 while ((newline = strstr (current, "\n")) != NULL) 383 { 384 *newline = '\0'; 385 fputs_unfiltered (current, gdb_stderr); 386 fputs_unfiltered ("\n", gdb_stderr); 387 current = newline + 1; 388 } 389 fputs_unfiltered (current, gdb_stderr); 390 } 391 } 392 393 reschedule (scb); 394 return ch; 395 } 396 397 int 398 ser_base_readchar (struct serial *scb, int timeout) 399 { 400 return generic_readchar (scb, timeout, do_ser_base_readchar); 401 } 402 403 int 404 ser_base_write (struct serial *scb, const char *str, int len) 405 { 406 int cc; 407 408 while (len > 0) 409 { 410 cc = scb->ops->write_prim (scb, str, len); 411 412 if (cc < 0) 413 return 1; 414 len -= cc; 415 str += cc; 416 } 417 return 0; 418 } 419 420 int 421 ser_base_flush_output (struct serial *scb) 422 { 423 return 0; 424 } 425 426 int 427 ser_base_flush_input (struct serial *scb) 428 { 429 if (scb->bufcnt >= 0) 430 { 431 scb->bufcnt = 0; 432 scb->bufp = scb->buf; 433 return 0; 434 } 435 else 436 return SERIAL_ERROR; 437 } 438 439 int 440 ser_base_send_break (struct serial *scb) 441 { 442 return 0; 443 } 444 445 int 446 ser_base_drain_output (struct serial *scb) 447 { 448 return 0; 449 } 450 451 void 452 ser_base_raw (struct serial *scb) 453 { 454 return; /* Always in raw mode */ 455 } 456 457 serial_ttystate 458 ser_base_get_tty_state (struct serial *scb) 459 { 460 /* allocate a dummy */ 461 return (serial_ttystate) XMALLOC (int); 462 } 463 464 int 465 ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate) 466 { 467 return 0; 468 } 469 470 int 471 ser_base_noflush_set_tty_state (struct serial *scb, 472 serial_ttystate new_ttystate, 473 serial_ttystate old_ttystate) 474 { 475 return 0; 476 } 477 478 void 479 ser_base_print_tty_state (struct serial *scb, 480 serial_ttystate ttystate, 481 struct ui_file *stream) 482 { 483 /* Nothing to print. */ 484 return; 485 } 486 487 int 488 ser_base_setbaudrate (struct serial *scb, int rate) 489 { 490 return 0; /* Never fails! */ 491 } 492 493 int 494 ser_base_setstopbits (struct serial *scb, int num) 495 { 496 return 0; /* Never fails! */ 497 } 498 499 /* Put the SERIAL device into/out-of ASYNC mode. */ 500 501 void 502 ser_base_async (struct serial *scb, 503 int async_p) 504 { 505 if (async_p) 506 { 507 /* Force a re-schedule. */ 508 scb->async_state = NOTHING_SCHEDULED; 509 if (serial_debug_p (scb)) 510 fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n", 511 scb->fd); 512 reschedule (scb); 513 } 514 else 515 { 516 if (serial_debug_p (scb)) 517 fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n", 518 scb->fd); 519 /* De-schedule whatever tasks are currently scheduled. */ 520 switch (scb->async_state) 521 { 522 case FD_SCHEDULED: 523 delete_file_handler (scb->fd); 524 break; 525 case NOTHING_SCHEDULED: 526 break; 527 default: /* TIMER SCHEDULED */ 528 delete_timer (scb->async_state); 529 break; 530 } 531 } 532 } 533