X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fser-mingw.c;h=afe04102e1554ec734b7fe18c73a7b231ce224d9;hb=9cca177baec32a1ed1422a87a1f57cda2d2eb21a;hp=db049991e87c1bd4f8fca770cbd9c50415150677;hpb=70ba0933adb6b8d64b0687289d51837a58b804f9;p=binutils-gdb.git diff --git a/gdb/ser-mingw.c b/gdb/ser-mingw.c index db049991e87..afe04102e15 100644 --- a/gdb/ser-mingw.c +++ b/gdb/ser-mingw.c @@ -1,6 +1,6 @@ /* Serial interface for local (hardwired) serial ports on Windows systems - Copyright (C) 2006-2014 Free Software Foundation, Inc. + Copyright (C) 2006-2022 Free Software Foundation, Inc. This file is part of GDB. @@ -29,12 +29,8 @@ #include #include -#include "gdb_assert.h" -#include - #include "command.h" - -void _initialize_ser_windows (void); +#include "gdbsupport/buildargv.h" struct ser_windows_state { @@ -47,7 +43,8 @@ struct ser_windows_state /* CancelIo is not available for Windows 95 OS, so we need to use LoadLibrary/GetProcAddress to avoid a startup failure. */ #define CancelIo dyn_CancelIo -static BOOL WINAPI (*CancelIo) (HANDLE); +typedef BOOL WINAPI (CancelIo_ftype) (HANDLE); +static CancelIo_ftype *CancelIo; /* Open up a real live device for serial I/O. */ @@ -90,8 +87,7 @@ ser_windows_open (struct serial *scb, const char *name) return -1; } - state = xmalloc (sizeof (struct ser_windows_state)); - memset (state, 0, sizeof (struct ser_windows_state)); + state = XCNEW (struct ser_windows_state); scb->state = state; /* Create a manual reset event to watch the input buffer. */ @@ -156,7 +152,6 @@ ser_windows_raw (struct serial *scb) if (GetCommState (h, &state) == 0) return; - state.fParity = FALSE; state.fOutxCtsFlow = FALSE; state.fOutxDsrFlow = FALSE; state.fDtrControl = DTR_CONTROL_ENABLE; @@ -166,9 +161,6 @@ ser_windows_raw (struct serial *scb) state.fNull = FALSE; state.fAbortOnError = FALSE; state.ByteSize = 8; - state.Parity = NOPARITY; - - scb->current_timeout = 0; if (SetCommState (h, &state) == 0) warning (_("SetCommState failed")); @@ -201,6 +193,40 @@ ser_windows_setstopbits (struct serial *scb, int num) return (SetCommState (h, &state) != 0) ? 0 : -1; } +/* Implement the "setparity" serial_ops callback. */ + +static int +ser_windows_setparity (struct serial *scb, int parity) +{ + HANDLE h = (HANDLE) _get_osfhandle (scb->fd); + DCB state; + + if (GetCommState (h, &state) == 0) + return -1; + + switch (parity) + { + case GDBPARITY_NONE: + state.Parity = NOPARITY; + state.fParity = FALSE; + break; + case GDBPARITY_ODD: + state.Parity = ODDPARITY; + state.fParity = TRUE; + break; + case GDBPARITY_EVEN: + state.Parity = EVENPARITY; + state.fParity = TRUE; + break; + default: + internal_warning (__FILE__, __LINE__, + "Incorrect parity value: %d", parity); + return -1; + } + + return (SetCommState (h, &state) != 0) ? 0 : -1; +} + static int ser_windows_setbaudrate (struct serial *scb, int rate) { @@ -226,7 +252,7 @@ ser_windows_close (struct serial *scb) by calling close (scb->fd) below. */ if (CancelIo) CancelIo ((HANDLE) _get_osfhandle (scb->fd)); - state = scb->state; + state = (struct ser_windows_state *) scb->state; CloseHandle (state->ov.hEvent); CloseHandle (state->except_event); @@ -247,7 +273,7 @@ ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) DWORD errors; HANDLE h = (HANDLE) _get_osfhandle (scb->fd); - state = scb->state; + state = (struct ser_windows_state *) scb->state; *except = state->except_event; *read = state->ov.hEvent; @@ -296,11 +322,10 @@ ser_windows_read_prim (struct serial *scb, size_t count) { struct ser_windows_state *state; OVERLAPPED ov; - DWORD bytes_read, bytes_read_tmp; + DWORD bytes_read; HANDLE h; - gdb_byte *p; - state = scb->state; + state = (struct ser_windows_state *) scb->state; if (state->in_progress) { WaitForSingleObject (state->ov.hEvent, INFINITE); @@ -326,7 +351,6 @@ ser_windows_read_prim (struct serial *scb, size_t count) static int ser_windows_write_prim (struct serial *scb, const void *buf, size_t len) { - struct ser_windows_state *state; OVERLAPPED ov; DWORD bytes_written; HANDLE h; @@ -504,12 +528,12 @@ stop_select_thread (struct ser_console_state *state) static DWORD WINAPI console_select_thread (void *arg) { - struct serial *scb = arg; + struct serial *scb = (struct serial *) arg; struct ser_console_state *state; int event_index; HANDLE h; - state = scb->state; + state = (struct ser_console_state *) scb->state; h = (HANDLE) _get_osfhandle (scb->fd); while (1) @@ -576,6 +600,11 @@ console_select_thread (void *arg) break; } } + else if (record.EventType == MOUSE_EVENT) + { + SetEvent (state->read_event); + break; + } /* Otherwise discard it and wait again. */ ReadConsoleInput (h, &record, 1, &n_records); @@ -607,12 +636,11 @@ fd_is_file (int fd) static DWORD WINAPI pipe_select_thread (void *arg) { - struct serial *scb = arg; + struct serial *scb = (struct serial *) arg; struct ser_console_state *state; - int event_index; HANDLE h; - state = scb->state; + state = (struct ser_console_state *) scb->state; h = (HANDLE) _get_osfhandle (scb->fd); while (1) @@ -650,12 +678,11 @@ pipe_select_thread (void *arg) static DWORD WINAPI file_select_thread (void *arg) { - struct serial *scb = arg; + struct serial *scb = (struct serial *) arg; struct ser_console_state *state; - int event_index; HANDLE h; - state = scb->state; + state = (struct ser_console_state *) scb->state; h = (HANDLE) _get_osfhandle (scb->fd); while (1) @@ -676,7 +703,7 @@ file_select_thread (void *arg) static void ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) { - struct ser_console_state *state = scb->state; + struct ser_console_state *state = (struct ser_console_state *) scb->state; if (state == NULL) { @@ -691,8 +718,7 @@ ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) return; } - state = xmalloc (sizeof (struct ser_console_state)); - memset (state, 0, sizeof (struct ser_console_state)); + state = XCNEW (struct ser_console_state); scb->state = state; if (is_tty) @@ -731,7 +757,7 @@ ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) static void ser_console_done_wait_handle (struct serial *scb) { - struct ser_console_state *state = scb->state; + struct ser_console_state *state = (struct ser_console_state *) scb->state; if (state == NULL) return; @@ -742,7 +768,7 @@ ser_console_done_wait_handle (struct serial *scb) static void ser_console_close (struct serial *scb) { - struct ser_console_state *state = scb->state; + struct ser_console_state *state = (struct ser_console_state *) scb->state; if (scb->state) { @@ -763,7 +789,7 @@ ser_console_get_tty_state (struct serial *scb) { struct ser_console_ttystate *state; - state = (struct ser_console_ttystate *) xmalloc (sizeof *state); + state = XNEW (struct ser_console_ttystate); state->is_a_tty = 1; return state; } @@ -788,9 +814,8 @@ struct pipe_state static struct pipe_state * make_pipe_state (void) { - struct pipe_state *ps = XNEW (struct pipe_state); + struct pipe_state *ps = XCNEW (struct pipe_state); - memset (ps, 0, sizeof (*ps)); ps->wait.read_event = INVALID_HANDLE_VALUE; ps->wait.except_event = INVALID_HANDLE_VALUE; ps->wait.start_select = INVALID_HANDLE_VALUE; @@ -825,82 +850,74 @@ free_pipe_state (struct pipe_state *ps) errno = saved_errno; } -static void -cleanup_pipe_state (void *untyped) +struct pipe_state_destroyer { - struct pipe_state *ps = untyped; + void operator() (pipe_state *ps) const + { + free_pipe_state (ps); + } +}; - free_pipe_state (ps); -} +typedef std::unique_ptr pipe_state_up; static int pipe_windows_open (struct serial *scb, const char *name) { - struct pipe_state *ps; FILE *pex_stderr; - char **argv; - struct cleanup *back_to; if (name == NULL) error_no_arg (_("child command")); - argv = gdb_buildargv (name); - back_to = make_cleanup_freeargv (argv); + gdb_argv argv (name); if (! argv[0] || argv[0][0] == '\0') error (_("missing child command")); - ps = make_pipe_state (); - make_cleanup (cleanup_pipe_state, ps); + pipe_state_up ps (make_pipe_state ()); ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL); if (! ps->pex) - goto fail; + return -1; ps->input = pex_input_pipe (ps->pex, 1); if (! ps->input) - goto fail; + return -1; { int err; const char *err_msg = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT | PEX_STDERR_TO_PIPE, - argv[0], argv, NULL, NULL, - &err); + argv[0], argv.get (), NULL, NULL, + &err); if (err_msg) { - /* Our caller expects us to return -1, but all they'll do with - it generally is print the message based on errno. We have - all the same information here, plus err_msg provided by - pex_run, so we just raise the error here. */ - if (err) - error (_("error starting child process '%s': %s: %s"), - name, err_msg, safe_strerror (err)); - else - error (_("error starting child process '%s': %s"), - name, err_msg); + /* Our caller expects us to return -1, but all they'll do with + it generally is print the message based on errno. We have + all the same information here, plus err_msg provided by + pex_run, so we just raise the error here. */ + if (err) + error (_("error starting child process '%s': %s: %s"), + name, err_msg, safe_strerror (err)); + else + error (_("error starting child process '%s': %s"), + name, err_msg); } } ps->output = pex_read_output (ps->pex, 1); if (! ps->output) - goto fail; + return -1; scb->fd = fileno (ps->output); pex_stderr = pex_read_err (ps->pex, 1); if (! pex_stderr) - goto fail; + return -1; scb->error_fd = fileno (pex_stderr); - scb->state = (void *) ps; + scb->state = ps.release (); - discard_cleanups (back_to); return 0; - - fail: - do_cleanups (back_to); - return -1; } static int @@ -931,7 +948,7 @@ pipe_windows_fdopen (struct serial *scb, int fd) static void pipe_windows_close (struct serial *scb) { - struct pipe_state *ps = scb->state; + struct pipe_state *ps = (struct pipe_state *) scb->state; /* In theory, we should try to kill the subprocess here, but the pex interface doesn't give us enough information to do that. Usually @@ -967,7 +984,7 @@ pipe_windows_read (struct serial *scb, size_t count) static int pipe_windows_write (struct serial *scb, const void *buf, size_t count) { - struct pipe_state *ps = scb->state; + struct pipe_state *ps = (struct pipe_state *) scb->state; HANDLE pipeline_in; DWORD written; @@ -989,7 +1006,7 @@ pipe_windows_write (struct serial *scb, const void *buf, size_t count) static void pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) { - struct pipe_state *ps = scb->state; + struct pipe_state *ps = (struct pipe_state *) scb->state; /* Have we allocated our events yet? */ if (ps->wait.read_event == INVALID_HANDLE_VALUE) @@ -1010,7 +1027,7 @@ pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) static void pipe_done_wait_handle (struct serial *scb) { - struct pipe_state *ps = scb->state; + struct pipe_state *ps = (struct pipe_state *) scb->state; /* Have we allocated our events yet? */ if (ps->wait.read_event == INVALID_HANDLE_VALUE) @@ -1046,14 +1063,40 @@ struct net_windows_state HANDLE sock_event; }; +/* Check whether the socket has any pending data to be read. If so, + set the select thread's read event. On error, set the select + thread's except event. If any event was set, return true, + otherwise return false. */ + +static int +net_windows_socket_check_pending (struct serial *scb) +{ + struct net_windows_state *state = (struct net_windows_state *) scb->state; + unsigned long available; + + if (ioctlsocket (scb->fd, FIONREAD, &available) != 0) + { + /* The socket closed, or some other error. */ + SetEvent (state->base.except_event); + return 1; + } + else if (available > 0) + { + SetEvent (state->base.read_event); + return 1; + } + + return 0; +} + static DWORD WINAPI net_windows_select_thread (void *arg) { - struct serial *scb = arg; + struct serial *scb = (struct serial *) arg; struct net_windows_state *state; int event_index; - state = scb->state; + state = (struct net_windows_state *) scb->state; while (1) { @@ -1065,39 +1108,60 @@ net_windows_select_thread (void *arg) wait_events[0] = state->base.stop_select; wait_events[1] = state->sock_event; - event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE); - - if (event_index == WAIT_OBJECT_0 - || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0) - /* We have been requested to stop. */ - ; - else if (event_index != WAIT_OBJECT_0 + 1) - /* Some error has occured. Assume that this is an error - condition. */ - SetEvent (state->base.except_event); - else + /* Wait for something to happen on the socket. */ + while (1) { + event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE); + + if (event_index == WAIT_OBJECT_0 + || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0) + { + /* We have been requested to stop. */ + break; + } + + if (event_index != WAIT_OBJECT_0 + 1) + { + /* Some error has occured. Assume that this is an error + condition. */ + SetEvent (state->base.except_event); + break; + } + /* Enumerate the internal network events, and reset the object that signalled us to catch the next event. */ - WSAEnumNetworkEvents (scb->fd, state->sock_event, &events); - - gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE)); - + if (WSAEnumNetworkEvents (scb->fd, state->sock_event, &events) != 0) + { + /* Something went wrong. Maybe the socket is gone. */ + SetEvent (state->base.except_event); + break; + } + if (events.lNetworkEvents & FD_READ) - SetEvent (state->base.read_event); - + { + if (net_windows_socket_check_pending (scb)) + break; + + /* Spurious wakeup. That is, the socket's event was + signalled before we last called recv. */ + } + if (events.lNetworkEvents & FD_CLOSE) - SetEvent (state->base.except_event); + { + SetEvent (state->base.except_event); + break; + } } SetEvent (state->base.have_stopped); } + return 0; } static void net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) { - struct net_windows_state *state = scb->state; + struct net_windows_state *state = (struct net_windows_state *) scb->state; /* Start from a clean slate. */ ResetEvent (state->base.read_event); @@ -1107,66 +1171,16 @@ net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except) *read = state->base.read_event; *except = state->base.except_event; - /* Check any pending events. This both avoids starting the thread - unnecessarily, and handles stray FD_READ events (see below). */ - if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0) - { - WSANETWORKEVENTS events; - int any = 0; - - /* Enumerate the internal network events, and reset the object that - signalled us to catch the next event. */ - WSAEnumNetworkEvents (scb->fd, state->sock_event, &events); - - /* You'd think that FD_READ or FD_CLOSE would be set here. But, - sometimes, neither is. I suspect that the FD_READ is set and - the corresponding event signalled while recv is running, and - the FD_READ is then lowered when recv consumes all the data, - but there's no way to un-signal the event. This isn't a - problem for the call in net_select_thread, since any new - events after this point will not have been drained by recv. - It just means that we can't have the obvious assert here. */ - - /* If there is a read event, it might be still valid, or it might - not be - it may have been signalled before we last called - recv. Double-check that there is data. */ - if (events.lNetworkEvents & FD_READ) - { - unsigned long available; - - if (ioctlsocket (scb->fd, FIONREAD, &available) == 0 - && available > 0) - { - SetEvent (state->base.read_event); - any = 1; - } - else - /* Oops, no data. This call to recv will cause future - data to retrigger the event, e.g. while we are - in net_select_thread. */ - recv (scb->fd, NULL, 0, 0); - } - - /* If there's a close event, then record it - it is obviously - still valid, and it will not be resignalled. */ - if (events.lNetworkEvents & FD_CLOSE) - { - SetEvent (state->base.except_event); - any = 1; - } - - /* If we set either handle, there's no need to wake the thread. */ - if (any) - return; - } - - start_select_thread (&state->base); + /* Check any pending events. Otherwise, start the select + thread. */ + if (!net_windows_socket_check_pending (scb)) + start_select_thread (&state->base); } static void net_windows_done_wait_handle (struct serial *scb) { - struct net_windows_state *state = scb->state; + struct net_windows_state *state = (struct net_windows_state *) scb->state; stop_select_thread (&state->base); } @@ -1176,14 +1190,12 @@ net_windows_open (struct serial *scb, const char *name) { struct net_windows_state *state; int ret; - DWORD threadId; ret = net_open (scb, name); if (ret != 0) return ret; - state = xmalloc (sizeof (struct net_windows_state)); - memset (state, 0, sizeof (struct net_windows_state)); + state = XCNEW (struct net_windows_state); scb->state = state; /* Associate an event with the socket. */ @@ -1200,7 +1212,7 @@ net_windows_open (struct serial *scb, const char *name) static void net_windows_close (struct serial *scb) { - struct net_windows_state *state = scb->state; + struct net_windows_state *state = (struct net_windows_state *) scb->state; destroy_select_thread (&state->base); CloseHandle (state->sock_event); @@ -1230,9 +1242,9 @@ static const struct serial_ops hardwire_ops = ser_base_copy_tty_state, ser_base_set_tty_state, ser_base_print_tty_state, - ser_base_noflush_set_tty_state, ser_windows_setbaudrate, ser_windows_setstopbits, + ser_windows_setparity, ser_windows_drain_output, ser_base_async, ser_windows_read_prim, @@ -1260,7 +1272,7 @@ static const struct serial_ops tty_ops = ser_base_copy_tty_state, ser_base_set_tty_state, ser_base_print_tty_state, - ser_base_noflush_set_tty_state, + NULL, NULL, NULL, ser_base_drain_output, @@ -1290,9 +1302,9 @@ static const struct serial_ops pipe_ops = ser_base_copy_tty_state, ser_base_set_tty_state, ser_base_print_tty_state, - ser_base_noflush_set_tty_state, ser_base_setbaudrate, ser_base_setstopbits, + ser_base_setparity, ser_base_drain_output, ser_base_async, pipe_windows_read, @@ -1320,9 +1332,9 @@ static const struct serial_ops tcp_ops = ser_base_copy_tty_state, ser_base_set_tty_state, ser_base_print_tty_state, - ser_base_noflush_set_tty_state, ser_base_setbaudrate, ser_base_setstopbits, + ser_base_setparity, ser_base_drain_output, ser_base_async, net_read_prim, @@ -1332,11 +1344,11 @@ static const struct serial_ops tcp_ops = net_windows_done_wait_handle }; +void _initialize_ser_windows (); void -_initialize_ser_windows (void) +_initialize_ser_windows () { WSADATA wsa_data; - struct serial_ops *ops; HMODULE hm = NULL; @@ -1344,7 +1356,7 @@ _initialize_ser_windows (void) hm = LoadLibrary ("kernel32.dll"); if (hm) { - CancelIo = (void *) GetProcAddress (hm, "CancelIo"); + CancelIo = (CancelIo_ftype *) GetProcAddress (hm, "CancelIo"); FreeLibrary (hm); } else