X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/f9c6f39b2b0039cf29df6597d41c124048c825cd..a1b1c1ea3adb864c8c2e3feb4eaed890a9b505cf:/src/syncio.c diff --git a/src/syncio.c b/src/syncio.c index 9958363b..0c202c9e 100644 --- a/src/syncio.c +++ b/src/syncio.c @@ -36,50 +36,93 @@ * of the SYNC command where the slave does it in a blocking way, and * the MIGRATE command that must be blocking in order to be atomic from the * point of view of the two instances (one migrating the key and one receiving - * the key). This is why need the following blocking I/O functions. */ + * the key). This is why need the following blocking I/O functions. + * + * All the functions take the timeout in milliseconds. */ + +#define REDIS_SYNCIO_RESOLUTION 10 /* Resolution in milliseconds */ -int syncWrite(int fd, char *ptr, ssize_t size, int timeout) { +/* Write the specified payload to 'fd'. If writing the whole payload will be + * done within 'timeout' milliseconds the operation succeeds and 'size' is + * returned. Otherwise the operation fails, -1 is returned, and an unspecified + * partial write could be performed against the file descriptor. */ +ssize_t syncWrite(int fd, char *ptr, ssize_t size, long long timeout) { ssize_t nwritten, ret = size; - time_t start = time(NULL); + long long start = mstime(); + long long remaining = timeout; - timeout++; - while(size) { - if (aeWait(fd,AE_WRITABLE,1000) & AE_WRITABLE) { - nwritten = write(fd,ptr,size); - if (nwritten == -1) return -1; + while(1) { + long long wait = (remaining > REDIS_SYNCIO_RESOLUTION) ? + remaining : REDIS_SYNCIO_RESOLUTION; + long long elapsed; + + /* Optimistically try to write before checking if the file descriptor + * is actually writable. At worst we get EAGAIN. */ + nwritten = write(fd,ptr,size); + if (nwritten == -1) { + if (errno != EAGAIN) return -1; + } else { ptr += nwritten; size -= nwritten; } - if ((time(NULL)-start) > timeout) { + if (size == 0) return ret; + + /* Wait */ + aeWait(fd,AE_WRITABLE,wait); + elapsed = mstime() - start; + if (elapsed >= timeout) { errno = ETIMEDOUT; return -1; } + remaining = timeout - elapsed; } - return ret; } -int syncRead(int fd, char *ptr, ssize_t size, int timeout) { +/* Read the specified amount of bytes from 'fd'. If all the bytes are read + * within 'timeout' milliseconds the operation succeed and 'size' is returned. + * Otherwise the operation fails, -1 is returned, and an unspecified amount of + * data could be read from the file descriptor. */ +ssize_t syncRead(int fd, char *ptr, ssize_t size, long long timeout) { ssize_t nread, totread = 0; - time_t start = time(NULL); + long long start = mstime(); + long long remaining = timeout; - timeout++; - while(size) { - if (aeWait(fd,AE_READABLE,1000) & AE_READABLE) { - nread = read(fd,ptr,size); - if (nread <= 0) return -1; + if (size == 0) return 0; + while(1) { + long long wait = (remaining > REDIS_SYNCIO_RESOLUTION) ? + remaining : REDIS_SYNCIO_RESOLUTION; + long long elapsed; + + /* Optimistically try to read before checking if the file descriptor + * is actually readable. At worst we get EAGAIN. */ + nread = read(fd,ptr,size); + if (nread == 0) return -1; /* short read. */ + if (nread == -1) { + if (errno != EAGAIN) return -1; + } else { ptr += nread; size -= nread; totread += nread; } - if ((time(NULL)-start) > timeout) { + if (size == 0) return totread; + + /* Wait */ + aeWait(fd,AE_READABLE,wait); + elapsed = mstime() - start; + if (elapsed >= timeout) { errno = ETIMEDOUT; return -1; } + remaining = timeout - elapsed; } - return totread; } -int syncReadLine(int fd, char *ptr, ssize_t size, int timeout) { +/* Read a line making sure that every char will not require more than 'timeout' + * milliseconds to be read. + * + * On success the number of bytes read is returned, otherwise -1. + * On success the string is always correctly terminated with a 0 byte. */ +ssize_t syncReadLine(int fd, char *ptr, ssize_t size, long long timeout) { ssize_t nread = 0; size--;