1 /* Generic serial interface functions. 2 3 Copyright (C) 1992-1996, 1998-2001, 2003-2012 Free Software 4 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 218 poll. */ 219 } 220 221 return 0; 222 } 223 } 224 225 /* Read a character with user-specified timeout. TIMEOUT is number of seconds 226 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns 227 char if successful. Returns -2 if timeout expired, EOF if line dropped 228 dead, or -3 for any other error (see errno in that case). */ 229 230 static int 231 do_ser_base_readchar (struct serial *scb, int timeout) 232 { 233 int status; 234 int delta; 235 236 /* We have to be able to keep the GUI alive here, so we break the 237 original timeout into steps of 1 second, running the "keep the 238 GUI alive" hook each time through the loop. 239 240 Also, timeout = 0 means to poll, so we just set the delta to 0, 241 so we will only go through the loop once. */ 242 243 delta = (timeout == 0 ? 0 : 1); 244 while (1) 245 { 246 /* N.B. The UI may destroy our world (for instance by calling 247 remote_stop,) in which case we want to get out of here as 248 quickly as possible. It is not safe to touch scb, since 249 someone else might have freed it. The 250 deprecated_ui_loop_hook signals that we should exit by 251 returning 1. */ 252 253 if (deprecated_ui_loop_hook) 254 { 255 if (deprecated_ui_loop_hook (0)) 256 return SERIAL_TIMEOUT; 257 } 258 259 status = ser_base_wait_for (scb, delta); 260 if (timeout > 0) 261 timeout -= delta; 262 263 /* If we got a character or an error back from wait_for, then we can 264 break from the loop before the timeout is completed. */ 265 if (status != SERIAL_TIMEOUT) 266 break; 267 268 /* If we have exhausted the original timeout, then generate 269 a SERIAL_TIMEOUT, and pass it out of the loop. */ 270 else if (timeout == 0) 271 { 272 status = SERIAL_TIMEOUT; 273 break; 274 } 275 } 276 277 if (status < 0) 278 return status; 279 280 status = scb->ops->read_prim (scb, BUFSIZ); 281 282 if (status <= 0) 283 { 284 if (status == 0) 285 return SERIAL_EOF; 286 else 287 /* Got an error from read. */ 288 return SERIAL_ERROR; 289 } 290 291 scb->bufcnt = status; 292 scb->bufcnt--; 293 scb->bufp = scb->buf; 294 return *scb->bufp++; 295 } 296 297 /* Perform operations common to both old and new readchar. */ 298 299 /* Return the next character from the input FIFO. If the FIFO is 300 empty, call the SERIAL specific routine to try and read in more 301 characters. 302 303 Initially data from the input FIFO is returned (fd_event() 304 pre-reads the input into that FIFO. Once that has been emptied, 305 further data is obtained by polling the input FD using the device 306 specific readchar() function. Note: reschedule() is called after 307 every read. This is because there is no guarentee that the lower 308 level fd_event() poll_event() code (which also calls reschedule()) 309 will be called. */ 310 311 int 312 generic_readchar (struct serial *scb, int timeout, 313 int (do_readchar) (struct serial *scb, int timeout)) 314 { 315 int ch; 316 if (scb->bufcnt > 0) 317 { 318 ch = *scb->bufp; 319 scb->bufcnt--; 320 scb->bufp++; 321 } 322 else if (scb->bufcnt < 0) 323 { 324 /* Some errors/eof are are sticky. */ 325 ch = scb->bufcnt; 326 } 327 else 328 { 329 ch = do_readchar (scb, timeout); 330 if (ch < 0) 331 { 332 switch ((enum serial_rc) ch) 333 { 334 case SERIAL_EOF: 335 case SERIAL_ERROR: 336 /* Make the error/eof stick. */ 337 scb->bufcnt = ch; 338 break; 339 case SERIAL_TIMEOUT: 340 scb->bufcnt = 0; 341 break; 342 } 343 } 344 } 345 /* Read any error output we might have. */ 346 if (scb->error_fd != -1) 347 { 348 ssize_t s; 349 char buf[81]; 350 351 for (;;) 352 { 353 char *current; 354 char *newline; 355 int to_read = 80; 356 357 int num_bytes = -1; 358 if (scb->ops->avail) 359 num_bytes = (scb->ops->avail)(scb, scb->error_fd); 360 if (num_bytes != -1) 361 to_read = (num_bytes < to_read) ? num_bytes : to_read; 362 363 if (to_read == 0) 364 break; 365 366 s = read (scb->error_fd, &buf, to_read); 367 if (s == -1) 368 break; 369 if (s == 0) 370 { 371 /* EOF */ 372 close (scb->error_fd); 373 scb->error_fd = -1; 374 break; 375 } 376 377 /* In theory, embedded newlines are not a problem. 378 But for MI, we want each output line to have just 379 one newline for legibility. So output things 380 in newline chunks. */ 381 buf[s] = '\0'; 382 current = buf; 383 while ((newline = strstr (current, "\n")) != NULL) 384 { 385 *newline = '\0'; 386 fputs_unfiltered (current, gdb_stderr); 387 fputs_unfiltered ("\n", gdb_stderr); 388 current = newline + 1; 389 } 390 fputs_unfiltered (current, gdb_stderr); 391 } 392 } 393 394 reschedule (scb); 395 return ch; 396 } 397 398 int 399 ser_base_readchar (struct serial *scb, int timeout) 400 { 401 return generic_readchar (scb, timeout, do_ser_base_readchar); 402 } 403 404 int 405 ser_base_write (struct serial *scb, const char *str, int len) 406 { 407 int cc; 408 409 while (len > 0) 410 { 411 cc = scb->ops->write_prim (scb, str, len); 412 413 if (cc < 0) 414 return 1; 415 len -= cc; 416 str += cc; 417 } 418 return 0; 419 } 420 421 int 422 ser_base_flush_output (struct serial *scb) 423 { 424 return 0; 425 } 426 427 int 428 ser_base_flush_input (struct serial *scb) 429 { 430 if (scb->bufcnt >= 0) 431 { 432 scb->bufcnt = 0; 433 scb->bufp = scb->buf; 434 return 0; 435 } 436 else 437 return SERIAL_ERROR; 438 } 439 440 int 441 ser_base_send_break (struct serial *scb) 442 { 443 return 0; 444 } 445 446 int 447 ser_base_drain_output (struct serial *scb) 448 { 449 return 0; 450 } 451 452 void 453 ser_base_raw (struct serial *scb) 454 { 455 return; /* Always in raw mode. */ 456 } 457 458 serial_ttystate 459 ser_base_get_tty_state (struct serial *scb) 460 { 461 /* Allocate a dummy. */ 462 return (serial_ttystate) XMALLOC (int); 463 } 464 465 serial_ttystate 466 ser_base_copy_tty_state (struct serial *scb, serial_ttystate ttystate) 467 { 468 /* Allocate another dummy. */ 469 return (serial_ttystate) XMALLOC (int); 470 } 471 472 int 473 ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate) 474 { 475 return 0; 476 } 477 478 int 479 ser_base_noflush_set_tty_state (struct serial *scb, 480 serial_ttystate new_ttystate, 481 serial_ttystate old_ttystate) 482 { 483 return 0; 484 } 485 486 void 487 ser_base_print_tty_state (struct serial *scb, 488 serial_ttystate ttystate, 489 struct ui_file *stream) 490 { 491 /* Nothing to print. */ 492 return; 493 } 494 495 int 496 ser_base_setbaudrate (struct serial *scb, int rate) 497 { 498 return 0; /* Never fails! */ 499 } 500 501 int 502 ser_base_setstopbits (struct serial *scb, int num) 503 { 504 return 0; /* Never fails! */ 505 } 506 507 /* Put the SERIAL device into/out-of ASYNC mode. */ 508 509 void 510 ser_base_async (struct serial *scb, 511 int async_p) 512 { 513 if (async_p) 514 { 515 /* Force a re-schedule. */ 516 scb->async_state = NOTHING_SCHEDULED; 517 if (serial_debug_p (scb)) 518 fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n", 519 scb->fd); 520 reschedule (scb); 521 } 522 else 523 { 524 if (serial_debug_p (scb)) 525 fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n", 526 scb->fd); 527 /* De-schedule whatever tasks are currently scheduled. */ 528 switch (scb->async_state) 529 { 530 case FD_SCHEDULED: 531 delete_file_handler (scb->fd); 532 break; 533 case NOTHING_SCHEDULED: 534 break; 535 default: /* TIMER SCHEDULED */ 536 delete_timer (scb->async_state); 537 break; 538 } 539 } 540 } 541