X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=fd.c;h=d56a31101ade30bd8790d8082f8a3be5f5b84004;hp=31eb638826f93206e7d36814b7d4cd8b8988a898;hb=98f2c8aea52a49fad3fd6df67b1eb32c1499176c;hpb=89b826322cca4511a1181e344e1753f0b126a4da diff --git a/fd.c b/fd.c index 31eb6388..d56a3110 100644 --- a/fd.c +++ b/fd.c @@ -1,19 +1,22 @@ /* - * Copyright (C) 2006-2009 Andre Noll + * Copyright (C) 2006-2010 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file fd.c Helper functions for file descriptor handling. */ +#include #include #include #include #include -#include +#include #include "para.h" #include "error.h" +#include "string.h" +#include "fd.h" /** * Write a buffer to a file descriptor, re-write on short writes. @@ -79,6 +82,122 @@ int write_nonblock(int fd, const char *buf, size_t len, return written; } +/** + * Read from a non-blocking file descriptor into multiple buffers. + * + * \param fd The file descriptor to read from. + * \param iov Scatter/gather array used in readv(). + * \param iovcnt Number of elements in \a iov. + * \param rfds An optional fd set pointer. + * \param num_bytes Result pointer. Contains the number of bytes read from \a fd. + * + * If \a rfds is not \p NULL and the (non-blocking) file descriptor \a fd is + * not set in \a rfds, this function returns early without doing anything. + * Otherwise The function tries to read up to \a sz bytes from \a fd. As for + * write_nonblock(), EAGAIN is not considered an error condition. However, EOF + * is. + * + * \return Zero or a negative error code. If the underlying call to readv(2) + * returned zero (indicating an end of file condition) or failed for some + * reason other than \p EAGAIN, a negative return value is returned. + * + * In any case, \a num_bytes contains the number of bytes that have been + * successfully read from \a fd (zero if the first readv() call failed with + * EAGAIN). Note that even if the function returns negative, some data might + * have been read before the error occured. In this case \a num_bytes is + * positive. + * + * \sa \ref write_nonblock(), read(2), readv(2). + */ +int readv_nonblock(int fd, struct iovec *iov, int iovcnt, fd_set *rfds, + size_t *num_bytes) +{ + int ret, i, j; + + *num_bytes = 0; + /* + * Avoid a shortcoming of select(): Reads from a non-blocking fd might + * return EAGAIN even if FD_ISSET() returns true. However, FD_ISSET() + * returning false definitely means that no data can currently be read. + * This is the common case, so it is worth to avoid the overhead of the + * read() system call in this case. + */ + if (rfds && !FD_ISSET(fd, rfds)) + return 0; + + for (i = 0, j = 0; i < iovcnt;) { + + /* fix up the first iov */ + assert(j < iov[i].iov_len); + iov[i].iov_base += j; + iov[i].iov_len -= j; + ret = readv(fd, iov + i, iovcnt - i); + iov[i].iov_base -= j; + iov[i].iov_len += j; + + if (ret == 0) + return -E_EOF; + if (ret < 0) { + if (errno == EAGAIN) + return 0; + return -ERRNO_TO_PARA_ERROR(errno); + } + *num_bytes += ret; + while (ret > 0) { + if (ret < iov[i].iov_len - j) { + j += ret; + break; + } + ret -= iov[i].iov_len - j; + j = 0; + if (++i >= iovcnt) + break; + } + } + return 0; +} + +/** + * Read from a non-blocking file descriptor into a single buffer. + * + * \param fd The file descriptor to read from. + * \param buf The buffer to read data to. + * \param sz The size of \a buf. + * \param rfds \see \ref readv_nonblock(). + * \param num_bytes \see \ref readv_nonblock(). + * + * This is a simple wrapper for readv_nonblock() which uses an iovec with a single + * buffer. + * + * \return The return value of the underlying call to readv_nonblock(). + */ +int read_nonblock(int fd, void *buf, size_t sz, fd_set *rfds, size_t *num_bytes) +{ + struct iovec iov = {.iov_base = buf, .iov_len = sz}; + return readv_nonblock(fd, &iov, 1, rfds, num_bytes); +} + +/** + * Simple wrapper for readv(). + * + * \param fd The file descriptor to read from. + * \param iov Scatter/gather array used in readv(). + * \param iovcnt Number of elements in \a iov. + * + * \return A negative error code on errors, the return value of the underlying + * call to readv() otherwise. + * + * \sa readv(2). + */ +int para_readv(int fd, struct iovec *iov, int iovcnt) +{ + int ret = readv(fd, iov, iovcnt); + + if (ret < 0) + return -ERRNO_TO_PARA_ERROR(errno); + return ret; +} + /** * Check whether a file exists. * @@ -114,11 +233,10 @@ int file_exists(const char *fn) int para_select(int n, fd_set *readfds, fd_set *writefds, struct timeval *timeout_tv) { - int ret, err; - do { + int ret; + do ret = select(n, readfds, writefds, NULL, timeout_tv); - err = errno; - } while (ret < 0 && err == EINTR); + while (ret < 0 && errno == EINTR); if (ret < 0) return -ERRNO_TO_PARA_ERROR(errno); return ret; @@ -446,18 +564,14 @@ int para_munmap(void *start, size_t length) int write_ok(int fd) { - struct timeval tv = {0, 0}; + struct timeval tv; fd_set wfds; - int ret; -again: + FD_ZERO(&wfds); FD_SET(fd, &wfds); tv.tv_sec = 0; tv.tv_usec = 0; - ret = select(fd + 1, NULL, &wfds, NULL, &tv); - if (ret < 0 && errno == EINTR) - goto again; - return ret; + return para_select(fd + 1, NULL, &wfds, &tv); } /** @@ -480,3 +594,65 @@ void valid_fd_012(void) } } } + +/** + * Traverse the given directory recursively. + * + * \param dirname The directory to traverse. + * \param func The function to call for each entry. + * \param private_data Pointer to an arbitrary data structure. + * + * For each regular file under \a dirname, the supplied function \a func is + * called. The full path of the regular file and the \a private_data pointer + * are passed to \a func. Directories for which the calling process has no + * permissions to change to are silently ignored. + * + * \return Standard. + */ +int for_each_file_in_dir(const char *dirname, + int (*func)(const char *, void *), void *private_data) +{ + DIR *dir; + struct dirent *entry; + int cwd_fd, ret2, ret = para_opendir(dirname, &dir, &cwd_fd); + + if (ret < 0) + return ret == -ERRNO_TO_PARA_ERROR(EACCES)? 1 : ret; + /* scan cwd recursively */ + while ((entry = readdir(dir))) { + mode_t m; + char *tmp; + struct stat s; + + if (!strcmp(entry->d_name, ".")) + continue; + if (!strcmp(entry->d_name, "..")) + continue; + if (lstat(entry->d_name, &s) == -1) + continue; + m = s.st_mode; + if (!S_ISREG(m) && !S_ISDIR(m)) + continue; + tmp = make_message("%s/%s", dirname, entry->d_name); + if (!S_ISDIR(m)) { + ret = func(tmp, private_data); + free(tmp); + if (ret < 0) + goto out; + continue; + } + /* directory */ + ret = for_each_file_in_dir(tmp, func, private_data); + free(tmp); + if (ret < 0) + goto out; + } + ret = 1; +out: + closedir(dir); + ret2 = para_fchdir(cwd_fd); + if (ret2 < 0 && ret >= 0) + ret = ret2; + close(cwd_fd); + return ret; +}