Index: head/lib/libc_r/uthread/uthread_poll.c =================================================================== --- head/lib/libc_r/uthread/uthread_poll.c (revision 95947) +++ head/lib/libc_r/uthread/uthread_poll.c (revision 95948) @@ -1,99 +1,111 @@ /* * Copyright (c) 1999 Daniel Eischen * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Daniel Eischen. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY DANIEL EISCHEN AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_poll, poll); +__weak_reference(__poll, poll); int _poll(struct pollfd *fds, unsigned int nfds, int timeout) { struct pthread *curthread = _get_curthread(); struct timespec ts; int numfds = nfds; int i, ret = 0; struct pthread_poll_data data; if (numfds > _thread_dtablesize) { numfds = _thread_dtablesize; } /* Check if a timeout was specified: */ if (timeout == INFTIM) { /* Wait for ever: */ _thread_kern_set_timeout(NULL); } else if (timeout > 0) { /* Convert the timeout in msec to a timespec: */ ts.tv_sec = timeout / 1000; ts.tv_nsec = (timeout % 1000) * 1000000; /* Set the wake up time: */ _thread_kern_set_timeout(&ts); } else if (timeout < 0) { /* a timeout less than zero but not == INFTIM is invalid */ errno = EINVAL; return (-1); } if (((ret = __sys_poll(fds, numfds, 0)) == 0) && (timeout != 0)) { data.nfds = numfds; data.fds = fds; /* * Clear revents in case of a timeout which leaves fds * unchanged: */ for (i = 0; i < numfds; i++) { fds[i].revents = 0; } curthread->data.poll_data = &data; curthread->interrupted = 0; _thread_kern_sched_state(PS_POLL_WAIT, __FILE__, __LINE__); if (curthread->interrupted) { errno = EINTR; ret = -1; } else { ret = data.nfds; } } return (ret); +} + +int +__poll(struct pollfd *fds, unsigned int nfds, int timeout) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _poll(fds, nfds, timeout); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libc_r/uthread/uthread_readv.c =================================================================== --- head/lib/libc_r/uthread/uthread_readv.c (revision 95947) +++ head/lib/libc_r/uthread/uthread_readv.c (revision 95948) @@ -1,94 +1,106 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_readv, readv); +__weak_reference(__readv, readv); ssize_t _readv(int fd, const struct iovec * iov, int iovcnt) { struct pthread *curthread = _get_curthread(); int ret; int type; /* Lock the file descriptor for read: */ if ((ret = _FD_LOCK(fd, FD_READ, NULL)) == 0) { /* Get the read/write mode type: */ type = _thread_fd_table[fd]->flags & O_ACCMODE; /* Check if the file is not open for read: */ if (type != O_RDONLY && type != O_RDWR) { /* File is not open for read: */ errno = EBADF; _FD_UNLOCK(fd, FD_READ); return (-1); } /* Perform a non-blocking readv syscall: */ while ((ret = __sys_readv(fd, iov, iovcnt)) < 0) { if ((_thread_fd_table[fd]->flags & O_NONBLOCK) == 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) { curthread->data.fd.fd = fd; _thread_kern_set_timeout(NULL); /* Reset the interrupted operation flag: */ curthread->interrupted = 0; _thread_kern_sched_state(PS_FDR_WAIT, __FILE__, __LINE__); /* * Check if the operation was * interrupted by a signal */ if (curthread->interrupted) { errno = EINTR; ret = -1; break; } } else { break; } } _FD_UNLOCK(fd, FD_READ); } return (ret); +} + +ssize_t +__readv(int fd, const struct iovec *iov, int iovcnt) +{ + ssize_t ret; + + _thread_enter_cancellation_point(); + ret = _readv(fd, iov, iovcnt); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libc_r/uthread/uthread_select.c =================================================================== --- head/lib/libc_r/uthread/uthread_select.c (revision 95947) +++ head/lib/libc_r/uthread/uthread_select.c (revision 95948) @@ -1,216 +1,229 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_select, select); +__weak_reference(__select, select); int _select(int numfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval * timeout) { struct pthread *curthread = _get_curthread(); struct timespec ts; int i, ret = 0, f_wait = 1; int pfd_index, got_events = 0, fd_count = 0; struct pthread_poll_data data; if (numfds > _thread_dtablesize) { numfds = _thread_dtablesize; } /* Check if a timeout was specified: */ if (timeout) { if (timeout->tv_sec < 0 || timeout->tv_usec < 0 || timeout->tv_usec >= 1000000) { errno = EINVAL; return (-1); } /* Convert the timeval to a timespec: */ TIMEVAL_TO_TIMESPEC(timeout, &ts); /* Set the wake up time: */ _thread_kern_set_timeout(&ts); if (ts.tv_sec == 0 && ts.tv_nsec == 0) f_wait = 0; } else { /* Wait for ever: */ _thread_kern_set_timeout(NULL); } /* Count the number of file descriptors to be polled: */ if (readfds || writefds || exceptfds) { for (i = 0; i < numfds; i++) { if ((readfds && FD_ISSET(i, readfds)) || (exceptfds && FD_ISSET(i, exceptfds)) || (writefds && FD_ISSET(i, writefds))) { fd_count++; } } } /* * Allocate memory for poll data if it hasn't already been * allocated or if previously allocated memory is insufficient. */ if ((curthread->poll_data.fds == NULL) || (curthread->poll_data.nfds < fd_count)) { data.fds = (struct pollfd *) realloc(curthread->poll_data.fds, sizeof(struct pollfd) * MAX(128, fd_count)); if (data.fds == NULL) { errno = ENOMEM; ret = -1; } else { /* * Note that the threads poll data always * indicates what is allocated, not what is * currently being polled. */ curthread->poll_data.fds = data.fds; curthread->poll_data.nfds = MAX(128, fd_count); } } if (ret == 0) { /* Setup the wait data. */ data.fds = curthread->poll_data.fds; data.nfds = fd_count; /* * Setup the array of pollfds. Optimize this by * running the loop in reverse and stopping when * the number of selected file descriptors is reached. */ for (i = numfds - 1, pfd_index = fd_count - 1; (i >= 0) && (pfd_index >= 0); i--) { data.fds[pfd_index].events = 0; if (readfds && FD_ISSET(i, readfds)) { data.fds[pfd_index].events = POLLRDNORM; } if (exceptfds && FD_ISSET(i, exceptfds)) { data.fds[pfd_index].events |= POLLRDBAND; } if (writefds && FD_ISSET(i, writefds)) { data.fds[pfd_index].events |= POLLWRNORM; } if (data.fds[pfd_index].events != 0) { /* * Set the file descriptor to be polled and * clear revents in case of a timeout which * leaves fds unchanged: */ data.fds[pfd_index].fd = i; data.fds[pfd_index].revents = 0; pfd_index--; } } if (((ret = __sys_poll(data.fds, data.nfds, 0)) == 0) && (f_wait != 0)) { curthread->data.poll_data = &data; curthread->interrupted = 0; _thread_kern_sched_state(PS_SELECT_WAIT, __FILE__, __LINE__); if (curthread->interrupted) { errno = EINTR; data.nfds = 0; ret = -1; } else ret = data.nfds; } } if (ret >= 0) { numfds = 0; for (i = 0; i < fd_count; i++) { /* * Check the results of the poll and clear * this file descriptor from the fdset if * the requested event wasn't ready. */ /* * First check for invalid descriptor. * If found, set errno and return -1. */ if (data.fds[i].revents & POLLNVAL) { errno = EBADF; return -1; } got_events = 0; if (readfds != NULL) { if (FD_ISSET(data.fds[i].fd, readfds)) { if (data.fds[i].revents & (POLLIN | POLLRDNORM)) got_events++; else FD_CLR(data.fds[i].fd, readfds); } } if (writefds != NULL) { if (FD_ISSET(data.fds[i].fd, writefds)) { if (data.fds[i].revents & (POLLOUT | POLLWRNORM | POLLWRBAND)) got_events++; else FD_CLR(data.fds[i].fd, writefds); } } if (exceptfds != NULL) { if (FD_ISSET(data.fds[i].fd, exceptfds)) { if (data.fds[i].revents & (POLLRDBAND | POLLPRI)) got_events++; else FD_CLR(data.fds[i].fd, exceptfds); } } if (got_events != 0) numfds+=got_events; } ret = numfds; } return (ret); +} + +int +__select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, + struct timeval *timeout) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _select(numfds, readfds, writefds, exceptfds, timeout); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libc_r/uthread/uthread_wait4.c =================================================================== --- head/lib/libc_r/uthread/uthread_wait4.c (revision 95947) +++ head/lib/libc_r/uthread/uthread_wait4.c (revision 95948) @@ -1,70 +1,82 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include "pthread_private.h" -__weak_reference(_wait4, wait4); +__weak_reference(__wait4, wait4); pid_t _wait4(pid_t pid, int *istat, int options, struct rusage * rusage) { struct pthread *curthread = _get_curthread(); pid_t ret; _thread_kern_sig_defer(); /* Perform a non-blocking wait4 syscall: */ while ((ret = __sys_wait4(pid, istat, options | WNOHANG, rusage)) == 0 && (options & WNOHANG) == 0) { /* Reset the interrupted operation flag: */ curthread->interrupted = 0; /* Schedule the next thread while this one waits: */ _thread_kern_sched_state(PS_WAIT_WAIT, __FILE__, __LINE__); /* Check if this call was interrupted by a signal: */ if (curthread->interrupted) { errno = EINTR; ret = -1; break; } } _thread_kern_sig_undefer(); return (ret); +} + +pid_t +__wait4(pid_t pid, int *istat, int options, struct rusage *rusage) +{ + pid_t ret; + + _thread_enter_cancellation_point(); + ret = _wait4(pid, istat, options, rusage); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libc_r/uthread/uthread_writev.c =================================================================== --- head/lib/libc_r/uthread/uthread_writev.c (revision 95947) +++ head/lib/libc_r/uthread/uthread_writev.c (revision 95948) @@ -1,204 +1,216 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_writev, writev); +__weak_reference(__writev, writev); ssize_t _writev(int fd, const struct iovec * iov, int iovcnt) { struct pthread *curthread = _get_curthread(); int blocking; int idx = 0; int type; ssize_t cnt; ssize_t n; ssize_t num = 0; ssize_t ret; struct iovec liov[20]; struct iovec *p_iov = liov; /* Check if the array size exceeds to compiled in size: */ if (iovcnt > (sizeof(liov) / sizeof(struct iovec))) { /* Allocate memory for the local array: */ if ((p_iov = (struct iovec *) malloc(iovcnt * sizeof(struct iovec))) == NULL) { /* Insufficient memory: */ errno = ENOMEM; return (-1); } } /* Copy the caller's array so that it can be modified locally: */ memcpy(p_iov,iov,iovcnt * sizeof(struct iovec)); /* Lock the file descriptor for write: */ if ((ret = _FD_LOCK(fd, FD_WRITE, NULL)) == 0) { /* Get the read/write mode type: */ type = _thread_fd_table[fd]->flags & O_ACCMODE; /* Check if the file is not open for write: */ if (type != O_WRONLY && type != O_RDWR) { /* File is not open for write: */ errno = EBADF; _FD_UNLOCK(fd, FD_WRITE); return (-1); } /* Check if file operations are to block */ blocking = ((_thread_fd_table[fd]->flags & O_NONBLOCK) == 0); /* * Loop while no error occurs and until the expected number * of bytes are written if performing a blocking write: */ while (ret == 0) { /* Perform a non-blocking write syscall: */ n = __sys_writev(fd, &p_iov[idx], iovcnt - idx); /* Check if one or more bytes were written: */ if (n > 0) { /* * Keep a count of the number of bytes * written: */ num += n; /* * Enter a loop to check if a short write * occurred and move the index to the * array entry where the short write * ended: */ cnt = n; while (cnt > 0 && idx < iovcnt) { /* * If the residual count exceeds * the size of this vector, then * it was completely written: */ if (cnt >= p_iov[idx].iov_len) /* * Decrement the residual * count and increment the * index to the next array * entry: */ cnt -= p_iov[idx++].iov_len; else { /* * This entry was only * partially written, so * adjust it's length * and base pointer ready * for the next write: */ p_iov[idx].iov_len -= cnt; p_iov[idx].iov_base += cnt; cnt = 0; } } } else if (n == 0) { /* * Avoid an infinite loop if the last iov_len is * 0. */ while (idx < iovcnt && p_iov[idx].iov_len == 0) idx++; if (idx == iovcnt) { ret = num; break; } } /* * If performing a blocking write, check if the * write would have blocked or if some bytes * were written but there are still more to * write: */ if (blocking && ((n < 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) || (n >= 0 && idx < iovcnt))) { curthread->data.fd.fd = fd; _thread_kern_set_timeout(NULL); /* Reset the interrupted operation flag: */ curthread->interrupted = 0; _thread_kern_sched_state(PS_FDW_WAIT, __FILE__, __LINE__); /* * Check if the operation was * interrupted by a signal */ if (curthread->interrupted) { /* Return an error: */ ret = -1; } /* * If performing a non-blocking write or if an * error occurred, just return whatever the write * syscall did: */ } else if (!blocking || n < 0) { /* A non-blocking call might return zero: */ ret = n; break; /* Check if the write has completed: */ } else if (idx == iovcnt) /* Return the number of bytes written: */ ret = num; } _FD_UNLOCK(fd, FD_RDWR); } /* If memory was allocated for the array, free it: */ if (p_iov != liov) free(p_iov); return (ret); +} + +ssize_t +__writev(int fd, const struct iovec *iov, int iovcnt) +{ + ssize_t ret; + + _thread_enter_cancellation_point(); + ret = _writev(fd, iov, iovcnt); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libkse/thread/thr_poll.c =================================================================== --- head/lib/libkse/thread/thr_poll.c (revision 95947) +++ head/lib/libkse/thread/thr_poll.c (revision 95948) @@ -1,99 +1,111 @@ /* * Copyright (c) 1999 Daniel Eischen * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Daniel Eischen. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY DANIEL EISCHEN AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_poll, poll); +__weak_reference(__poll, poll); int _poll(struct pollfd *fds, unsigned int nfds, int timeout) { struct pthread *curthread = _get_curthread(); struct timespec ts; int numfds = nfds; int i, ret = 0; struct pthread_poll_data data; if (numfds > _thread_dtablesize) { numfds = _thread_dtablesize; } /* Check if a timeout was specified: */ if (timeout == INFTIM) { /* Wait for ever: */ _thread_kern_set_timeout(NULL); } else if (timeout > 0) { /* Convert the timeout in msec to a timespec: */ ts.tv_sec = timeout / 1000; ts.tv_nsec = (timeout % 1000) * 1000000; /* Set the wake up time: */ _thread_kern_set_timeout(&ts); } else if (timeout < 0) { /* a timeout less than zero but not == INFTIM is invalid */ errno = EINVAL; return (-1); } if (((ret = __sys_poll(fds, numfds, 0)) == 0) && (timeout != 0)) { data.nfds = numfds; data.fds = fds; /* * Clear revents in case of a timeout which leaves fds * unchanged: */ for (i = 0; i < numfds; i++) { fds[i].revents = 0; } curthread->data.poll_data = &data; curthread->interrupted = 0; _thread_kern_sched_state(PS_POLL_WAIT, __FILE__, __LINE__); if (curthread->interrupted) { errno = EINTR; ret = -1; } else { ret = data.nfds; } } return (ret); +} + +int +__poll(struct pollfd *fds, unsigned int nfds, int timeout) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _poll(fds, nfds, timeout); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libkse/thread/thr_readv.c =================================================================== --- head/lib/libkse/thread/thr_readv.c (revision 95947) +++ head/lib/libkse/thread/thr_readv.c (revision 95948) @@ -1,94 +1,106 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_readv, readv); +__weak_reference(__readv, readv); ssize_t _readv(int fd, const struct iovec * iov, int iovcnt) { struct pthread *curthread = _get_curthread(); int ret; int type; /* Lock the file descriptor for read: */ if ((ret = _FD_LOCK(fd, FD_READ, NULL)) == 0) { /* Get the read/write mode type: */ type = _thread_fd_table[fd]->flags & O_ACCMODE; /* Check if the file is not open for read: */ if (type != O_RDONLY && type != O_RDWR) { /* File is not open for read: */ errno = EBADF; _FD_UNLOCK(fd, FD_READ); return (-1); } /* Perform a non-blocking readv syscall: */ while ((ret = __sys_readv(fd, iov, iovcnt)) < 0) { if ((_thread_fd_table[fd]->flags & O_NONBLOCK) == 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) { curthread->data.fd.fd = fd; _thread_kern_set_timeout(NULL); /* Reset the interrupted operation flag: */ curthread->interrupted = 0; _thread_kern_sched_state(PS_FDR_WAIT, __FILE__, __LINE__); /* * Check if the operation was * interrupted by a signal */ if (curthread->interrupted) { errno = EINTR; ret = -1; break; } } else { break; } } _FD_UNLOCK(fd, FD_READ); } return (ret); +} + +ssize_t +__readv(int fd, const struct iovec *iov, int iovcnt) +{ + ssize_t ret; + + _thread_enter_cancellation_point(); + ret = _readv(fd, iov, iovcnt); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libkse/thread/thr_select.c =================================================================== --- head/lib/libkse/thread/thr_select.c (revision 95947) +++ head/lib/libkse/thread/thr_select.c (revision 95948) @@ -1,216 +1,229 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_select, select); +__weak_reference(__select, select); int _select(int numfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval * timeout) { struct pthread *curthread = _get_curthread(); struct timespec ts; int i, ret = 0, f_wait = 1; int pfd_index, got_events = 0, fd_count = 0; struct pthread_poll_data data; if (numfds > _thread_dtablesize) { numfds = _thread_dtablesize; } /* Check if a timeout was specified: */ if (timeout) { if (timeout->tv_sec < 0 || timeout->tv_usec < 0 || timeout->tv_usec >= 1000000) { errno = EINVAL; return (-1); } /* Convert the timeval to a timespec: */ TIMEVAL_TO_TIMESPEC(timeout, &ts); /* Set the wake up time: */ _thread_kern_set_timeout(&ts); if (ts.tv_sec == 0 && ts.tv_nsec == 0) f_wait = 0; } else { /* Wait for ever: */ _thread_kern_set_timeout(NULL); } /* Count the number of file descriptors to be polled: */ if (readfds || writefds || exceptfds) { for (i = 0; i < numfds; i++) { if ((readfds && FD_ISSET(i, readfds)) || (exceptfds && FD_ISSET(i, exceptfds)) || (writefds && FD_ISSET(i, writefds))) { fd_count++; } } } /* * Allocate memory for poll data if it hasn't already been * allocated or if previously allocated memory is insufficient. */ if ((curthread->poll_data.fds == NULL) || (curthread->poll_data.nfds < fd_count)) { data.fds = (struct pollfd *) realloc(curthread->poll_data.fds, sizeof(struct pollfd) * MAX(128, fd_count)); if (data.fds == NULL) { errno = ENOMEM; ret = -1; } else { /* * Note that the threads poll data always * indicates what is allocated, not what is * currently being polled. */ curthread->poll_data.fds = data.fds; curthread->poll_data.nfds = MAX(128, fd_count); } } if (ret == 0) { /* Setup the wait data. */ data.fds = curthread->poll_data.fds; data.nfds = fd_count; /* * Setup the array of pollfds. Optimize this by * running the loop in reverse and stopping when * the number of selected file descriptors is reached. */ for (i = numfds - 1, pfd_index = fd_count - 1; (i >= 0) && (pfd_index >= 0); i--) { data.fds[pfd_index].events = 0; if (readfds && FD_ISSET(i, readfds)) { data.fds[pfd_index].events = POLLRDNORM; } if (exceptfds && FD_ISSET(i, exceptfds)) { data.fds[pfd_index].events |= POLLRDBAND; } if (writefds && FD_ISSET(i, writefds)) { data.fds[pfd_index].events |= POLLWRNORM; } if (data.fds[pfd_index].events != 0) { /* * Set the file descriptor to be polled and * clear revents in case of a timeout which * leaves fds unchanged: */ data.fds[pfd_index].fd = i; data.fds[pfd_index].revents = 0; pfd_index--; } } if (((ret = __sys_poll(data.fds, data.nfds, 0)) == 0) && (f_wait != 0)) { curthread->data.poll_data = &data; curthread->interrupted = 0; _thread_kern_sched_state(PS_SELECT_WAIT, __FILE__, __LINE__); if (curthread->interrupted) { errno = EINTR; data.nfds = 0; ret = -1; } else ret = data.nfds; } } if (ret >= 0) { numfds = 0; for (i = 0; i < fd_count; i++) { /* * Check the results of the poll and clear * this file descriptor from the fdset if * the requested event wasn't ready. */ /* * First check for invalid descriptor. * If found, set errno and return -1. */ if (data.fds[i].revents & POLLNVAL) { errno = EBADF; return -1; } got_events = 0; if (readfds != NULL) { if (FD_ISSET(data.fds[i].fd, readfds)) { if (data.fds[i].revents & (POLLIN | POLLRDNORM)) got_events++; else FD_CLR(data.fds[i].fd, readfds); } } if (writefds != NULL) { if (FD_ISSET(data.fds[i].fd, writefds)) { if (data.fds[i].revents & (POLLOUT | POLLWRNORM | POLLWRBAND)) got_events++; else FD_CLR(data.fds[i].fd, writefds); } } if (exceptfds != NULL) { if (FD_ISSET(data.fds[i].fd, exceptfds)) { if (data.fds[i].revents & (POLLRDBAND | POLLPRI)) got_events++; else FD_CLR(data.fds[i].fd, exceptfds); } } if (got_events != 0) numfds+=got_events; } ret = numfds; } return (ret); +} + +int +__select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, + struct timeval *timeout) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _select(numfds, readfds, writefds, exceptfds, timeout); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libkse/thread/thr_wait4.c =================================================================== --- head/lib/libkse/thread/thr_wait4.c (revision 95947) +++ head/lib/libkse/thread/thr_wait4.c (revision 95948) @@ -1,70 +1,82 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include "pthread_private.h" -__weak_reference(_wait4, wait4); +__weak_reference(__wait4, wait4); pid_t _wait4(pid_t pid, int *istat, int options, struct rusage * rusage) { struct pthread *curthread = _get_curthread(); pid_t ret; _thread_kern_sig_defer(); /* Perform a non-blocking wait4 syscall: */ while ((ret = __sys_wait4(pid, istat, options | WNOHANG, rusage)) == 0 && (options & WNOHANG) == 0) { /* Reset the interrupted operation flag: */ curthread->interrupted = 0; /* Schedule the next thread while this one waits: */ _thread_kern_sched_state(PS_WAIT_WAIT, __FILE__, __LINE__); /* Check if this call was interrupted by a signal: */ if (curthread->interrupted) { errno = EINTR; ret = -1; break; } } _thread_kern_sig_undefer(); return (ret); +} + +pid_t +__wait4(pid_t pid, int *istat, int options, struct rusage *rusage) +{ + pid_t ret; + + _thread_enter_cancellation_point(); + ret = _wait4(pid, istat, options, rusage); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libkse/thread/thr_writev.c =================================================================== --- head/lib/libkse/thread/thr_writev.c (revision 95947) +++ head/lib/libkse/thread/thr_writev.c (revision 95948) @@ -1,204 +1,216 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_writev, writev); +__weak_reference(__writev, writev); ssize_t _writev(int fd, const struct iovec * iov, int iovcnt) { struct pthread *curthread = _get_curthread(); int blocking; int idx = 0; int type; ssize_t cnt; ssize_t n; ssize_t num = 0; ssize_t ret; struct iovec liov[20]; struct iovec *p_iov = liov; /* Check if the array size exceeds to compiled in size: */ if (iovcnt > (sizeof(liov) / sizeof(struct iovec))) { /* Allocate memory for the local array: */ if ((p_iov = (struct iovec *) malloc(iovcnt * sizeof(struct iovec))) == NULL) { /* Insufficient memory: */ errno = ENOMEM; return (-1); } } /* Copy the caller's array so that it can be modified locally: */ memcpy(p_iov,iov,iovcnt * sizeof(struct iovec)); /* Lock the file descriptor for write: */ if ((ret = _FD_LOCK(fd, FD_WRITE, NULL)) == 0) { /* Get the read/write mode type: */ type = _thread_fd_table[fd]->flags & O_ACCMODE; /* Check if the file is not open for write: */ if (type != O_WRONLY && type != O_RDWR) { /* File is not open for write: */ errno = EBADF; _FD_UNLOCK(fd, FD_WRITE); return (-1); } /* Check if file operations are to block */ blocking = ((_thread_fd_table[fd]->flags & O_NONBLOCK) == 0); /* * Loop while no error occurs and until the expected number * of bytes are written if performing a blocking write: */ while (ret == 0) { /* Perform a non-blocking write syscall: */ n = __sys_writev(fd, &p_iov[idx], iovcnt - idx); /* Check if one or more bytes were written: */ if (n > 0) { /* * Keep a count of the number of bytes * written: */ num += n; /* * Enter a loop to check if a short write * occurred and move the index to the * array entry where the short write * ended: */ cnt = n; while (cnt > 0 && idx < iovcnt) { /* * If the residual count exceeds * the size of this vector, then * it was completely written: */ if (cnt >= p_iov[idx].iov_len) /* * Decrement the residual * count and increment the * index to the next array * entry: */ cnt -= p_iov[idx++].iov_len; else { /* * This entry was only * partially written, so * adjust it's length * and base pointer ready * for the next write: */ p_iov[idx].iov_len -= cnt; p_iov[idx].iov_base += cnt; cnt = 0; } } } else if (n == 0) { /* * Avoid an infinite loop if the last iov_len is * 0. */ while (idx < iovcnt && p_iov[idx].iov_len == 0) idx++; if (idx == iovcnt) { ret = num; break; } } /* * If performing a blocking write, check if the * write would have blocked or if some bytes * were written but there are still more to * write: */ if (blocking && ((n < 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) || (n >= 0 && idx < iovcnt))) { curthread->data.fd.fd = fd; _thread_kern_set_timeout(NULL); /* Reset the interrupted operation flag: */ curthread->interrupted = 0; _thread_kern_sched_state(PS_FDW_WAIT, __FILE__, __LINE__); /* * Check if the operation was * interrupted by a signal */ if (curthread->interrupted) { /* Return an error: */ ret = -1; } /* * If performing a non-blocking write or if an * error occurred, just return whatever the write * syscall did: */ } else if (!blocking || n < 0) { /* A non-blocking call might return zero: */ ret = n; break; /* Check if the write has completed: */ } else if (idx == iovcnt) /* Return the number of bytes written: */ ret = num; } _FD_UNLOCK(fd, FD_RDWR); } /* If memory was allocated for the array, free it: */ if (p_iov != liov) free(p_iov); return (ret); +} + +ssize_t +__writev(int fd, const struct iovec *iov, int iovcnt) +{ + ssize_t ret; + + _thread_enter_cancellation_point(); + ret = _writev(fd, iov, iovcnt); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libpthread/thread/thr_poll.c =================================================================== --- head/lib/libpthread/thread/thr_poll.c (revision 95947) +++ head/lib/libpthread/thread/thr_poll.c (revision 95948) @@ -1,99 +1,111 @@ /* * Copyright (c) 1999 Daniel Eischen * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Daniel Eischen. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY DANIEL EISCHEN AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_poll, poll); +__weak_reference(__poll, poll); int _poll(struct pollfd *fds, unsigned int nfds, int timeout) { struct pthread *curthread = _get_curthread(); struct timespec ts; int numfds = nfds; int i, ret = 0; struct pthread_poll_data data; if (numfds > _thread_dtablesize) { numfds = _thread_dtablesize; } /* Check if a timeout was specified: */ if (timeout == INFTIM) { /* Wait for ever: */ _thread_kern_set_timeout(NULL); } else if (timeout > 0) { /* Convert the timeout in msec to a timespec: */ ts.tv_sec = timeout / 1000; ts.tv_nsec = (timeout % 1000) * 1000000; /* Set the wake up time: */ _thread_kern_set_timeout(&ts); } else if (timeout < 0) { /* a timeout less than zero but not == INFTIM is invalid */ errno = EINVAL; return (-1); } if (((ret = __sys_poll(fds, numfds, 0)) == 0) && (timeout != 0)) { data.nfds = numfds; data.fds = fds; /* * Clear revents in case of a timeout which leaves fds * unchanged: */ for (i = 0; i < numfds; i++) { fds[i].revents = 0; } curthread->data.poll_data = &data; curthread->interrupted = 0; _thread_kern_sched_state(PS_POLL_WAIT, __FILE__, __LINE__); if (curthread->interrupted) { errno = EINTR; ret = -1; } else { ret = data.nfds; } } return (ret); +} + +int +__poll(struct pollfd *fds, unsigned int nfds, int timeout) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _poll(fds, nfds, timeout); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libpthread/thread/thr_readv.c =================================================================== --- head/lib/libpthread/thread/thr_readv.c (revision 95947) +++ head/lib/libpthread/thread/thr_readv.c (revision 95948) @@ -1,94 +1,106 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_readv, readv); +__weak_reference(__readv, readv); ssize_t _readv(int fd, const struct iovec * iov, int iovcnt) { struct pthread *curthread = _get_curthread(); int ret; int type; /* Lock the file descriptor for read: */ if ((ret = _FD_LOCK(fd, FD_READ, NULL)) == 0) { /* Get the read/write mode type: */ type = _thread_fd_table[fd]->flags & O_ACCMODE; /* Check if the file is not open for read: */ if (type != O_RDONLY && type != O_RDWR) { /* File is not open for read: */ errno = EBADF; _FD_UNLOCK(fd, FD_READ); return (-1); } /* Perform a non-blocking readv syscall: */ while ((ret = __sys_readv(fd, iov, iovcnt)) < 0) { if ((_thread_fd_table[fd]->flags & O_NONBLOCK) == 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) { curthread->data.fd.fd = fd; _thread_kern_set_timeout(NULL); /* Reset the interrupted operation flag: */ curthread->interrupted = 0; _thread_kern_sched_state(PS_FDR_WAIT, __FILE__, __LINE__); /* * Check if the operation was * interrupted by a signal */ if (curthread->interrupted) { errno = EINTR; ret = -1; break; } } else { break; } } _FD_UNLOCK(fd, FD_READ); } return (ret); +} + +ssize_t +__readv(int fd, const struct iovec *iov, int iovcnt) +{ + ssize_t ret; + + _thread_enter_cancellation_point(); + ret = _readv(fd, iov, iovcnt); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libpthread/thread/thr_select.c =================================================================== --- head/lib/libpthread/thread/thr_select.c (revision 95947) +++ head/lib/libpthread/thread/thr_select.c (revision 95948) @@ -1,216 +1,229 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_select, select); +__weak_reference(__select, select); int _select(int numfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval * timeout) { struct pthread *curthread = _get_curthread(); struct timespec ts; int i, ret = 0, f_wait = 1; int pfd_index, got_events = 0, fd_count = 0; struct pthread_poll_data data; if (numfds > _thread_dtablesize) { numfds = _thread_dtablesize; } /* Check if a timeout was specified: */ if (timeout) { if (timeout->tv_sec < 0 || timeout->tv_usec < 0 || timeout->tv_usec >= 1000000) { errno = EINVAL; return (-1); } /* Convert the timeval to a timespec: */ TIMEVAL_TO_TIMESPEC(timeout, &ts); /* Set the wake up time: */ _thread_kern_set_timeout(&ts); if (ts.tv_sec == 0 && ts.tv_nsec == 0) f_wait = 0; } else { /* Wait for ever: */ _thread_kern_set_timeout(NULL); } /* Count the number of file descriptors to be polled: */ if (readfds || writefds || exceptfds) { for (i = 0; i < numfds; i++) { if ((readfds && FD_ISSET(i, readfds)) || (exceptfds && FD_ISSET(i, exceptfds)) || (writefds && FD_ISSET(i, writefds))) { fd_count++; } } } /* * Allocate memory for poll data if it hasn't already been * allocated or if previously allocated memory is insufficient. */ if ((curthread->poll_data.fds == NULL) || (curthread->poll_data.nfds < fd_count)) { data.fds = (struct pollfd *) realloc(curthread->poll_data.fds, sizeof(struct pollfd) * MAX(128, fd_count)); if (data.fds == NULL) { errno = ENOMEM; ret = -1; } else { /* * Note that the threads poll data always * indicates what is allocated, not what is * currently being polled. */ curthread->poll_data.fds = data.fds; curthread->poll_data.nfds = MAX(128, fd_count); } } if (ret == 0) { /* Setup the wait data. */ data.fds = curthread->poll_data.fds; data.nfds = fd_count; /* * Setup the array of pollfds. Optimize this by * running the loop in reverse and stopping when * the number of selected file descriptors is reached. */ for (i = numfds - 1, pfd_index = fd_count - 1; (i >= 0) && (pfd_index >= 0); i--) { data.fds[pfd_index].events = 0; if (readfds && FD_ISSET(i, readfds)) { data.fds[pfd_index].events = POLLRDNORM; } if (exceptfds && FD_ISSET(i, exceptfds)) { data.fds[pfd_index].events |= POLLRDBAND; } if (writefds && FD_ISSET(i, writefds)) { data.fds[pfd_index].events |= POLLWRNORM; } if (data.fds[pfd_index].events != 0) { /* * Set the file descriptor to be polled and * clear revents in case of a timeout which * leaves fds unchanged: */ data.fds[pfd_index].fd = i; data.fds[pfd_index].revents = 0; pfd_index--; } } if (((ret = __sys_poll(data.fds, data.nfds, 0)) == 0) && (f_wait != 0)) { curthread->data.poll_data = &data; curthread->interrupted = 0; _thread_kern_sched_state(PS_SELECT_WAIT, __FILE__, __LINE__); if (curthread->interrupted) { errno = EINTR; data.nfds = 0; ret = -1; } else ret = data.nfds; } } if (ret >= 0) { numfds = 0; for (i = 0; i < fd_count; i++) { /* * Check the results of the poll and clear * this file descriptor from the fdset if * the requested event wasn't ready. */ /* * First check for invalid descriptor. * If found, set errno and return -1. */ if (data.fds[i].revents & POLLNVAL) { errno = EBADF; return -1; } got_events = 0; if (readfds != NULL) { if (FD_ISSET(data.fds[i].fd, readfds)) { if (data.fds[i].revents & (POLLIN | POLLRDNORM)) got_events++; else FD_CLR(data.fds[i].fd, readfds); } } if (writefds != NULL) { if (FD_ISSET(data.fds[i].fd, writefds)) { if (data.fds[i].revents & (POLLOUT | POLLWRNORM | POLLWRBAND)) got_events++; else FD_CLR(data.fds[i].fd, writefds); } } if (exceptfds != NULL) { if (FD_ISSET(data.fds[i].fd, exceptfds)) { if (data.fds[i].revents & (POLLRDBAND | POLLPRI)) got_events++; else FD_CLR(data.fds[i].fd, exceptfds); } } if (got_events != 0) numfds+=got_events; } ret = numfds; } return (ret); +} + +int +__select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, + struct timeval *timeout) +{ + int ret; + + _thread_enter_cancellation_point(); + ret = _select(numfds, readfds, writefds, exceptfds, timeout); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libpthread/thread/thr_wait4.c =================================================================== --- head/lib/libpthread/thread/thr_wait4.c (revision 95947) +++ head/lib/libpthread/thread/thr_wait4.c (revision 95948) @@ -1,70 +1,82 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include "pthread_private.h" -__weak_reference(_wait4, wait4); +__weak_reference(__wait4, wait4); pid_t _wait4(pid_t pid, int *istat, int options, struct rusage * rusage) { struct pthread *curthread = _get_curthread(); pid_t ret; _thread_kern_sig_defer(); /* Perform a non-blocking wait4 syscall: */ while ((ret = __sys_wait4(pid, istat, options | WNOHANG, rusage)) == 0 && (options & WNOHANG) == 0) { /* Reset the interrupted operation flag: */ curthread->interrupted = 0; /* Schedule the next thread while this one waits: */ _thread_kern_sched_state(PS_WAIT_WAIT, __FILE__, __LINE__); /* Check if this call was interrupted by a signal: */ if (curthread->interrupted) { errno = EINTR; ret = -1; break; } } _thread_kern_sig_undefer(); return (ret); +} + +pid_t +__wait4(pid_t pid, int *istat, int options, struct rusage *rusage) +{ + pid_t ret; + + _thread_enter_cancellation_point(); + ret = _wait4(pid, istat, options, rusage); + _thread_leave_cancellation_point(); + + return ret; } Index: head/lib/libpthread/thread/thr_writev.c =================================================================== --- head/lib/libpthread/thread/thr_writev.c (revision 95947) +++ head/lib/libpthread/thread/thr_writev.c (revision 95948) @@ -1,204 +1,216 @@ /* * Copyright (c) 1995-1998 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by John Birrell. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include #include #include "pthread_private.h" -__weak_reference(_writev, writev); +__weak_reference(__writev, writev); ssize_t _writev(int fd, const struct iovec * iov, int iovcnt) { struct pthread *curthread = _get_curthread(); int blocking; int idx = 0; int type; ssize_t cnt; ssize_t n; ssize_t num = 0; ssize_t ret; struct iovec liov[20]; struct iovec *p_iov = liov; /* Check if the array size exceeds to compiled in size: */ if (iovcnt > (sizeof(liov) / sizeof(struct iovec))) { /* Allocate memory for the local array: */ if ((p_iov = (struct iovec *) malloc(iovcnt * sizeof(struct iovec))) == NULL) { /* Insufficient memory: */ errno = ENOMEM; return (-1); } } /* Copy the caller's array so that it can be modified locally: */ memcpy(p_iov,iov,iovcnt * sizeof(struct iovec)); /* Lock the file descriptor for write: */ if ((ret = _FD_LOCK(fd, FD_WRITE, NULL)) == 0) { /* Get the read/write mode type: */ type = _thread_fd_table[fd]->flags & O_ACCMODE; /* Check if the file is not open for write: */ if (type != O_WRONLY && type != O_RDWR) { /* File is not open for write: */ errno = EBADF; _FD_UNLOCK(fd, FD_WRITE); return (-1); } /* Check if file operations are to block */ blocking = ((_thread_fd_table[fd]->flags & O_NONBLOCK) == 0); /* * Loop while no error occurs and until the expected number * of bytes are written if performing a blocking write: */ while (ret == 0) { /* Perform a non-blocking write syscall: */ n = __sys_writev(fd, &p_iov[idx], iovcnt - idx); /* Check if one or more bytes were written: */ if (n > 0) { /* * Keep a count of the number of bytes * written: */ num += n; /* * Enter a loop to check if a short write * occurred and move the index to the * array entry where the short write * ended: */ cnt = n; while (cnt > 0 && idx < iovcnt) { /* * If the residual count exceeds * the size of this vector, then * it was completely written: */ if (cnt >= p_iov[idx].iov_len) /* * Decrement the residual * count and increment the * index to the next array * entry: */ cnt -= p_iov[idx++].iov_len; else { /* * This entry was only * partially written, so * adjust it's length * and base pointer ready * for the next write: */ p_iov[idx].iov_len -= cnt; p_iov[idx].iov_base += cnt; cnt = 0; } } } else if (n == 0) { /* * Avoid an infinite loop if the last iov_len is * 0. */ while (idx < iovcnt && p_iov[idx].iov_len == 0) idx++; if (idx == iovcnt) { ret = num; break; } } /* * If performing a blocking write, check if the * write would have blocked or if some bytes * were written but there are still more to * write: */ if (blocking && ((n < 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) || (n >= 0 && idx < iovcnt))) { curthread->data.fd.fd = fd; _thread_kern_set_timeout(NULL); /* Reset the interrupted operation flag: */ curthread->interrupted = 0; _thread_kern_sched_state(PS_FDW_WAIT, __FILE__, __LINE__); /* * Check if the operation was * interrupted by a signal */ if (curthread->interrupted) { /* Return an error: */ ret = -1; } /* * If performing a non-blocking write or if an * error occurred, just return whatever the write * syscall did: */ } else if (!blocking || n < 0) { /* A non-blocking call might return zero: */ ret = n; break; /* Check if the write has completed: */ } else if (idx == iovcnt) /* Return the number of bytes written: */ ret = num; } _FD_UNLOCK(fd, FD_RDWR); } /* If memory was allocated for the array, free it: */ if (p_iov != liov) free(p_iov); return (ret); +} + +ssize_t +__writev(int fd, const struct iovec *iov, int iovcnt) +{ + ssize_t ret; + + _thread_enter_cancellation_point(); + ret = _writev(fd, iov, iovcnt); + _thread_leave_cancellation_point(); + + return ret; }