sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code

Remove sys_select[_intr]

Browse Source
This commit is contained in:
Volker Lendecke 2011-02-18 12:34:08 +01:00 committed by Volker Lendecke
parent 3254e39220
commit d163f5d67c
2 changed files with 0 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
lib/util/select.c
View File

@ -53,162 +53,6 @@ void sys_select_signal(char c)
errno = saved_errno; errno = saved_errno;
} }
/*******************************************************************
Like select() but avoids the signal race using a pipe
it also guuarantees that fds on return only ever contains bits set
for file descriptors that were readable.
********************************************************************/
int sys_select(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *tval)
{
int ret, saved_errno;
fd_set *readfds2, readfds_buf;
if (initialised != sys_getpid()) {
if (pipe(select_pipe) == -1)
{
DEBUG(0, ("sys_select: pipe failed (%s)\n",
strerror(errno)));
if (readfds != NULL)
FD_ZERO(readfds);
if (writefds != NULL)
FD_ZERO(writefds);
if (errorfds != NULL)
FD_ZERO(errorfds);
return -1;
}
/*
* These next two lines seem to fix a bug with the Linux
* 2.0.x kernel (and probably other UNIXes as well) where
* the one byte read below can block even though the
* select returned that there is data in the pipe and
* the pipe_written variable was incremented. Thanks to
* HP for finding this one. JRA.
*/
if(set_blocking(select_pipe[0],0)==-1)
smb_panic("select_pipe[0]: O_NONBLOCK failed");
if(set_blocking(select_pipe[1],0)==-1)
smb_panic("select_pipe[1]: O_NONBLOCK failed");
initialised = sys_getpid();
}
maxfd = MAX(select_pipe[0]+1, maxfd);
/* If readfds is NULL we need to provide our own set. */
if (readfds) {
readfds2 = readfds;
} else {
readfds2 = &readfds_buf;
FD_ZERO(readfds2);
}
FD_SET(select_pipe[0], readfds2);
errno = 0;
ret = select(maxfd,readfds2,writefds,errorfds,tval);
if (ret <= 0) {
FD_ZERO(readfds2);
if (writefds)
FD_ZERO(writefds);
if (errorfds)
FD_ZERO(errorfds);
} else if (FD_ISSET(select_pipe[0], readfds2)) {
char c;
saved_errno = errno;
if (read(select_pipe[0], &c, 1) == 1) {
pipe_read++;
/* Mark Weaver <mark-clist@npsl.co.uk> pointed out a critical
fix to ensure we don't lose signals. We must always
return -1 when the select pipe is set, otherwise if another
fd is also ready (so ret == 2) then we used to eat the
byte in the pipe and lose the signal. JRA.
*/
ret = -1;
#if 0
/* JRA - we can use this to debug the signal messaging... */
DEBUG(0,("select got %u signal\n", (unsigned int)c));
#endif
errno = EINTR;
} else {
FD_CLR(select_pipe[0], readfds2);
ret--;
errno = saved_errno;
}
}
return ret;
}
/*******************************************************************
Similar to sys_select() but catch EINTR and continue.
This is what sys_select() used to do in Samba.
********************************************************************/
int sys_select_intr(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *tval)
{
int ret;
fd_set *readfds2, readfds_buf, *writefds2, writefds_buf, *errorfds2, errorfds_buf;
struct timeval tval2, *ptval;
struct timespec end_time;
readfds2 = (readfds ? &readfds_buf : NULL);
writefds2 = (writefds ? &writefds_buf : NULL);
errorfds2 = (errorfds ? &errorfds_buf : NULL);
if (tval) {
clock_gettime_mono(&end_time);
end_time.tv_sec += tval->tv_sec;
end_time.tv_nsec += tval->tv_usec *1000;
end_time.tv_sec += end_time.tv_nsec / 1000000000;
end_time.tv_nsec %= 1000000000;
errno = 0;
tval2 = *tval;
ptval = &tval2;
} else {
ptval = NULL;
}
do {
if (readfds)
readfds_buf = *readfds;
if (writefds)
writefds_buf = *writefds;
if (errorfds)
errorfds_buf = *errorfds;
if (ptval && (errno == EINTR)) {
struct timespec now_time;
int64_t tdif;
clock_gettime_mono(&now_time);
tdif = nsec_time_diff(&end_time,&now_time);
if (tdif <= 0) {
ret = 0; /* time expired. */
break;
}
ptval->tv_sec = tdif / 1000000000;
ptval->tv_usec = (tdif % 1000000000) / 1000;
}
/* We must use select and not sys_select here. If we use
sys_select we'd lose the fact a signal occurred when sys_select
read a byte from the pipe. Fix from Mark Weaver
<mark-clist@npsl.co.uk>
*/
ret = select(maxfd, readfds2, writefds2, errorfds2, ptval);
} while (ret == -1 && errno == EINTR);
if (readfds)
*readfds = readfds_buf;
if (writefds)
*writefds = writefds_buf;
if (errorfds)
*errorfds = errorfds_buf;
return ret;
}
/* /*
* sys_poll expects pollfd's to be a talloc'ed array. * sys_poll expects pollfd's to be a talloc'ed array.
* *

2
lib/util/select.h
View File

@ -25,8 +25,6 @@
/* The following definitions come from lib/util/select.c */ /* The following definitions come from lib/util/select.c */
void sys_select_signal(char c); void sys_select_signal(char c);
int sys_select(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *tval);
int sys_select_intr(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *tval);
int sys_poll(struct pollfd *fds, int num_fds, int timeout); int sys_poll(struct pollfd *fds, int num_fds, int timeout);
int sys_poll_intr(struct pollfd *fds, int num_fds, int timeout); int sys_poll_intr(struct pollfd *fds, int num_fds, int timeout);