1/* Generic serial interface functions. 2 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2003, 4 2004, 2005, 2006, 2007 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 34static timer_handler_func push_event; 35static 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: */ 47enum { 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 66void 67reschedule (struct serial *scb) 68{ 69 if (serial_is_async_p (scb)) 70 { 71 int next_state; 72 switch (scb->async_state) 73 { 74 case FD_SCHEDULED: 75 if (scb->bufcnt == 0) 76 next_state = FD_SCHEDULED; 77 else 78 { 79 delete_file_handler (scb->fd); 80 next_state = create_timer (0, push_event, scb); 81 } 82 break; 83 case NOTHING_SCHEDULED: 84 if (scb->bufcnt == 0) 85 { 86 add_file_handler (scb->fd, fd_event, scb); 87 next_state = FD_SCHEDULED; 88 } 89 else 90 { 91 next_state = create_timer (0, push_event, scb); 92 } 93 break; 94 default: /* TIMER SCHEDULED */ 95 if (scb->bufcnt == 0) 96 { 97 delete_timer (scb->async_state); 98 add_file_handler (scb->fd, fd_event, scb); 99 next_state = FD_SCHEDULED; 100 } 101 else 102 next_state = scb->async_state; 103 break; 104 } 105 if (serial_debug_p (scb)) 106 { 107 switch (next_state) 108 { 109 case FD_SCHEDULED: 110 if (scb->async_state != FD_SCHEDULED) 111 fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n", 112 scb->fd); 113 break; 114 default: /* TIMER SCHEDULED */ 115 if (scb->async_state == FD_SCHEDULED) 116 fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n", 117 scb->fd); 118 break; 119 } 120 } 121 scb->async_state = next_state; 122 } 123} 124 125/* FD_EVENT: This is scheduled when the input FIFO is empty (and there 126 is no pending error). As soon as data arrives, it is read into the 127 input FIFO and the client notified. The client should then drain 128 the FIFO using readchar(). If the FIFO isn't immediatly emptied, 129 push_event() is used to nag the client until it is. */ 130 131static void 132fd_event (int error, void *context) 133{ 134 struct serial *scb = context; 135 if (error != 0) 136 { 137 scb->bufcnt = SERIAL_ERROR; 138 } 139 else if (scb->bufcnt == 0) 140 { 141 /* Prime the input FIFO. The readchar() function is used to 142 pull characters out of the buffer. See also 143 generic_readchar(). */ 144 int nr; 145 nr = scb->ops->read_prim (scb, BUFSIZ); 146 if (nr == 0) 147 { 148 scb->bufcnt = SERIAL_EOF; 149 } 150 else if (nr > 0) 151 { 152 scb->bufcnt = nr; 153 scb->bufp = scb->buf; 154 } 155 else 156 { 157 scb->bufcnt = SERIAL_ERROR; 158 } 159 } 160 scb->async_handler (scb, scb->async_context); 161 reschedule (scb); 162} 163 164/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending 165 error). Nag the client until all the data has been read. In the 166 case of errors, the client will need to close or de-async the 167 device before naging stops. */ 168 169static void 170push_event (void *context) 171{ 172 struct serial *scb = context; 173 scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */ 174 scb->async_handler (scb, scb->async_context); 175 /* re-schedule */ 176 reschedule (scb); 177} 178 179/* Wait for input on scb, with timeout seconds. Returns 0 on success, 180 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */ 181 182static int 183ser_base_wait_for (struct serial *scb, int timeout) 184{ 185 while (1) 186 { 187 int numfds; 188 struct timeval tv; 189 fd_set readfds, exceptfds; 190 191 /* NOTE: Some OS's can scramble the READFDS when the select() 192 call fails (ex the kernel with Red Hat 5.2). Initialize all 193 arguments before each call. */ 194 195 tv.tv_sec = timeout; 196 tv.tv_usec = 0; 197 198 FD_ZERO (&readfds); 199 FD_ZERO (&exceptfds); 200 FD_SET (scb->fd, &readfds); 201 FD_SET (scb->fd, &exceptfds); 202 203 if (timeout >= 0) 204 numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, &tv); 205 else 206 numfds = gdb_select (scb->fd + 1, &readfds, 0, &exceptfds, 0); 207 208 if (numfds <= 0) 209 { 210 if (numfds == 0) 211 return SERIAL_TIMEOUT; 212 else if (errno == EINTR) 213 continue; 214 else 215 return SERIAL_ERROR; /* Got an error from select or poll */ 216 } 217 218 return 0; 219 } 220} 221 222/* Read a character with user-specified timeout. TIMEOUT is number of seconds 223 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns 224 char if successful. Returns -2 if timeout expired, EOF if line dropped 225 dead, or -3 for any other error (see errno in that case). */ 226 227static int 228do_ser_base_readchar (struct serial *scb, int timeout) 229{ 230 int status; 231 int delta; 232 233 /* We have to be able to keep the GUI alive here, so we break the 234 original timeout into steps of 1 second, running the "keep the 235 GUI alive" hook each time through the loop. 236 237 Also, timeout = 0 means to poll, so we just set the delta to 0, 238 so we will only go through the loop once. */ 239 240 delta = (timeout == 0 ? 0 : 1); 241 while (1) 242 { 243 /* N.B. The UI may destroy our world (for instance by calling 244 remote_stop,) in which case we want to get out of here as 245 quickly as possible. It is not safe to touch scb, since 246 someone else might have freed it. The 247 deprecated_ui_loop_hook signals that we should exit by 248 returning 1. */ 249 250 if (deprecated_ui_loop_hook) 251 { 252 if (deprecated_ui_loop_hook (0)) 253 return SERIAL_TIMEOUT; 254 } 255 256 status = ser_base_wait_for (scb, delta); 257 if (timeout > 0) 258 timeout -= delta; 259 260 /* If we got a character or an error back from wait_for, then we can 261 break from the loop before the timeout is completed. */ 262 if (status != SERIAL_TIMEOUT) 263 break; 264 265 /* If we have exhausted the original timeout, then generate 266 a SERIAL_TIMEOUT, and pass it out of the loop. */ 267 else if (timeout == 0) 268 { 269 status = SERIAL_TIMEOUT; 270 break; 271 } 272 } 273 274 if (status < 0) 275 return status; 276 277 status = scb->ops->read_prim (scb, BUFSIZ); 278 279 if (status <= 0) 280 { 281 if (status == 0) 282 /* 0 chars means timeout. (We may need to distinguish between EOF 283 & timeouts someday.) */ 284 return SERIAL_TIMEOUT; 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 310int 311generic_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 369 /* In theory, embedded newlines are not a problem. 370 But for MI, we want each output line to have just 371 one newline for legibility. So output things 372 in newline chunks. */ 373 buf[s] = '\0'; 374 current = buf; 375 while ((newline = strstr (current, "\n")) != NULL) 376 { 377 *newline = '\0'; 378 fputs_unfiltered (current, gdb_stderr); 379 fputs_unfiltered ("\n", gdb_stderr); 380 current = newline + 1; 381 } 382 fputs_unfiltered (current, gdb_stderr); 383 } 384 } 385 386 reschedule (scb); 387 return ch; 388} 389 390int 391ser_base_readchar (struct serial *scb, int timeout) 392{ 393 return generic_readchar (scb, timeout, do_ser_base_readchar); 394} 395 396int 397ser_base_write (struct serial *scb, const char *str, int len) 398{ 399 int cc; 400 401 while (len > 0) 402 { 403 cc = scb->ops->write_prim (scb, str, len); 404 405 if (cc < 0) 406 return 1; 407 len -= cc; 408 str += cc; 409 } 410 return 0; 411} 412 413int 414ser_base_flush_output (struct serial *scb) 415{ 416 return 0; 417} 418 419int 420ser_base_flush_input (struct serial *scb) 421{ 422 if (scb->bufcnt >= 0) 423 { 424 scb->bufcnt = 0; 425 scb->bufp = scb->buf; 426 return 0; 427 } 428 else 429 return SERIAL_ERROR; 430} 431 432int 433ser_base_send_break (struct serial *scb) 434{ 435 return 0; 436} 437 438int 439ser_base_drain_output (struct serial *scb) 440{ 441 return 0; 442} 443 444void 445ser_base_raw (struct serial *scb) 446{ 447 return; /* Always in raw mode */ 448} 449 450serial_ttystate 451ser_base_get_tty_state (struct serial *scb) 452{ 453 /* allocate a dummy */ 454 return (serial_ttystate) XMALLOC (int); 455} 456 457int 458ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate) 459{ 460 return 0; 461} 462 463int 464ser_base_noflush_set_tty_state (struct serial *scb, 465 serial_ttystate new_ttystate, 466 serial_ttystate old_ttystate) 467{ 468 return 0; 469} 470 471void 472ser_base_print_tty_state (struct serial *scb, 473 serial_ttystate ttystate, 474 struct ui_file *stream) 475{ 476 /* Nothing to print. */ 477 return; 478} 479 480int 481ser_base_setbaudrate (struct serial *scb, int rate) 482{ 483 return 0; /* Never fails! */ 484} 485 486int 487ser_base_setstopbits (struct serial *scb, int num) 488{ 489 return 0; /* Never fails! */ 490} 491 492/* Put the SERIAL device into/out-of ASYNC mode. */ 493 494void 495ser_base_async (struct serial *scb, 496 int async_p) 497{ 498 if (async_p) 499 { 500 /* Force a re-schedule. */ 501 scb->async_state = NOTHING_SCHEDULED; 502 if (serial_debug_p (scb)) 503 fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n", 504 scb->fd); 505 reschedule (scb); 506 } 507 else 508 { 509 if (serial_debug_p (scb)) 510 fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n", 511 scb->fd); 512 /* De-schedule whatever tasks are currently scheduled. */ 513 switch (scb->async_state) 514 { 515 case FD_SCHEDULED: 516 delete_file_handler (scb->fd); 517 break; 518 case NOTHING_SCHEDULED: 519 break; 520 default: /* TIMER SCHEDULED */ 521 delete_timer (scb->async_state); 522 break; 523 } 524 } 525} 526