X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=serialport.c;h=74d46eede7953d7ac0c761c18001cd0a3a102ffe;hb=b457865b8f42b68953bf2910dcc02d3fe27fc2a8;hp=bae37ed73a2801359f50b35cfbc4381ddbbf4495;hpb=8ebfaf896690c8be6832ccb32780c2b83630b357;p=libserialport.git diff --git a/serialport.c b/serialport.c index bae37ed..74d46ee 100644 --- a/serialport.c +++ b/serialport.c @@ -2,8 +2,8 @@ * This file is part of the libserialport project. * * Copyright (C) 2010-2012 Bert Vermeulen - * Copyright (C) 2010-2012 Uwe Hermann - * Copyright (C) 2013 Martin Ling + * Copyright (C) 2010-2015 Uwe Hermann + * Copyright (C) 2013-2015 Martin Ling * Copyright (C) 2013 Matthias Heidbrink * Copyright (C) 2014 Aurelien Jacobs * @@ -21,6 +21,7 @@ * along with this program. If not, see . */ +#include #include "libserialport.h" #include "libserialport_internal.h" @@ -74,6 +75,20 @@ SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port * DEBUG_FMT("Building structure for port %s", portname); +#if !defined(_WIN32) && defined(HAVE_REALPATH) + /* + * get_port_details() below tries to be too smart and figure out + * some transport properties from the port name which breaks with + * symlinks. Therefore we canonicalize the portname first. + */ + char pathbuf[PATH_MAX + 1]; + char *res = realpath(portname, pathbuf); + if (!res) + RETURN_ERROR(SP_ERR_ARG, "Could not retrieve realpath behind port name"); + + portname = pathbuf; +#endif + if (!(port = malloc(sizeof(struct sp_port)))) RETURN_ERROR(SP_ERR_MEM, "Port structure malloc failed"); @@ -89,6 +104,8 @@ SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port * #ifdef _WIN32 port->usb_path = NULL; port->hdl = INVALID_HANDLE_VALUE; + port->write_buf = NULL; + port->write_buf_size = 0; #else port->fd = -1; #endif @@ -295,6 +312,8 @@ SP_API void sp_free_port(struct sp_port *port) #ifdef _WIN32 if (port->usb_path) free(port->usb_path); + if (port->write_buf) + free(port->write_buf); #endif free(port); @@ -308,7 +327,8 @@ SP_PRIV struct sp_port **list_append(struct sp_port **list, void *tmp; unsigned int count; - for (count = 0; list[count]; count++); + for (count = 0; list[count]; count++) + ; if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2)))) goto fail; list = tmp; @@ -388,12 +408,12 @@ SP_API void sp_free_port_list(struct sp_port **list) #ifdef _WIN32 #define CHECK_PORT_HANDLE() do { \ if (port->hdl == INVALID_HANDLE_VALUE) \ - RETURN_ERROR(SP_ERR_ARG, "Invalid port handle"); \ + RETURN_ERROR(SP_ERR_ARG, "Port not open"); \ } while (0) #else #define CHECK_PORT_HANDLE() do { \ if (port->fd < 0) \ - RETURN_ERROR(SP_ERR_ARG, "Invalid port fd"); \ + RETURN_ERROR(SP_ERR_ARG, "Port not open"); \ } while (0) #endif #define CHECK_OPEN_PORT() do { \ @@ -627,6 +647,10 @@ SP_API enum sp_return sp_close(struct sp_port *port) CLOSE_OVERLAPPED(write_ovl); CLOSE_OVERLAPPED(wait_ovl); + if (port->write_buf) { + free(port->write_buf); + port->write_buf = NULL; + } #else /* Returns 0 upon success, -1 upon failure. */ if (close(port->fd) == -1) @@ -716,6 +740,27 @@ SP_API enum sp_return sp_drain(struct sp_port *port) #endif } +#ifdef _WIN32 +static enum sp_return await_write_completion(struct sp_port *port) +{ + TRACE("%p", port); + DWORD bytes_written; + BOOL result; + + /* Wait for previous non-blocking write to complete, if any. */ + if (port->writing) { + DEBUG("Waiting for previous write to complete"); + result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE); + port->writing = 0; + if (!result) + RETURN_FAIL("Previous write failed to complete"); + DEBUG("Previous write completed"); + } + + RETURN_OK(); +} +#endif + SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, size_t count, unsigned int timeout_ms) { @@ -738,17 +783,8 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, #ifdef _WIN32 DWORD bytes_written = 0; - BOOL result; - /* Wait for previous non-blocking write to complete, if any. */ - if (port->writing) { - DEBUG("Waiting for previous write to complete"); - result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE); - port->writing = 0; - if (!result) - RETURN_FAIL("Previous write failed to complete"); - DEBUG("Previous write completed"); - } + TRY(await_write_completion(port)); /* Set timeout. */ if (port->timeouts.WriteTotalTimeoutConstant != timeout_ms) { @@ -757,24 +793,34 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, RETURN_FAIL("SetCommTimeouts() failed"); } + /* Reduce count if it exceeds the WriteFile limit. */ + if (count > WRITEFILE_MAX_SIZE) + count = WRITEFILE_MAX_SIZE; + /* Start write. */ - if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl) == 0) { - if (GetLastError() == ERROR_IO_PENDING) { - DEBUG("Waiting for write to complete"); - GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE); - DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count); - RETURN_INT(bytes_written); - } else { - RETURN_FAIL("WriteFile() failed"); - } - } else { + if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl)) { DEBUG("Write completed immediately"); RETURN_INT(count); + } else if (GetLastError() == ERROR_IO_PENDING) { + DEBUG("Waiting for write to complete"); + if (GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE) == 0) { + if (GetLastError() == ERROR_SEM_TIMEOUT) { + DEBUG("Write timed out"); + RETURN_INT(0); + } else { + RETURN_FAIL("GetOverlappedResult() failed"); + } + } + DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count); + RETURN_INT(bytes_written); + } else { + RETURN_FAIL("WriteFile() failed"); } #else size_t bytes_written = 0; unsigned char *ptr = (unsigned char *) buf; struct timeval start, delta, now, end = {0, 0}; + int started = 0; fd_set fds; int result; @@ -788,20 +834,25 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, timeradd(&start, &delta, &end); } + FD_ZERO(&fds); + FD_SET(port->fd, &fds); + /* Loop until we have written the requested number of bytes. */ while (bytes_written < count) { - /* Wait until space is available. */ - FD_ZERO(&fds); - FD_SET(port->fd, &fds); - if (timeout_ms) { + /* + * Check timeout only if we have run select() at least once, + * to avoid any issues if a short timeout is reached before + * select() is even run. + */ + if (timeout_ms && started) { gettimeofday(&now, NULL); - if (timercmp(&now, &end, >)) { - DEBUG("Write timed out"); - RETURN_INT(bytes_written); - } + if (timercmp(&now, &end, >)) + /* Timeout has expired. */ + break; timersub(&end, &now, &delta); } result = select(port->fd + 1, NULL, &fds, NULL, timeout_ms ? &delta : NULL); + started = 1; if (result < 0) { if (errno == EINTR) { DEBUG("select() call was interrupted, repeating"); @@ -810,8 +861,8 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, RETURN_FAIL("select() failed"); } } else if (result == 0) { - DEBUG("Write timed out"); - RETURN_INT(bytes_written); + /* Timeout has expired. */ + break; } /* Do write. */ @@ -830,6 +881,9 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, ptr += result; } + if (bytes_written < count) + DEBUG("Write timed out"); + RETURN_INT(bytes_written); #endif } @@ -850,8 +904,7 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port, RETURN_INT(0); #ifdef _WIN32 - DWORD written = 0; - BYTE *ptr = (BYTE *) buf; + DWORD buf_bytes; /* Check whether previous write is complete. */ if (port->writing) { @@ -872,48 +925,43 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port, RETURN_FAIL("SetCommTimeouts() failed"); } - /* - * Keep writing data until the OS has to actually start an async IO - * for it. At that point we know the buffer is full. - */ - while (written < count) { - /* Copy first byte of user buffer. */ - port->pending_byte = *ptr++; - - /* Start asynchronous write. */ - if (WriteFile(port->hdl, &port->pending_byte, 1, NULL, &port->write_ovl) == 0) { - if (GetLastError() == ERROR_IO_PENDING) { - if (HasOverlappedIoCompleted(&port->write_ovl)) { - DEBUG("Asynchronous write completed immediately"); - port->writing = 0; - written++; - continue; - } else { - DEBUG("Asynchronous write running"); - port->writing = 1; - RETURN_INT(++written); - } - } else { - /* Actual failure of some kind. */ - RETURN_FAIL("WriteFile() failed"); - } + /* Reduce count if it exceeds the WriteFile limit. */ + if (count > WRITEFILE_MAX_SIZE) + count = WRITEFILE_MAX_SIZE; + + /* Copy data to our write buffer. */ + buf_bytes = min(port->write_buf_size, count); + memcpy(port->write_buf, buf, buf_bytes); + + /* Start asynchronous write. */ + if (WriteFile(port->hdl, port->write_buf, buf_bytes, NULL, &port->write_ovl) == 0) { + if (GetLastError() == ERROR_IO_PENDING) { + if ((port->writing = !HasOverlappedIoCompleted(&port->write_ovl))) + DEBUG("Asynchronous write completed immediately"); + else + DEBUG("Asynchronous write running"); } else { - DEBUG("Single byte written immediately"); - written++; + /* Actual failure of some kind. */ + RETURN_FAIL("WriteFile() failed"); } } DEBUG("All bytes written immediately"); - RETURN_INT(written); + RETURN_INT(buf_bytes); #else /* Returns the number of bytes written, or -1 upon failure. */ ssize_t written = write(port->fd, buf, count); - if (written < 0) - RETURN_FAIL("write() failed"); - else + if (written < 0) { + if (errno == EAGAIN) + // Buffer is full, no bytes written. + RETURN_INT(0); + else + RETURN_FAIL("write() failed"); + } else { RETURN_INT(written); + } #endif } @@ -962,25 +1010,26 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, /* Set timeout. */ if (port->timeouts.ReadIntervalTimeout != 0 || + port->timeouts.ReadTotalTimeoutMultiplier != 0 || port->timeouts.ReadTotalTimeoutConstant != timeout_ms) { port->timeouts.ReadIntervalTimeout = 0; + port->timeouts.ReadTotalTimeoutMultiplier = 0; port->timeouts.ReadTotalTimeoutConstant = timeout_ms; if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) RETURN_FAIL("SetCommTimeouts() failed"); } /* Start read. */ - if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) { - if (GetLastError() == ERROR_IO_PENDING) { - DEBUG("Waiting for read to complete"); - GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE); - DEBUG_FMT("Read completed, %d/%d bytes read", bytes_read, count); - } else { - RETURN_FAIL("ReadFile() failed"); - } - } else { + if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl)) { DEBUG("Read completed immediately"); bytes_read = count; + } else if (GetLastError() == ERROR_IO_PENDING) { + DEBUG("Waiting for read to complete"); + if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0) + RETURN_FAIL("GetOverlappedResult() failed"); + DEBUG_FMT("Read completed, %d/%d bytes read", bytes_read, count); + } else { + RETURN_FAIL("ReadFile() failed"); } TRY(restart_wait_if_needed(port, bytes_read)); @@ -989,8 +1038,9 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, #else size_t bytes_read = 0; - unsigned char *ptr = (unsigned char *) buf; + unsigned char *ptr = (unsigned char *)buf; struct timeval start, delta, now, end = {0, 0}; + int started = 0; fd_set fds; int result; @@ -1004,19 +1054,25 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, timeradd(&start, &delta, &end); } + FD_ZERO(&fds); + FD_SET(port->fd, &fds); + /* Loop until we have the requested number of bytes. */ while (bytes_read < count) { - /* Wait until data is available. */ - FD_ZERO(&fds); - FD_SET(port->fd, &fds); - if (timeout_ms) { + /* + * Check timeout only if we have run select() at least once, + * to avoid any issues if a short timeout is reached before + * select() is even run. + */ + if (timeout_ms && started) { gettimeofday(&now, NULL); if (timercmp(&now, &end, >)) /* Timeout has expired. */ - RETURN_INT(bytes_read); + break; timersub(&end, &now, &delta); } result = select(port->fd + 1, &fds, NULL, NULL, timeout_ms ? &delta : NULL); + started = 1; if (result < 0) { if (errno == EINTR) { DEBUG("select() call was interrupted, repeating"); @@ -1025,8 +1081,8 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, RETURN_FAIL("select() failed"); } } else if (result == 0) { - DEBUG("Read timed out"); - RETURN_INT(bytes_read); + /* Timeout has expired. */ + break; } /* Do read. */ @@ -1034,7 +1090,10 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, if (result < 0) { if (errno == EAGAIN) - /* This shouldn't happen because we did a select() first, but handle anyway. */ + /* + * This shouldn't happen because we did a + * select() first, but handle anyway. + */ continue; else /* This is an actual failure. */ @@ -1045,6 +1104,142 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, ptr += result; } + if (bytes_read < count) + DEBUG("Read timed out"); + + RETURN_INT(bytes_read); +#endif +} + +SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf, + size_t count, unsigned int timeout_ms) +{ + TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms); + + CHECK_OPEN_PORT(); + + if (!buf) + RETURN_ERROR(SP_ERR_ARG, "Null buffer"); + + if (count == 0) + RETURN_ERROR(SP_ERR_ARG, "Zero count"); + + if (timeout_ms) + DEBUG_FMT("Reading next max %d bytes from port %s, timeout %d ms", + count, port->name, timeout_ms); + else + DEBUG_FMT("Reading next max %d bytes from port %s, no timeout", + count, port->name); + +#ifdef _WIN32 + DWORD bytes_read = 0; + + /* If timeout_ms == 0, set maximum timeout. */ + DWORD timeout_val = (timeout_ms == 0 ? MAXDWORD - 1 : timeout_ms); + + /* Set timeout. */ + if (port->timeouts.ReadIntervalTimeout != MAXDWORD || + port->timeouts.ReadTotalTimeoutMultiplier != MAXDWORD || + port->timeouts.ReadTotalTimeoutConstant != timeout_val) { + port->timeouts.ReadIntervalTimeout = MAXDWORD; + port->timeouts.ReadTotalTimeoutMultiplier = MAXDWORD; + port->timeouts.ReadTotalTimeoutConstant = timeout_val; + if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) + RETURN_FAIL("SetCommTimeouts() failed"); + } + + /* Loop until we have at least one byte, or timeout is reached. */ + while (bytes_read == 0) { + /* Start read. */ + if (ReadFile(port->hdl, buf, count, &bytes_read, &port->read_ovl)) { + DEBUG("Read completed immediately"); + } else if (GetLastError() == ERROR_IO_PENDING) { + DEBUG("Waiting for read to complete"); + if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0) + RETURN_FAIL("GetOverlappedResult() failed"); + if (bytes_read > 0) { + DEBUG("Read completed"); + } else if (timeout_ms > 0) { + DEBUG("Read timed out"); + break; + } else { + DEBUG("Restarting read"); + } + } else { + RETURN_FAIL("ReadFile() failed"); + } + } + + TRY(restart_wait_if_needed(port, bytes_read)); + + RETURN_INT(bytes_read); + +#else + size_t bytes_read = 0; + struct timeval start, delta, now, end = {0, 0}; + int started = 0; + fd_set fds; + int result; + + if (timeout_ms) { + /* Get time at start of operation. */ + gettimeofday(&start, NULL); + /* Define duration of timeout. */ + delta.tv_sec = timeout_ms / 1000; + delta.tv_usec = (timeout_ms % 1000) * 1000; + /* Calculate time at which we should give up. */ + timeradd(&start, &delta, &end); + } + + FD_ZERO(&fds); + FD_SET(port->fd, &fds); + + /* Loop until we have at least one byte, or timeout is reached. */ + while (bytes_read == 0) { + /* + * Check timeout only if we have run select() at least once, + * to avoid any issues if a short timeout is reached before + * select() is even run. + */ + if (timeout_ms && started) { + gettimeofday(&now, NULL); + if (timercmp(&now, &end, >)) + /* Timeout has expired. */ + break; + timersub(&end, &now, &delta); + } + result = select(port->fd + 1, &fds, NULL, NULL, timeout_ms ? &delta : NULL); + started = 1; + if (result < 0) { + if (errno == EINTR) { + DEBUG("select() call was interrupted, repeating"); + continue; + } else { + RETURN_FAIL("select() failed"); + } + } else if (result == 0) { + /* Timeout has expired. */ + break; + } + + /* Do read. */ + result = read(port->fd, buf, count); + + if (result < 0) { + if (errno == EAGAIN) + /* This shouldn't happen because we did a select() first, but handle anyway. */ + continue; + else + /* This is an actual failure. */ + RETURN_FAIL("read() failed"); + } + + bytes_read = result; + } + + if (bytes_read == 0) + DEBUG("Read timed out"); + RETURN_INT(bytes_read); #endif } @@ -1066,8 +1261,10 @@ SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, /* Set timeout. */ if (port->timeouts.ReadIntervalTimeout != MAXDWORD || + port->timeouts.ReadTotalTimeoutMultiplier != 0 || port->timeouts.ReadTotalTimeoutConstant != 0) { port->timeouts.ReadIntervalTimeout = MAXDWORD; + port->timeouts.ReadTotalTimeoutMultiplier = 0; port->timeouts.ReadTotalTimeoutConstant = 0; if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) RETURN_FAIL("SetCommTimeouts() failed"); @@ -1075,10 +1272,11 @@ SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, /* Do read. */ if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) - RETURN_FAIL("ReadFile() failed"); + if (GetLastError() != ERROR_IO_PENDING) + RETURN_FAIL("ReadFile() failed"); /* Get number of bytes read. */ - if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0) + if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, FALSE) == 0) RETURN_FAIL("GetOverlappedResult() failed"); TRY(restart_wait_if_needed(port, bytes_read)); @@ -1262,6 +1460,10 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, RETURN_OK(); #else struct timeval start, delta, now, end = {0, 0}; + const struct timeval max_delta = { + (INT_MAX / 1000), (INT_MAX % 1000) * 1000 + }; + int started = 0, timeout_overflow = 0; int result, timeout_remaining_ms; struct pollfd *pollfds; unsigned int i; @@ -1270,7 +1472,7 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, RETURN_ERROR(SP_ERR_MEM, "pollfds malloc() failed"); for (i = 0; i < event_set->count; i++) { - pollfds[i].fd = ((int *) event_set->handles)[i]; + pollfds[i].fd = ((int *)event_set->handles)[i]; pollfds[i].events = 0; pollfds[i].revents = 0; if (event_set->masks[i] & SP_EVENT_RX_READY) @@ -1293,17 +1495,30 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, /* Loop until an event occurs. */ while (1) { - if (timeout_ms) { + /* + * Check timeout only if we have run poll() at least once, + * to avoid any issues if a short timeout is reached before + * poll() is even run. + */ + if (!timeout_ms) { + timeout_remaining_ms = -1; + } else if (!started) { + timeout_overflow = (timeout_ms > INT_MAX); + timeout_remaining_ms = timeout_overflow ? INT_MAX : timeout_ms; + } else { gettimeofday(&now, NULL); if (timercmp(&now, &end, >)) { DEBUG("Wait timed out"); break; } timersub(&end, &now, &delta); + if ((timeout_overflow = timercmp(&delta, &max_delta, >))) + delta = max_delta; timeout_remaining_ms = delta.tv_sec * 1000 + delta.tv_usec / 1000; } - result = poll(pollfds, event_set->count, timeout_ms ? timeout_remaining_ms : -1); + result = poll(pollfds, event_set->count, timeout_remaining_ms); + started = 1; if (result < 0) { if (errno == EINTR) { @@ -1315,7 +1530,8 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, } } else if (result == 0) { DEBUG("poll() timed out"); - break; + if (!timeout_overflow) + break; } else { DEBUG("poll() completed"); break; @@ -1666,6 +1882,9 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, DEBUG_FMT("Setting configuration for port %s", port->name); #ifdef _WIN32 + + TRY(await_write_completion(port)); + if (config->baudrate >= 0) { for (i = 0; i < NUM_STD_BAUDRATES; i++) { if (config->baudrate == std_baudrates[i].value) { @@ -1676,6 +1895,14 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (i == NUM_STD_BAUDRATES) data->dcb.BaudRate = config->baudrate; + + /* Allocate write buffer for 50ms of data at baud rate. */ + port->write_buf_size = max(config->baudrate / (8 * 20), 1); + port->write_buf = realloc(port->write_buf, + port->write_buf_size); + + if (!port->write_buf) + RETURN_ERROR(SP_ERR_MEM, "Allocating write buffer failed"); } if (config->bits >= 0)