Attachment #151071 for bug #196354

Lines 49-54 bool malloc_mutex_init(malloc_mutex_t *mutex); Link Here

(-)b/contrib/jemalloc/include/jemalloc/internal/mutex.h (+1 lines)
49	void malloc_mutex_prefork(malloc_mutex_t *mutex);	49	void malloc_mutex_prefork(malloc_mutex_t *mutex);
50	void malloc_mutex_postfork_parent(malloc_mutex_t *mutex);	50	void malloc_mutex_postfork_parent(malloc_mutex_t *mutex);
51	void malloc_mutex_postfork_child(malloc_mutex_t *mutex);	51	void malloc_mutex_postfork_child(malloc_mutex_t *mutex);
		52	bool malloc_mutex_first_thread(void);
52	bool mutex_boot(void);	53	bool mutex_boot(void);
53		54
54	#endif /* JEMALLOC_H_EXTERNS */	55	#endif /* JEMALLOC_H_EXTERNS */

Lines 2061-2066 jemalloc_postfork_child(void) Link Here

(-)b/contrib/jemalloc/src/jemalloc.c (+7 lines)
2061	ctl_postfork_child();	2061	ctl_postfork_child();
2062	}	2062	}
2063		2063
		2064	void
		2065	_malloc_first_thread(void)
		2066	{
		2067
		2068	(void)malloc_mutex_first_thread();
		2069	}
		2070
2064	/******************************************************************************/	2071	/******************************************************************************/
2065	/*	2072	/*
2066	* The following functions are used for TLS allocation/deallocation in static	2073	* The following functions are used for TLS allocation/deallocation in static




JEMALLOC_EXPORT int	_pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
    void *(calloc_cb)(size_t, size_t));

#pragma weak _pthread_mutex_init_calloc_cb
    _pthread_mutex_init_calloc_cb);

int
_pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
    void *(calloc_cb)(size_t, size_t))
{

	return (((int (*)(pthread_mutex_t *, void *(*)(size_t, size_t)))
	    __libc_interposing[INTERPOS__pthread_mutex_init_calloc_cb])(
	   mutex, calloc_cb));
}
#endif


}

bool
malloc_mutex_first_thread(void)
{

#ifdef JEMALLOC_MUTEX_INIT_CB

#endif
	return (false);
}

bool
mutex_boot(void)
{

#ifndef JEMALLOC_MUTEX_INIT_CB
	return (malloc_mutex_first_thread());
#else
	return (false);
#endif
}

Lines 156-161 libkern.${LIBC_ARCH}:: ${KMSRCS} Link Here

(-)b/lib/libc/Makefile (+4 lines)
156	cp -fp ${.ALLSRC} ${DESTDIR}/sys/libkern/${LIBC_ARCH}	156	cp -fp ${.ALLSRC} ${DESTDIR}/sys/libkern/${LIBC_ARCH}
157	.endif	157	.endif
158		158
		159	.if ${MK_SYSCALL_COMPAT} != "no"
		160	CFLAGS+=-DSYSCALL_COMPAT
		161	.endif
		162
159	.include <bsd.arch.inc.mk>	163	.include <bsd.arch.inc.mk>
160		164
161	.include <bsd.lib.mk>	165	.include <bsd.lib.mk>

Lines 28-31 FBSD_1.2 { Link Here

(-)b/lib/libc/compat-43/Symbol.map (+1 lines)
28	FBSDprivate_1.0 {	28	FBSDprivate_1.0 {
29	__creat;	29	__creat;
30	_creat;	30	_creat;
		31	__libc_creat;
31	};	32	};

Lines 36-46 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/compat-43/creat.c (-4 / +16 lines)
36	#include "namespace.h"	36	#include "namespace.h"
37	#include <fcntl.h>	37	#include <fcntl.h>
38	#include "un-namespace.h"	38	#include "un-namespace.h"
		39	#include "libc_private.h"
39		40
		41	__weak_reference(__libc_creat, __creat);
		42	__weak_reference(__libc_creat, _creat);
		43
		44	#pragma weak creat
40	int	45	int
41	__creat(const char *path, mode_t mode)	46	creat(const char *path, mode_t mode)
42	{	47	{
43	return(_open(path, O_WRONLY\|O_CREAT\|O_TRUNC, mode));	48
		49	return (((int ()(const char , mode_t))
		50	__libc_interposing[INTERPOS_creat])(path, mode));
		51	}
		52
		53	int
		54	__libc_creat(const char *path, mode_t mode)
		55	{
		56
		57	return(__sys_open(path, O_WRONLY \| O_CREAT \| O_TRUNC, mode));
44	}	58	}
45	__weak_reference(__creat, creat);
46	__weak_reference(__creat, _creat);

Lines 5-10 Link Here

(-)b/lib/libc/gen/Makefile.inc (+1 lines)
5	.PATH: ${LIBC_SRCTOP}/${LIBC_ARCH}/gen ${LIBC_SRCTOP}/gen	5	.PATH: ${LIBC_SRCTOP}/${LIBC_ARCH}/gen ${LIBC_SRCTOP}/gen
6		6
7	SRCS+= __getosreldate.c \	7	SRCS+= __getosreldate.c \
		8	__pthread_mutex_init_calloc_cb_stub.c \
8	__xuname.c \	9	__xuname.c \
9	_once_stub.c \	10	_once_stub.c \
10	_pthread_stubs.c \	11	_pthread_stubs.c \




	_rtld_atfork_post;
	_rtld_error;		/* for private use */
	_rtld_get_stack_prot;
	_rtld_is_dlopened;
	_rtld_thread_init;	/* for private use */
	__elf_phdr_match_addr;
	_err;

	_libc_sem_post_compat;
	_libc_sem_getvalue_compat;

	__libc_pause;
	__libc_raise;
	__libc_system;
	__libc_sleep;
	__libc_tcdrain;
	__libc_usleep;
	__libc_wait;
	__libc_wait3;
	__libc_waitpid;

	__elf_aux_vector;
	__pthread_map_stacks_exec;
	__fillcontextx;




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <pthread.h>
#include "libc_private.h"

int
_pthread_mutex_init_calloc_cb_stub(pthread_mutex_t *mutex,
    void *(calloc_cb)(size_t, size_t))
{

	return (0);
}

Lines 233-235 _rtld_get_stack_prot(void) Link Here

(-)b/lib/libc/gen/dlfcn.c (+7 lines)
233	return (PROT_EXEC \| PROT_READ \| PROT_WRITE);	233	return (PROT_EXEC \| PROT_READ \| PROT_WRITE);
234	}	234	}
235		235
		236	#pragma weak _rtld_is_dlopened
		237	int
		238	_rtld_is_dlopened(void *arg)
		239	{
		240
		241	return (0);
		242	}

Lines 38-48 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/pause.c (-3 / +15 lines)
38	#include <unistd.h>	38	#include <unistd.h>
39	#include "un-namespace.h"	39	#include "un-namespace.h"
40		40
		41	#include "libc_private.h"
		42
41	/*	43	/*
42	* Backwards compatible pause.	44	* Backwards compatible pause.
43	*/	45	*/
44	int	46	int
45	__pause(void)	47	__libc_pause(void)
46	{	48	{
47	sigset_t oset;	49	sigset_t oset;
48		50
Lines 50-54 __pause(void) Link Here
50	return (-1);	52	return (-1);
51	return (_sigsuspend(&oset));	53	return (_sigsuspend(&oset));
52	}	54	}
53	__weak_reference(__pause, pause);	55
54	__weak_reference(__pause, _pause);	56	#pragma weak pause
		57	int
		58	pause(void)
		59	{
		60
		61	return (((int (*)(void))
		62	__libc_interposing[INTERPOS_pause])());
		63	}
		64
		65	__weak_reference(__libc_pause, __pause);
		66	__weak_reference(__libc_pause, _pause);




#include <signal.h>
#include <unistd.h>

#include "libc_private.h"
__weak_reference(__raise, _raise);

__weak_reference(__libc_raise, __raise);
__weak_reference(__libc_raise, _raise);

#pragma weak raise
int
raise(int s)
{

	return (((int (*)(int))
	    __libc_interposing[INTERPOS_raise])(s));
}

int
__libc_raise(int s)
{

	return (kill(getpid(), s));
}




#include <unistd.h>
#include "un-namespace.h"

#include "libc_private.h"

#pragma weak sleep
unsigned int
sleep(unsigned int seconds)
{

	return (((unsigned int (*)(unsigned int))
	    __libc_interposing[INTERPOS_sleep])(seconds));
}

unsigned int
__libc_sleep(unsigned int seconds)
{
	struct timespec time_to_sleep;
	struct timespec time_remaining;

	 * the maximum value for a time_t is >= INT_MAX.
	 */
	if (seconds > INT_MAX)
		return (seconds - INT_MAX + __libc_sleep(INT_MAX));

	time_to_sleep.tv_sec = seconds;
	time_to_sleep.tv_nsec = 0;

		(time_remaining.tv_nsec != 0)); /* round up */
}

__weak_reference(__libc_sleep, __sleep);
__weak_reference(__libc_sleep, _sleep);




/*
 * Copyright (c) 2001 Daniel M. Eischen <deischen@freebsd.org>
 * 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. Neither the name of the author nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/signal.h>
#include <sys/ucontext.h>

#include <errno.h>
#include <stddef.h>

__weak_reference(__swapcontext, swapcontext);

int
__swapcontext(ucontext_t *oucp, const ucontext_t *ucp)
{
	int ret;

	if ((oucp == NULL) || (ucp == NULL)) {
		errno = EINVAL;
		return (-1);
	}
	oucp->uc_flags &= ~UCF_SWAPPED;
	ret = getcontext(oucp);
	if ((ret == 0) && !(oucp->uc_flags & UCF_SWAPPED)) {
		oucp->uc_flags |= UCF_SWAPPED;
		ret = setcontext(ucp);
	}
	return (ret);
}

Lines 46-51 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/termios.c (-3 / +15 lines)
46	#include <unistd.h>	46	#include <unistd.h>
47	#include "un-namespace.h"	47	#include "un-namespace.h"
48		48
		49	#include "libc_private.h"
		50
49	int	51	int
50	tcgetattr(int fd, struct termios *t)	52	tcgetattr(int fd, struct termios *t)
51	{	53	{
Lines 208-220 tcsendbreak(int fd, int len __unused) Link Here
208	}	210	}
209		211
210	int	212	int
211	__tcdrain(int fd)	213	__libc_tcdrain(int fd)
212	{	214	{
		215
213	return (_ioctl(fd, TIOCDRAIN, 0));	216	return (_ioctl(fd, TIOCDRAIN, 0));
214	}	217	}
215		218
216	__weak_reference(__tcdrain, tcdrain);	219	#pragma weak tcdrain
217	__weak_reference(__tcdrain, _tcdrain);	220	int
		221	tcdrain(int fd)
		222	{
		223
		224	return (((int (*)(int))
		225	__libc_interposing[INTERPOS_tcdrain])(fd));
		226	}
		227
		228	__weak_reference(__libc_tcdrain, __tcdrain);
		229	__weak_reference(__libc_tcdrain, _tcdrain);
218		230
219	int	231	int
220	tcflush(int fd, int which)	232	tcflush(int fd, int which)




#include <unistd.h>
#include "un-namespace.h"

#include "libc_private.h"

#pragma weak usleep
int
usleep(useconds_t useconds)
{

	return (((int (*)(useconds_t))
	    __libc_interposing[INTERPOS_usleep])(useconds));
}

int
__libc_usleep(useconds_t useconds)
{
	struct timespec time_to_sleep;


	return (_nanosleep(&time_to_sleep, NULL));
}

__weak_reference(__libc_usleep, __usleep);
__weak_reference(__libc_usleep, _usleep);

Lines 40-50 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/wait.c (-4 / +16 lines)
40	#include <sys/resource.h>	40	#include <sys/resource.h>
41	#include "un-namespace.h"	41	#include "un-namespace.h"
42		42
		43	#include "libc_private.h"
		44
		45	#pragma weak wait
43	pid_t	46	pid_t
44	__wait(int *istat)	47	wait(int *istat)
45	{	48	{
46	return (_wait4(WAIT_ANY, istat, 0, (struct rusage *)0));	49
		50	return (((pid_t ()(int ))
		51	__libc_interposing[INTERPOS_wait])(istat));
		52	}
		53
		54	pid_t
		55	__libc_wait(int *istat)
		56	{
		57
		58	return (__sys_wait4(WAIT_ANY, istat, 0, NULL));
47	}	59	}
48		60
49	__weak_reference(__wait, wait);	61	__weak_reference(__libc_wait, __wait);
50	__weak_reference(__wait, _wait);	62	__weak_reference(__libc_wait, _wait);




#include <sys/resource.h>
#include "un-namespace.h"

#include "libc_private.h"

#pragma weak wait3
pid_t
wait3(int *istat, int options, struct rusage *rup)
{

	return (((pid_t (*)(int *, int, struct rusage *))
	    __libc_interposing[INTERPOS_wait3])(istat, options, rup));
}

__weak_reference(__libc_wait3, __wait3);

pid_t
__libc_wait3(int *istat, int options, struct rusage *rup)
	int *istat;
	int options;
	struct rusage *rup;
{

	return (__sys_wait4(WAIT_ANY, istat, options, rup));
}

Lines 40-50 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/waitpid.c (-4 / +16 lines)
40	#include <sys/resource.h>	40	#include <sys/resource.h>
41	#include "un-namespace.h"	41	#include "un-namespace.h"
42		42
		43	#include "libc_private.h"
		44
		45	#pragma weak waitpid
43	pid_t	46	pid_t
44	__waitpid(pid_t pid, int *istat, int options)	47	waitpid(pid_t pid, int *istat, int options)
45	{	48	{
46	return (_wait4(pid, istat, options, (struct rusage *)0));	49
		50	return (((pid_t ()(pid_t, int , int))
		51	__libc_interposing[INTERPOS_waitpid])(pid, istat, options));
		52	}
		53
		54	pid_t
		55	__libc_waitpid(pid_t pid, int *istat, int options)
		56	{
		57
		58	return (__sys_wait4(pid, istat, options, NULL));
47	}	59	}
48		60
49	__weak_reference(__waitpid, waitpid);	61	__weak_reference(__libc_waitpid, __waitpid);
50	__weak_reference(__waitpid, _waitpid);	62	__weak_reference(__libc_waitpid, _waitpid);





extern pthread_func_entry_t __thr_jtable[];

extern int *(*__error_selector)(void);
int	_pthread_mutex_init_calloc_cb_stub(pthread_mutex_t *mutex,
	    void *(calloc_cb)(__size_t, __size_t));

typedef int (*interpos_func_t)(void);
interpos_func_t *__libc_interposing_slot(int interposno);
extern interpos_func_t __libc_interposing[];

enum {
	INTERPOS_accept,
	INTERPOS_accept4,
	INTERPOS_aio_suspend,
	INTERPOS_close,
	INTERPOS_connect,
	INTERPOS_creat,
	INTERPOS_fcntl,
	INTERPOS_fsync,
	INTERPOS_msync,
	INTERPOS_nanosleep,
	INTERPOS_open,
	INTERPOS_openat,
	INTERPOS_poll,
	INTERPOS_pselect,
	INTERPOS_raise,
	INTERPOS_recvfrom,
	INTERPOS_recvmsg,
	INTERPOS_select,
	INTERPOS_sendmsg,
	INTERPOS_sendto,
	INTERPOS_setcontext,
	INTERPOS_sigaction,
	INTERPOS_sigprocmask,
	INTERPOS_sigsuspend,
	INTERPOS_sigwait,
	INTERPOS_sigtimedwait,
	INTERPOS_sigwaitinfo,
	INTERPOS_swapcontext,
	INTERPOS_system,
	INTERPOS_sleep,
	INTERPOS_tcdrain,
	INTERPOS_usleep,
	INTERPOS_pause,
	INTERPOS_read,
	INTERPOS_readv,
	INTERPOS_wait,
	INTERPOS_wait3,
	INTERPOS_wait4,
	INTERPOS_waitpid,
	INTERPOS_write,
	INTERPOS_writev,
	INTERPOS__pthread_mutex_init_calloc_cb,
	INTERPOS_MAX
};

/*
 * yplib internal interfaces
 */

void _malloc_prefork(void);
void _malloc_postfork(void);

void _malloc_first_thread(void);

/*
 * Function to clean up streams, called from abort() and exit().
 */
void (*__cleanup)(void) __hidden;

/*
 * Get kern.osreldate to detect ABI revisions.  Explicitly
 * ignores value of $OSVERSION and caches result.  Prototypes
 * for the wrapped "new" pad-less syscalls are here for now.
 */
int __getosreldate(void);
#include <sys/_types.h>
#include <sys/_sigset.h>
extern __off_t	__sys_lseek(int, __off_t, int);
extern int	__sys_ftruncate(int, __off_t);
extern int	__sys_truncate(const char *, __off_t);
extern __ssize_t __sys_pread(int, void *, __size_t, __off_t);
extern __ssize_t __sys_pwrite(int, const void *, __size_t, __off_t);
extern void *	__sys_mmap(void *, __size_t, int, int, int, __off_t);

/* With pad */
__off_t	__sys_freebsd6_lseek(int, int, __off_t, int);
int	__sys_freebsd6_ftruncate(int, int, __off_t);
int	__sys_freebsd6_truncate(const char *, int, __off_t);
__ssize_t __sys_freebsd6_pread(int, void *, __size_t, int, __off_t);
__ssize_t __sys_freebsd6_pwrite(int, const void *, __size_t, int, __off_t);
void *	__sys_freebsd6_mmap(void *, __size_t, int, int, int, int, __off_t);

/* Without back-compat translation */
extern int	__sys_fcntl(int, int, ...);

struct aiocb;
struct fd_set;
struct iovec;
struct msghdr;
struct pollfd;
struct rusage;
struct sigaction;
struct sockaddr;
struct timespec;
struct timeval;
struct timezone;
struct __siginfo;
struct __ucontext;
int		__sys_aio_suspend(const struct aiocb * const[], int,
		    const struct timespec *);
int		__sys_accept(int, struct sockaddr *, __socklen_t *);
int		__sys_accept4(int, struct sockaddr *, __socklen_t *, int);
int		__sys_clock_gettime(__clockid_t, struct timespec *ts);
int		__sys_close(int);
int		__sys_connect(int, const struct sockaddr *, __socklen_t);
int		__sys_fcntl(int, int, ...);
int		__sys_fsync(int);
int		__sys_ftruncate(int, __off_t);
int		__sys_gettimeofday(struct timeval *, struct timezone *);
__off_t		__sys_lseek(int, __off_t, int);
void	       *__sys_mmap(void *, __size_t, int, int, int, __off_t);
int		__sys_msync(void *, __size_t, int);
int		__sys_nanosleep(const struct timespec *, struct timespec *);
int		__sys_open(const char *, int, ...);
int		__sys_openat(int, const char *, int, ...);
int		__sys_pselect(int, struct fd_set *, struct fd_set *,
		    struct fd_set *, const struct timespec *,
		    const __sigset_t *);
int		__sys_poll(struct pollfd *, unsigned, int);
__ssize_t	__sys_pread(int, void *, __size_t, __off_t);
__ssize_t	__sys_pwrite(int, const void *, __size_t, __off_t);
__ssize_t	__sys_read(int, void *, __size_t);
__ssize_t	__sys_readv(int, const struct iovec *, int);
__ssize_t	__sys_recv(int, void *, __size_t, int);
__ssize_t	__sys_recvfrom(int, void *, __size_t, int, struct sockaddr *,
		    __socklen_t *);
__ssize_t	__sys_recvmsg(int, struct msghdr *, int);
int		__sys_select(int, struct fd_set *, struct fd_set *,
		    struct fd_set *, struct timeval *);
__ssize_t	__sys_sendmsg(int, const struct msghdr *, int);
__ssize_t	__sys_sendto(int, const void *, __size_t, int,
		    const struct sockaddr *, __socklen_t);
int		__sys_setcontext(const struct __ucontext *);
int		__sys_sigaction(int, const struct sigaction *,
		    struct sigaction *);
int		__sys_sigprocmask(int, const __sigset_t *, __sigset_t *);
int		__sys_sigsuspend(const __sigset_t *);
int		__sys_sigtimedwait(const __sigset_t *, struct __siginfo *,
		    const struct timespec *);
int		__sys_sigwait(const __sigset_t *, int *);
int		__sys_sigwaitinfo(const __sigset_t *, struct __siginfo *);
int		__sys_swapcontext(struct __ucontext *,
		    const struct __ucontext *);
int		__sys_truncate(const char *, __off_t);
__pid_t		__sys_wait4(__pid_t, int *, int, struct rusage *);
__ssize_t	__sys_write(int, const void *, __size_t);
__ssize_t	__sys_writev(int, const struct iovec *, int);

int		__libc_creat(const char *path, __mode_t mode);
int		__libc_pause(void);
int		__libc_raise(int);
int		__libc_sigwait(const __sigset_t * __restrict,
		    int * restrict sig);
int		__libc_system(const char *);
unsigned int	__libc_sleep(unsigned int);
int		__libc_tcdrain(int);
int		__libc_usleep(__useconds_t);
__pid_t		__libc_wait(int *);
__pid_t		__libc_wait3(int *, int, struct rusage *);
__pid_t		__libc_waitpid(__pid_t, int *, int);
int		__fcntl_compat(int fd, int cmd, ...);

/* execve() with PATH processing to implement posix_spawnp() */
int _execvpe(const char *, char * const *, char * const *);

Lines 118-121 FBSD_1.4 { Link Here

(-)b/lib/libc/stdlib/Symbol.map (+1 lines)
118	FBSDprivate_1.0 {	118	FBSDprivate_1.0 {
119	__system;	119	__system;
120	_system;	120	_system;
		121	__libc_system;
121	};	122	};

Lines 55-58 FBSDprivate_1.0 { Link Here

(-)b/lib/libc/stdlib/jemalloc/Symbol.map (+1 lines)
55	_malloc_thread_cleanup;	55	_malloc_thread_cleanup;
56	_malloc_prefork;	56	_malloc_prefork;
57	_malloc_postfork;	57	_malloc_postfork;
		58	_malloc_first_thread;
58	};	59	};




#include "un-namespace.h"
#include "libc_private.h"

#pragma weak system
int
system(const char *command)
{

	return (((int (*)(const char *))
	    __libc_interposing[INTERPOS_system])(command));
}

int
__libc_system(const char *command)
{
	pid_t pid, savedpid;
	int pstat;

	return(pid == -1 ? -1 : pstat);
}

__weak_reference(__libc_system, __system);
__weak_reference(__libc_system, _system);

Lines 20-36 NOASM+= clock_gettime.o gettimeofday.o Link Here

(-)b/lib/libc/sys/Makefile.inc (-7 / +50 lines)
20	PSEUDO+= _clock_gettime.o _gettimeofday.o	20	PSEUDO+= _clock_gettime.o _gettimeofday.o
21		21
22	# Sources common to both syscall interfaces:	22	# Sources common to both syscall interfaces:
23	SRCS+= stack_protector.c stack_protector_compat.c __error.c	23	SRCS+= \
		24	stack_protector.c \
		25	stack_protector_compat.c \
		26	__error.c \
		27	interposing_table.c
		28
24	.if ${MK_SYSCALL_COMPAT} != "no"	29	.if ${MK_SYSCALL_COMPAT} != "no"
25	SYSCALL_COMPAT_SRCS= fcntl.c ftruncate.c lseek.c mmap.c pread.c \	30	SYSCALL_COMPAT_SRCS= \
26	pwrite.c truncate.c	31	ftruncate.c \
		32	lseek.c \
		33	mmap.c \
		34	pread.c \
		35	pwrite.c \
		36	truncate.c
27	SRCS+= ${SYSCALL_COMPAT_SRCS}	37	SRCS+= ${SYSCALL_COMPAT_SRCS}
28	NOASM+= ${SYSCALL_COMPAT_SRCS:S/.c/.o/}	38	NOASM+= ${SYSCALL_COMPAT_SRCS:S/.c/.o/}
29	PSEUDO+= _fcntl.o
30	.endif	39	.endif
31	SRCS+= sigwait.c	40
32	NOASM+= sigwait.o	41	INTERPOSED = \
33	PSEUDO+= _sigwait.o	42	accept \
		43	accept4 \
		44	aio_suspend \
		45	close \
		46	connect \
		47	fcntl \
		48	fsync \
		49	msync \
		50	nanosleep \
		51	open \
		52	openat \
		53	poll \
		54	pselect \
		55	read \
		56	readv \
		57	recvfrom \
		58	recvmsg \
		59	select \
		60	sendmsg \
		61	sendto \
		62	setcontext \
		63	sigaction \
		64	sigprocmask \
		65	sigsuspend \
		66	sigtimedwait \
		67	sigwait \
		68	sigwaitinfo \
		69	swapcontext \
		70	wait4 \
		71	write \
		72	writev
		73
		74	SRCS+= ${INTERPOSED:S/$/.c/}
		75	NOASM+= ${INTERPOSED:S/$/.o/}
		76	PSEUDO+= ${INTERPOSED:C/^.*$/_&.o/}
34		77
35	# Add machine dependent asm sources:	78	# Add machine dependent asm sources:
36	SRCS+=${MDASM}	79	SRCS+=${MDASM}

Lines 1046-1054 FBSDprivate_1.0 { Link Here

(-)b/lib/libc/sys/Symbol.map (+4 lines)
1046	__sys_wait6;	1046	__sys_wait6;
1047	_write;	1047	_write;
1048	__sys_write;	1048	__sys_write;
		1049	__write_p;
1049	_writev;	1050	_writev;
1050	__sys_writev;	1051	__sys_writev;
1051	__error_unthreaded;	1052	__error_unthreaded;
		1053	__error_selector;
1052	nlm_syscall;	1054	nlm_syscall;
1053	gssd_syscall;	1055	gssd_syscall;
		1056	__libc_interposing_slot;
		1057	__libc_sigwait;
1054	};	1058	};





extern int errno;

/*
 * Declare a weak reference in case the application is not linked
 * with libpthread.
 */
__weak_reference(__error_unthreaded, __error);

int *
__error_unthreaded(void)
{
	return(&errno);
}

int *(*__error_selector)(void) = __error_unthreaded;

int *
__error(void)
{

	return (__error_selector());
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include "libc_private.h"

__weak_reference(__sys_accept, __accept);

#pragma weak accept
int
accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{

	return (((int (*)(int, struct sockaddr *, socklen_t *))
	    __libc_interposing[INTERPOS_accept])(s, addr, addrlen));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include "libc_private.h"

__weak_reference(__sys_accept4, __accept4);

#pragma weak accept4
int
accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags)
{

	return (((int (*)(int, struct sockaddr *, socklen_t *, int))
	    __libc_interposing[INTERPOS_accept4])(s, addr, addrlen, flags));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/aio.h>
#include "libc_private.h"

__weak_reference(__sys_aio_suspend, __aio_suspend);

#pragma weak aio_suspend
int
aio_suspend(const struct aiocb * const iocbs[], int niocb,
    const struct timespec *timeout)
{

	return (((int (*)(const struct aiocb * const[], int,
	    const struct timespec *))
	    __libc_interposing[INTERPOS_aio_suspend])(iocbs, niocb, timeout));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/fcntl.h>
#include "libc_private.h"

__weak_reference(__sys_close, __close);

#pragma weak close
int
close(int fd)
{

	return (((int (*)(int))__libc_interposing[INTERPOS_close])(fd));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include "libc_private.h"

__weak_reference(__sys_connect, __connect);

#pragma weak connect
int
connect(int s, const struct sockaddr *addr, socklen_t addrlen)
{

	return (((int (*)(int, const struct sockaddr *, socklen_t))
	    __libc_interposing[INTERPOS_connect])(s, addr, addrlen));
}




#include <sys/syscall.h>
#include "libc_private.h"

#pragma weak fcntl
int
fcntl(int fd, int cmd, ...)
{
	va_list args;
	long arg;

	va_start(args, cmd);
	arg = va_arg(args, long);
	va_end(args);

	return (((int (*)(int, int, ...))
	    __libc_interposing[INTERPOS_fcntl])(fd, cmd, arg));
}

#ifdef SYSCALL_COMPAT
__weak_reference(__fcntl_compat, __fcntl);

int
__fcntl_compat(int fd, int cmd, ...)

		return (__sys_fcntl(fd, cmd, arg));
	}
}
#else
__weak_reference(__sys_fcntl, __fcntl_compat);
__weak_reference(__sys_fcntl, __fcntl);
#endif




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/fcntl.h>
#include "libc_private.h"

__weak_reference(__sys_fsync, __fsync);

int
fsync(int fd)
{

	return (((int (*)(int))__libc_interposing[INTERPOS_fsync])(fd));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include "libc_private.h"

#define	SLOT(a, b) \
	[INTERPOS_##a] = (interpos_func_t)b
interpos_func_t __libc_interposing[INTERPOS_MAX] = {
	SLOT(accept, __sys_accept),
	SLOT(accept4, __sys_accept4),
	SLOT(aio_suspend, __sys_aio_suspend),
	SLOT(close, __sys_close),
	SLOT(connect, __sys_connect),
	SLOT(creat, __libc_creat),
	SLOT(fcntl, __fcntl_compat),
	SLOT(fsync, __sys_fsync),
	SLOT(msync, __sys_msync),
	SLOT(nanosleep, __sys_nanosleep),
	SLOT(open, __sys_open),
	SLOT(openat, __sys_openat),
	SLOT(poll, __sys_poll),
	SLOT(pselect, __sys_pselect),
	SLOT(raise, __libc_raise),
	SLOT(read, __sys_read),
	SLOT(readv, __sys_readv),
	SLOT(recvfrom, __sys_recvfrom),
	SLOT(recvmsg, __sys_recvmsg),
	SLOT(select, __sys_select),
	SLOT(sendmsg, __sys_sendmsg),
	SLOT(sendto, __sys_sendto),
	SLOT(setcontext, __sys_setcontext),
	SLOT(sigaction, __sys_sigaction),
	SLOT(sigprocmask, __sys_sigprocmask),
	SLOT(sigsuspend, __sys_sigsuspend),
	SLOT(sigwait, __libc_sigwait),
	SLOT(sigtimedwait, __sys_sigtimedwait),
	SLOT(sigwaitinfo, __sys_sigwaitinfo),
	SLOT(swapcontext, __sys_swapcontext),
	SLOT(system, __libc_system),
	SLOT(sleep, __libc_sleep),
	SLOT(tcdrain, __libc_tcdrain),
	SLOT(usleep, __libc_usleep),
	SLOT(pause, __libc_pause),
	SLOT(wait, __libc_wait),
	SLOT(wait3, __libc_wait3),
	SLOT(wait4, __sys_wait4),
	SLOT(waitpid, __libc_waitpid),
	SLOT(write, __sys_write),
	SLOT(writev, __sys_writev),
	SLOT(_pthread_mutex_init_calloc_cb, _pthread_mutex_init_calloc_cb_stub),
};
#undef SLOT

interpos_func_t *
__libc_interposing_slot(int interposno)
{

	return (&__libc_interposing[interposno]);
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/fcntl.h>
#include "libc_private.h"

__weak_reference(__sys_msync, __msync);

#pragma weak msync
int
msync(void *addr, size_t len, int flags)
{

	return (((int (*)(void *, size_t, int))
	    __libc_interposing[INTERPOS_msync])(addr, len, flags));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <time.h>
#include "libc_private.h"

__weak_reference(__sys_nanosleep, __nanosleep);

#pragma weak nanosleep
int
nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
{

	return (((int (*)(const struct timespec *, struct timespec *))
	    __libc_interposing[INTERPOS_nanosleep])(rqtp, rmtp));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/fcntl.h>
#include <stdarg.h>
#include "libc_private.h"

__weak_reference(__sys_open, __open);

#pragma weak open
int
open(const char *path, int flags, ...)
{
	va_list ap;
	int mode;

	if ((flags & O_CREAT) != 0) {
		va_start(ap, flags);
		mode = va_arg(ap, int);
		va_end(ap);
	} else {
		mode = 0;
	}
	return (((int (*)(const char *, int, ...))
	    __libc_interposing[INTERPOS_open])(path, flags, mode));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/fcntl.h>
#include <stdarg.h>
#include "libc_private.h"

__weak_reference(__sys_openat, __openat);

#pragma weak openat
int
openat(int fd, const char *path, int flags, ...)
{
	va_list ap;
	int mode;

	if ((flags & O_CREAT) != 0) {
		va_start(ap, flags);
		mode = va_arg(ap, int);
		va_end(ap);
	} else {
		mode = 0;
	}
	return (((int (*)(int, const char *, int, ...))
	    __libc_interposing[INTERPOS_openat])(fd, path, flags, mode));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/poll.h>
#include "libc_private.h"

__weak_reference(__sys_poll, __poll);

#pragma weak poll
int
poll(struct pollfd pfd[], nfds_t nfds, int timeout)
{

	return (((int (*)(struct pollfd *, nfds_t, int))
	    __libc_interposing[INTERPOS_poll])(pfd, nfds, timeout));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/select.h>
#include "libc_private.h"

__weak_reference(__sys_pselect, __pselect);

#pragma weak pselect
int
pselect(int n, fd_set *rs, fd_set *ws, fd_set *es, const struct timespec *t,
    const sigset_t *s)
{

	return (((int (*)(int, fd_set *, fd_set *, fd_set *,
	    const struct timespec *, const sigset_t *))
	    __libc_interposing[INTERPOS_pselect])(n, rs, ws, es, t, s));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <unistd.h>
#include "libc_private.h"

__weak_reference(__sys_read, __read);

#pragma weak read
ssize_t
read(int fd, void *buf, size_t nbytes)
{

	return (((ssize_t (*)(int, void *, size_t))
	    __libc_interposing[INTERPOS_read])(fd, buf, nbytes));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <unistd.h>
#include "libc_private.h"

__weak_reference(__sys_readv, __readv);

#pragma weak readv
ssize_t
readv(int fd, const struct iovec *iov, int iovcnt)
{

	return (((ssize_t (*)(int, const struct iovec *, int))
	    __libc_interposing[INTERPOS_readv])(fd, iov, iovcnt));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include "libc_private.h"

__weak_reference(__sys_recvfrom, __recvfrom);

#pragma weak recvfrom
ssize_t
recvfrom(int s, void *buf, size_t len, int flags,
    struct sockaddr * __restrict from, socklen_t * __restrict fromlen)
{

	return (((ssize_t (*)(int, void *, size_t, int,
	    struct sockaddr *, socklen_t *))
	    __libc_interposing[INTERPOS_recvfrom])(s, buf, len, flags,
	   from, fromlen));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include "libc_private.h"

__weak_reference(__sys_recvmsg, __recvmsg);

#pragma weak recvmsg
ssize_t
recvmsg(int s, struct msghdr *msg, int flags)
{

	return (((int (*)(int, struct msghdr *, int))
	    __libc_interposing[INTERPOS_recvmsg])(s, msg, flags));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/select.h>
#include "libc_private.h"

__weak_reference(__sys_select, __select);

#pragma weak select
int
select(int n, fd_set *rs, fd_set *ws, fd_set *es, struct timeval *t)
{

	return (((int (*)(int, fd_set *, fd_set *, fd_set *, struct timeval *))
	    __libc_interposing[INTERPOS_select])(n, rs, ws, es, t));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include "libc_private.h"

__weak_reference(__sys_sendmsg, __sendmsg);

#pragma weak sendmsg
ssize_t
sendmsg(int s, const struct msghdr *msg, int flags)
{

	return (((int (*)(int, const struct msghdr *, int))
	    __libc_interposing[INTERPOS_sendmsg])(s, msg, flags));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include "libc_private.h"

__weak_reference(__sys_sendto, __sendto);

#pragma weak sendto
ssize_t
sendto(int s, const void *msg, size_t len, int flags,
    const struct sockaddr *to, socklen_t tolen)
{

	return (((ssize_t (*)(int, const void *, size_t, int,
	    const struct sockaddr *, socklen_t))
	    __libc_interposing[INTERPOS_sendto])(s, msg, len, flags,
	    to, tolen));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <ucontext.h>
#include "libc_private.h"

__weak_reference(__sys_setcontext, __setcontext);

#pragma weak setcontext
int
setcontext(const ucontext_t *uc)
{

	return (((int (*)(const ucontext_t *))
	    __libc_interposing[INTERPOS_setcontext])(uc));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <signal.h>
#include "libc_private.h"

__weak_reference(__sys_sigaction, __sigaction);

#pragma weak sigaction
int
sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
{

	return (((int (*)(int, const struct sigaction *, struct sigaction *))
	    __libc_interposing[INTERPOS_sigaction])(sig, act, oact));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <signal.h>
#include "libc_private.h"

__weak_reference(__sys_sigprocmask, __sigprocmask);

#pragma weak sigprocmask
int
sigprocmask(int how, const sigset_t *set, sigset_t *oset)
{

	return (((int (*)(int, const sigset_t *, sigset_t *))
	    __libc_interposing[INTERPOS_sigprocmask])(how, set, oset));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <signal.h>
#include "libc_private.h"

__weak_reference(__sys_sigsuspend, __sigsuspend);

#pragma weak sigsuspend
int
sigsuspend(const sigset_t *set)
{

	return (((int (*)(const sigset_t *))
	    __libc_interposing[INTERPOS_sigsuspend])(set));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <signal.h>
#include "libc_private.h"

__weak_reference(__sys_sigtimedwait, __sigtimedwait);

#pragma weak sigtimedwait
int
sigtimedwait(const sigset_t * __restrict set, siginfo_t * __restrict info,
    const struct timespec * __restrict t)
{

	return (((int (*)(const sigset_t *, siginfo_t *,
	    const struct timespec *))
	    __libc_interposing[INTERPOS_sigtimedwait])(set, info, t));
}





#include <errno.h>
#include <signal.h>
#include "libc_private.h"

__weak_reference(__libc_sigwait, __sigwait);

#pragma weak sigwait
int
sigwait(const sigset_t *set, int *sig)
{

	return (((int (*)(const sigset_t *, int *))
	    __libc_interposing[INTERPOS_sigwait])(set, sig));
}

int
__libc_sigwait(const sigset_t *set, int *sig)
{
	int ret;





/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <signal.h>
#include "libc_private.h"

__weak_reference(__sys_sigwaitinfo, __sigwaitinfo);

#pragma weak sigwaitinfo
int
sigwaitinfo(const sigset_t * __restrict set, siginfo_t * __restrict info)
{

	return (((int (*)(const sigset_t *, siginfo_t *))
	    __libc_interposing[INTERPOS_sigwaitinfo])(set, info));
}




/*
 * Copyright (c) 2001 Daniel M. Eischen <deischen@freebsd.org>
 * 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. Neither the name of the author nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/signal.h>
#include <sys/ucontext.h>
#include <errno.h>
#include <stddef.h>
#include "libc_private.h"

__weak_reference(__sys_swapcontext, __swapcontext);

#pragma weak swapcontext
int
swapcontext(ucontext_t *oucp, const ucontext_t *ucp)
{

	return (((int (*)(ucontext_t *, const ucontext_t *))
	    __libc_interposing[INTERPOS_swapcontext])(oucp, ucp));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/wait.h>
#include "libc_private.h"

__weak_reference(__sys_wait4, __wait4);

#pragma weak wait4
pid_t
wait4(pid_t pid, int *status, int options, struct rusage *ru)
{

	return (((pid_t (*)(pid_t, int *, int, struct rusage *))
	    __libc_interposing[INTERPOS_wait4])(pid, status, options, ru));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <unistd.h>
#include "libc_private.h"

__weak_reference(__sys_write, __write);

#pragma weak write
ssize_t
write(int fd, const void *buf, size_t nbytes)
{

	return (((ssize_t (*)(int, const void *, size_t))
	    __libc_interposing[INTERPOS_write])(fd, buf, nbytes));
}




/*
 * Copyright (c) 2014 The FreeBSD Foundation.
 * All rights reserved.
 *
 * Portions of this software were developed by Konstantin Belousov
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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(s), this list of conditions and the following disclaimer as
 *    the first lines of this file unmodified other than the possible
 *    addition of one or more copyright notices.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice(s), this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``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 COPYRIGHT HOLDER(S) 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>
#include <sys/syscall.h>
#include <unistd.h>
#include "libc_private.h"

__weak_reference(__sys_writev, __writev);

#pragma weak writev
ssize_t
writev(int fd, const struct iovec *iov, int iovcnt)
{

	return (((ssize_t (*)(int, const struct iovec *, int))
	    __libc_interposing[INTERPOS_writev])(fd, iov, iovcnt));
}

Lines 40-46 MAN= libthr.3 Link Here

(-)b/lib/libthr/Makefile (-1 lines)
40		40
41	# enable extra internal consistancy checks	41	# enable extra internal consistancy checks
42	CFLAGS+=-D_PTHREADS_INVARIANTS	42	CFLAGS+=-D_PTHREADS_INVARIANTS
43	#CFLAGS+=-g
44		43
45	PRECIOUSLIB=	44	PRECIOUSLIB=
46		45




 * Use the same naming scheme as libc.
 */
FBSD_1.0 {
	__error;
	accept;
	aio_suspend;
	close;
	connect;
	creat;
	execve;
	fcntl;
	fork;
	fsync;
	msync;
	nanosleep;
	open;
	pause;
	poll;
	pselect;
	pthread_atfork;
	pthread_barrier_destroy;
	pthread_barrier_init;

	pthread_testcancel;
	pthread_timedjoin_np;
	pthread_yield;
	raise;
	read;
	readv;
	recvfrom;
	recvmsg;
	select;
	sendmsg;
	sendto;
	sigaction;
	sigprocmask;
	sigsuspend;
	sigwait;
	sigwaitinfo;
	sigtimedwait;
	sleep;
	system;
	tcdrain;
	usleep;
	wait;
	wait3;
	wait4;
	waitpid;
	write;
	writev;
};

/*

 * These are not part of our application ABI.
 */
FBSDprivate_1.0 {
	___creat;
	___pause;
	___pselect;
	___sigwait;
	___sleep;
	___system;
	___tcdrain;
	___usleep;
	___wait;
	___waitpid;
	__accept;
	__accept4;
	__aio_suspend;
	__close;
	__connect;
	__fcntl;
	__fsync;
	__msync;
	__nanosleep;
	__open;
	__openat;
	__poll;
	__pthread_cond_timedwait;
	__pthread_cond_wait;
	__pthread_cxa_finalize;

	__pthread_mutex_lock;
	__pthread_mutex_timedlock;
	__pthread_mutex_trylock;
	__read;
	__readv;
	__recvfrom;
	__recvmsg;
	__select;
	__sendmsg;
	__sendto;
	__sigsuspend;
	__sigtimedwait;
	__sigwaitinfo;
	__wait3;
	__wait4;
	__write;
	__writev;
	_fork;
	_pthread_atfork;
	_pthread_barrier_destroy;
	_pthread_barrier_init;

	_pthread_testcancel;
	_pthread_timedjoin_np;
	_pthread_yield;
	_raise;
	_setcontext;
	_sigaction;
	_sigprocmask;
	_sigsuspend;
	_sigtimedwait;
	_sigwait;
	_sigwaitinfo;
	_spinlock;
	_spinlock_debug;
	_spinunlock;
	_swapcontext;

	/* Debugger needs these. */
	_libthr_debug;

};

FBSD_1.2 {
	openat;
	pthread_getthreadid_np;
	setcontext;
	swapcontext;
};

FBSD_1.3 {
	accept4;
};

Lines 42-49 Link Here

(-)b/lib/libthr/sys/thr_error.c (-1 / +2 lines)
42	#undef errno	42	#undef errno
43	extern int errno;	43	extern int errno;
44		44
		45	__weak_reference(__error_threaded, __error);
45	int *	46	int *
46	__error(void)	47	__error_threaded(void)
47	{	48	{
48	struct pthread *curthread;	49	struct pthread *curthread;
49		50

Lines 40-45 Link Here

(-)b/lib/libthr/thread/thr_create.c (-2 / +6 lines)
40	#include <pthread_np.h>	40	#include <pthread_np.h>
41	#include "un-namespace.h"	41	#include "un-namespace.h"
42		42
		43	#include "libc_private.h"
43	#include "thr_private.h"	44	#include "thr_private.h"
44		45
45	static int create_stack(struct pthread_attr *pattr);	46	static int create_stack(struct pthread_attr *pattr);
Lines 66-73 _pthread_create(pthread_t * thread, const pthread_attr_t * attr, Link Here
66	/*	67	/*
67	* Tell libc and others now they need lock to protect their data.	68	* Tell libc and others now they need lock to protect their data.
68	*/	69	*/
69	if (_thr_isthreaded() == 0 && _thr_setthreaded(1))	70	if (_thr_isthreaded() == 0) {
70	return (EAGAIN);	71	_malloc_first_thread();
		72	if (_thr_setthreaded(1))
		73	return (EAGAIN);
		74	}
71		75
72	curthread = _get_curthread();	76	curthread = _get_curthread();
73	if ((new_thread = _thr_alloc(curthread)) == NULL)	77	if ((new_thread = _thr_alloc(curthread)) == NULL)




#include <sys/types.h>
#include <sys/signalvar.h>
#include <sys/ioctl.h>
#include <sys/link_elf.h>
#include <sys/resource.h>
#include <sys/sysctl.h>
#include <sys/ttycom.h>

void
_libpthread_init(struct pthread *curthread)
{
	int fd, first, dlopened;

	/* Check if this function has already been called: */
	if ((_thr_initial != NULL) && (curthread == NULL))

	if (sizeof(jmp_table) != (sizeof(pthread_func_t) * PJT_MAX * 2))
		PANIC("Thread jump table not properly initialized");
	memcpy(__thr_jtable, jmp_table, sizeof(jmp_table));
	__thr_interpose_libc();

	/*
	 * Check for the special case of this process running as

		if (curthread == NULL)
			PANIC("Can't allocate initial thread");
		init_main_thread(curthread);
	} else {
		first = 0;
	}
		
	/*
	 * Add the thread to the thread list queue.
	 */


	if (first) {
		_thr_initial = curthread;
		dlopened = _rtld_is_dlopened(&_thread_autoinit_dummy_decl) != 0;
		_thr_signal_init(dlopened);
		if (_thread_event_mask & TD_CREATE)
			_thr_report_creation(curthread, curthread);
		/*

Lines 31-36 Link Here

(-)b/lib/libthr/thread/thr_printf.c (+1 lines)
31	#include <unistd.h>	31	#include <unistd.h>
32	#include <pthread.h>	32	#include <pthread.h>
33		33
		34	#include "libc_private.h"
34	#include "thr_private.h"	35	#include "thr_private.h"
35		36
36	static void pchar(int fd, char c);	37	static void pchar(int fd, char c);




void	_thr_testcancel(struct pthread *) __hidden;
void	_thr_signal_block(struct pthread *) __hidden;
void	_thr_signal_unblock(struct pthread *) __hidden;
void	_thr_signal_init(int) __hidden;
void	_thr_signal_deinit(void) __hidden;
int	_thr_send_sig(struct pthread *, int sig) __hidden;
void	_thr_list_init(void) __hidden;

int	__sys_fork(void);
pid_t	__sys_getpid(void);
ssize_t __sys_read(int, void *, size_t);
ssize_t __sys_write(int, const void *, size_t);
void	__sys_exit(int);
#endif


void	_sleepq_drop(struct sleepqueue *,
		void (*cb)(struct pthread *, void *arg), void *) __hidden;

int	_pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
	    void *(calloc_cb)(size_t, size_t));

struct dl_phdr_info;
void __pthread_cxa_finalize(struct dl_phdr_info *phdr_info);
void _thr_tsd_unload(struct dl_phdr_info *phdr_info) __hidden;
void _thr_sigact_unload(struct dl_phdr_info *phdr_info) __hidden;
void _thr_stack_fix_protection(struct pthread *thrd);

int *__error_threaded(void);
void __thr_interpose_libc(void) __hidden;
int __thr_pause(void) __hidden;
int __thr_raise(int sig);
int __thr_setcontext(const ucontext_t *ucp);
int __thr_sigaction(int sig, const struct sigaction *act,
    struct sigaction *oact) __hidden;
int __thr_sigprocmask(int how, const sigset_t *set, sigset_t *oset);
int __thr_sigsuspend(const sigset_t * set);
int __thr_sigtimedwait(const sigset_t *set, siginfo_t *info,
    const struct timespec * timeout);
int __thr_sigwait(const sigset_t *set, int *sig);
int __thr_sigwaitinfo(const sigset_t *set, siginfo_t *info);
int __thr_swapcontext(ucontext_t *oucp, const ucontext_t *ucp);

__END_DECLS

#endif  /* !_THR_PRIVATE_H */




#include "un-namespace.h"
#include "libc_private.h"

#include "libc_private.h"
#include "thr_private.h"

/* #define DEBUG_SIGNAL */


static struct usigaction _thr_sigact[_SIG_MAXSIG];

static inline struct usigaction *
__libc_sigaction_slot(int signo)
{

	return (&_thr_sigact[signo - 1]);
}

static void thr_sighandler(int, siginfo_t *, void *);
static void handle_signal(struct sigaction *, int, siginfo_t *, ucontext_t *);
static void check_deferred_signal(struct pthread *);
static void check_suspend(struct pthread *);
static void check_cancel(struct pthread *curthread, ucontext_t *ucp);

int	___pause(void);
int	_raise(int);
int	__sigtimedwait(const sigset_t *set, siginfo_t *info,
	const struct timespec * timeout);
int	_sigtimedwait(const sigset_t *set, siginfo_t *info,
	const struct timespec * timeout);
int	__sigwaitinfo(const sigset_t *set, siginfo_t *info);
int	_sigwaitinfo(const sigset_t *set, siginfo_t *info);
int	___sigwait(const sigset_t *set, int *sig);
int	_sigwait(const sigset_t *set, int *sig);
int	__sigsuspend(const sigset_t *sigmask);
int	_sigaction(int, const struct sigaction *, struct sigaction *);
int	_setcontext(const ucontext_t *);
int	_swapcontext(ucontext_t *, const ucontext_t *);


	errno = err;
}

typedef void (*ohandler)(int sig, int code, struct sigcontext *scp,
    char *addr, __sighandler_t *catcher);

/*
 * The signal handler wrapper is entered with all signal masked.

static void
thr_sighandler(int sig, siginfo_t *info, void *_ucp)
{
	struct pthread *curthread;
	ucontext_t *ucp;
	struct sigaction act;
	struct usigaction *usa;
	int err;

	err = errno;
	curthread = _get_curthread();
	ucp = _ucp;
	usa = __libc_sigaction_slot(sig);
	_thr_rwl_rdlock(&usa->lock);
	act = usa->sigact;
	_thr_rwl_unlock(&usa->lock);
	errno = err;
	curthread->deferred_run = 0;


	 * so after setjmps() returns once more, the user code may need to
	 * re-set cancel_enable flag by calling pthread_setcancelstate().
	 */
	if ((actp->sa_flags & SA_SIGINFO) != 0) {
		sigfunc(sig, info, ucp);
	} else {
		((ohandler)sigfunc)(sig, info->si_code,
		    (struct sigcontext *)ucp, info->si_addr,
		    (__sighandler_t *)sigfunc);
	}
	err = errno;


}

void
_thr_signal_init(int dlopened)
{
	struct sigaction act, nact, oact;
	struct usigaction *usa;
	sigset_t oldset;
	int sig, error;

	if (dlopened) {
		__sys_sigprocmask(SIG_SETMASK, &_thr_maskset, &oldset);
		for (sig = 1; sig <= _SIG_MAXSIG; sig++) {
			if (sig == SIGCANCEL)
				continue;
			error = __sys_sigaction(sig, NULL, &oact);
			if (error == -1 || oact.sa_handler == SIG_DFL ||
			    oact.sa_handler == SIG_IGN)
				continue;
			usa = __libc_sigaction_slot(sig);
			usa->sigact = oact;
			nact = oact;
			remove_thr_signals(&usa->sigact.sa_mask);
			nact.sa_flags &= ~SA_NODEFER;
			nact.sa_flags |= SA_SIGINFO;
			nact.sa_sigaction = thr_sighandler;
			nact.sa_mask = _thr_maskset;
			(void)__sys_sigaction(sig, &nact, NULL);
		}
		__sys_sigprocmask(SIG_SETMASK, &oldset, NULL);
	}

	/* Install SIGCANCEL handler. */
	SIGFILLSET(act.sa_mask);

	struct pthread *curthread = _get_curthread();
	struct urwlock *rwlp;
	struct sigaction *actp;
	struct usigaction *usa;
	struct sigaction kact;
	void (*handler)(int);
	int sig;
 
	_thr_signal_block(curthread);
	for (sig = 1; sig <= _SIG_MAXSIG; sig++) {
		usa = __libc_sigaction_slot(sig);
		actp = &usa->sigact;
retry:
		handler = actp->sa_handler;
		if (handler != SIG_DFL && handler != SIG_IGN &&
		    __elf_phdr_match_addr(phdr_info, handler)) {
			rwlp = &usa->lock;
			_thr_rwl_wrlock(rwlp);
			if (handler != actp->sa_handler) {
				_thr_rwl_unlock(rwlp);

	int i;

	for (i = 1; i <= _SIG_MAXSIG; ++i)
		_thr_rwl_rdlock(&__libc_sigaction_slot(i)->lock);
}

void

	int i;

	for (i = 1; i <= _SIG_MAXSIG; ++i)
		_thr_rwl_unlock(&__libc_sigaction_slot(i)->lock);
}

void

{
	int i;

	for (i = 1; i <= _SIG_MAXSIG; ++i) {
		bzero(&__libc_sigaction_slot(i) -> lock,
		    sizeof(struct urwlock));
	}
}

void

{
}

__weak_reference(___pause, pause);

int
__thr_pause(void)
{
	sigset_t oset;

	if (_sigprocmask(SIG_BLOCK, NULL, &oset) == -1)
		return (-1);
	return (__thr_sigsuspend(&oset));
}

__weak_reference(_raise, raise);

int
__thr_raise(int sig)
{
	return _thr_send_sig(_get_curthread(), sig);
}

	return (_thr_send_sig(_get_curthread(), sig));
}

int
__thr_sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
{
	struct sigaction newact, oldact, oldact2;
	sigset_t oldset;
	struct usigaction *usa;
	int ret, err;

	if (!_SIG_VALID(sig) || sig == SIGCANCEL) {
		errno = EINVAL;
		return (-1);
	}

	ret = 0;
	err = 0;
	usa = __libc_sigaction_slot(sig);

	__sys_sigprocmask(SIG_SETMASK, &_thr_maskset, &oldset);
	_thr_rwl_wrlock(&usa->lock);
 
	if (act != NULL) {
		oldact2 = usa->sigact;
		newact = *act;

 		/*
		 * if a new sig handler is SIG_DFL or SIG_IGN,
		 * don't remove old handler from __libc_sigact[],
		 * so deferred signals still can use the handlers,
		 * multiple threads invoking sigaction itself is
		 * a race condition, so it is not a problem.
		 */
		if (newact.sa_handler != SIG_DFL &&
		    newact.sa_handler != SIG_IGN) {
			usa->sigact = newact;
			remove_thr_signals(&usa->sigact.sa_mask);
				&_thr_sigact[sig-1].sigact.sa_mask);
			newact.sa_flags &= ~SA_NODEFER;
			newact.sa_flags |= SA_SIGINFO;
			newact.sa_sigaction = thr_sighandler;
			newact.sa_mask = _thr_maskset; /* mask all signals */
		}
		ret = __sys_sigaction(sig, &newact, &oldact);
		if (ret == -1) {
			err = errno;
			usa->sigact = oldact2;
		}
	} else if (oact != NULL) {
		ret = __sys_sigaction(sig, NULL, &oldact);
		err = errno;
	}

	if (oldact.sa_handler != SIG_DFL && oldact.sa_handler != SIG_IGN) {
	    oldact.sa_handler != SIG_IGN) {
		if (act != NULL)
			oldact = oldact2;
		else if (oact != NULL)
			oldact = usa->sigact;
	}

	_thr_rwl_unlock(&usa->lock);
	__sys_sigprocmask(SIG_SETMASK, &oldset, NULL);

	if (ret == 0) {

	return (ret);
}

__weak_reference(_sigprocmask, sigprocmask);

int
__thr_sigprocmask(int how, const sigset_t *set, sigset_t *oset)
{
	const sigset_t *p = set;
	sigset_t newset;

	return (0);
}

__weak_reference(__sigsuspend, sigsuspend);

int
_sigsuspend(const sigset_t * set)
{

}

int
__thr_sigsuspend(const sigset_t * set)
{
	struct pthread *curthread;
	sigset_t newset;

	return (ret);
}

__weak_reference(___sigwait, sigwait);
__weak_reference(__sigtimedwait, sigtimedwait);
__weak_reference(__sigwaitinfo, sigwaitinfo);

int
_sigtimedwait(const sigset_t *set, siginfo_t *info,
	const struct timespec * timeout)

 *   it is not canceled.
 */
int
__thr_sigtimedwait(const sigset_t *set, siginfo_t *info,
    const struct timespec * timeout)
{
	struct pthread	*curthread = _get_curthread();
	sigset_t newset;

 *   it is not canceled.
 */ 
int
__thr_sigwaitinfo(const sigset_t *set, siginfo_t *info)
{
	struct pthread	*curthread = _get_curthread();
	sigset_t newset;

 *   it is not canceled.
 */ 
int
__thr_sigwait(const sigset_t *set, int *sig)
{
	struct pthread	*curthread = _get_curthread();
	sigset_t newset;

	return (ret);
}

__weak_reference(_setcontext, setcontext);
int
__thr_setcontext(const ucontext_t *ucp)
{
	ucontext_t uc;


		return __sys_setcontext(ucp);
	(void) memcpy(&uc, ucp, sizeof(uc));
	SIGDELSET(uc.uc_sigmask, SIGCANCEL);
	return (__sys_setcontext(&uc));
}

__weak_reference(_swapcontext, swapcontext);
int
__thr_swapcontext(ucontext_t *oucp, const ucontext_t *ucp)
{
	ucontext_t uc;


		SIGDELSET(uc.uc_sigmask, SIGCANCEL);
		ucp = &uc;
	}
	return (__sys_swapcontext(oucp, ucp));
}

Lines 1-9 Link Here

(-)b/lib/libthr/thread/thr_syscalls.c (-266 / +225 lines)
1	/*	1	/*
		2	* Copyright (c) 2014 The FreeBSD Foundation.
2	* Copyright (C) 2005 David Xu <davidxu@freebsd.org>.	3	* Copyright (C) 2005 David Xu <davidxu@freebsd.org>.
3	* Copyright (c) 2003 Daniel Eischen <deischen@freebsd.org>.	4	* Copyright (c) 2003 Daniel Eischen <deischen@freebsd.org>.
4	* Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.	5	* Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
5	* All rights reserved.	6	* All rights reserved.
6	*	7	*
		8	* Portions of this software were developed by Konstantin Belousov
		9	* under sponsorship from the FreeBSD Foundation.
		10	*
7	* Redistribution and use in source and binary forms, with or without	11	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions	12	* modification, are permitted provided that the following conditions
9	* are met:	13	* are met:
Lines 27-34 Link Here
27	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE	31	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
28	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,	32	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
29	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	33	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30	*
31	* $FreeBSD$
32	*/	34	*/
33		35
34	/*	36	/*
Lines 61-66 Link Here
61	*	63	*
62	*/	64	*/
63		65
		66	#include <sys/cdefs.h>
		67	__FBSDID("$FreeBSD$");
		68
64	#include "namespace.h"	69	#include "namespace.h"
65	#include <sys/types.h>	70	#include <sys/types.h>
66	#include <sys/mman.h>	71	#include <sys/mman.h>
Lines 87-171 Link Here
87	#include <pthread.h>	92	#include <pthread.h>
88	#include "un-namespace.h"	93	#include "un-namespace.h"
89		94
		95	#include "libc_private.h"
90	#include "thr_private.h"	96	#include "thr_private.h"
91		97
92	extern int __creat(const char *, mode_t);
93	extern int __pselect(int, fd_set , fd_set , fd_set *,
94	const struct timespec , const sigset_t );
95	extern unsigned __sleep(unsigned int);
96	extern int __system(const char *);
97	extern int __tcdrain(int);
98	extern int __usleep(useconds_t);
99	extern pid_t __wait(int *);
100	extern pid_t __waitpid(pid_t, int *, int);
101	extern int __sys_aio_suspend(const struct aiocb * const[], int,
102	const struct timespec *);
103	extern int __sys_accept(int, struct sockaddr , socklen_t );
104	extern int __sys_accept4(int, struct sockaddr , socklen_t , int);
105	extern int __sys_connect(int, const struct sockaddr *, socklen_t);
106	extern int __sys_fsync(int);
107	extern int __sys_msync(void *, size_t, int);
108	extern int __sys_pselect(int, fd_set , fd_set , fd_set *,
109	const struct timespec , const sigset_t );
110	extern int __sys_poll(struct pollfd *, unsigned, int);
111	extern ssize_t __sys_recv(int, void *, size_t, int);
112	extern ssize_t __sys_recvfrom(int, void , size_t, int, struct sockaddr , socklen_t *);
113	extern ssize_t __sys_recvmsg(int, struct msghdr *, int);
114	extern int __sys_select(int, fd_set , fd_set , fd_set , struct timeval );
115	extern int __sys_sendfile(int, int, off_t, size_t, struct sf_hdtr *,
116	off_t *, int);
117	extern ssize_t __sys_sendmsg(int, const struct msghdr *, int);
118	extern ssize_t __sys_sendto(int, const void ,size_t, int, const struct sockaddr , socklen_t);
119	extern ssize_t __sys_readv(int, const struct iovec *, int);
120	extern pid_t __sys_wait4(pid_t, int , int, struct rusage );
121	extern ssize_t __sys_writev(int, const struct iovec *, int);
122
123	int ___creat(const char *, mode_t);
124	int ___pselect(int, fd_set , fd_set , fd_set *,
125	const struct timespec , const sigset_t );
126	unsigned ___sleep(unsigned);
127	int ___system(const char *);
128	int ___tcdrain(int);
129	int ___usleep(useconds_t useconds);
130	pid_t ___wait(int *);
131	pid_t ___waitpid(pid_t, int *, int);
132	int __accept(int, struct sockaddr , socklen_t );
133	int __accept4(int, struct sockaddr , socklen_t , int);
134	int __aio_suspend(const struct aiocb * const iocbs[], int,
135	const struct timespec *);
136	int __close(int);
137	int __connect(int, const struct sockaddr *, socklen_t);
138	int __fcntl(int, int,...);
139	#ifdef SYSCALL_COMPAT	98	#ifdef SYSCALL_COMPAT
140	extern int __fcntl_compat(int, int,...);	99	extern int __fcntl_compat(int, int, ...);
141	#endif	100	#endif
142	int __fsync(int);
143	int __msync(void *, size_t, int);
144	int __nanosleep(const struct timespec , struct timespec );
145	int __open(const char *, int,...);
146	int __openat(int, const char *, int,...);
147	int __poll(struct pollfd *, unsigned int, int);
148	ssize_t __read(int, void *buf, size_t);
149	ssize_t __readv(int, const struct iovec *, int);
150	ssize_t __recvfrom(int, void , size_t, int f, struct sockaddr , socklen_t *);
151	ssize_t __recvmsg(int, struct msghdr *, int);
152	int __select(int, fd_set , fd_set , fd_set , struct timeval );
153	ssize_t __sendmsg(int, const struct msghdr *, int);
154	ssize_t __sendto(int, const void *, size_t, int,
155	const struct sockaddr *, socklen_t);
156	pid_t __wait3(int , int, struct rusage );
157	pid_t __wait4(pid_t, int , int, struct rusage );
158	ssize_t __write(int, const void *, size_t);
159	ssize_t __writev(int, const struct iovec *, int);
160
161	__weak_reference(__accept, accept);
162		101
163	/*	102	/*
164	* Cancellation behavior:	103	* Cancellation behavior:
165	* If thread is canceled, no socket is created.	104	* If thread is canceled, no socket is created.
166	*/	105	*/
167	int	106	static int
168	__accept(int s, struct sockaddr addr, socklen_t addrlen)	107	__thr_accept(int s, struct sockaddr addr, socklen_t addrlen)
169	{	108	{
170	struct pthread *curthread;	109	struct pthread *curthread;
171	int ret;	110	int ret;
Lines 178-191 __accept(int s, struct sockaddr addr, socklen_t addrlen) Link Here
178	return (ret);	117	return (ret);
179	}	118	}
180		119
181	__weak_reference(__accept4, accept4);
182
183	/*	120	/*
184	* Cancellation behavior:	121	* Cancellation behavior:
185	* If thread is canceled, no socket is created.	122	* If thread is canceled, no socket is created.
186	*/	123	*/
187	int	124	static int
188	__accept4(int s, struct sockaddr addr, socklen_t addrlen, int flags)	125	__thr_accept4(int s, struct sockaddr addr, socklen_t addrlen, int flags)
189	{	126	{
190	struct pthread *curthread;	127	struct pthread *curthread;
191	int ret;	128	int ret;
Lines 198-212 __accept4(int s, struct sockaddr addr, socklen_t addrlen, int flags) Link Here
198	return (ret);	135	return (ret);
199	}	136	}
200		137
201	__weak_reference(__aio_suspend, aio_suspend);	138	static int
202		139	__thr_aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct
203	int
204	__aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct
205	timespec *timeout)	140	timespec *timeout)
206	{	141	{
207	struct pthread *curthread = _get_curthread();	142	struct pthread *curthread;
208	int ret;	143	int ret;
209		144
		145	curthread = _get_curthread();
210	_thr_cancel_enter(curthread);	146	_thr_cancel_enter(curthread);
211	ret = __sys_aio_suspend(iocbs, niocb, timeout);	147	ret = __sys_aio_suspend(iocbs, niocb, timeout);
212	_thr_cancel_leave(curthread, 1);	148	_thr_cancel_leave(curthread, 1);
Lines 214-221 __aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct Link Here
214	return (ret);	150	return (ret);
215	}	151	}
216		152
217	__weak_reference(__close, close);
218
219	/*	153	/*
220	* Cancellation behavior:	154	* Cancellation behavior:
221	* According to manual of close(), the file descriptor is always deleted.	155	* According to manual of close(), the file descriptor is always deleted.
Lines 223-234 __weak_reference(__close, close); Link Here
223	* descriptor is always deleted despite whether the thread is canceled	157	* descriptor is always deleted despite whether the thread is canceled
224	* or not.	158	* or not.
225	*/	159	*/
226	int	160	static int
227	__close(int fd)	161	__thr_close(int fd)
228	{	162	{
229	struct pthread *curthread = _get_curthread();	163	struct pthread *curthread;
230	int ret;	164	int ret;
231		165
		166	curthread = _get_curthread();
232	_thr_cancel_enter2(curthread, 0);	167	_thr_cancel_enter2(curthread, 0);
233	ret = __sys_close(fd);	168	ret = __sys_close(fd);
234	_thr_cancel_leave(curthread, 1);	169	_thr_cancel_leave(curthread, 1);
Lines 236-253 __close(int fd) Link Here
236	return (ret);	171	return (ret);
237	}	172	}
238		173
239	__weak_reference(__connect, connect);
240
241	/*	174	/*
242	* Cancellation behavior:	175	* Cancellation behavior:
243	* If the thread is canceled, connection is not made.	176	* If the thread is canceled, connection is not made.
244	*/	177	*/
245	int	178	static int
246	__connect(int fd, const struct sockaddr *name, socklen_t namelen)	179	__thr_connect(int fd, const struct sockaddr *name, socklen_t namelen)
247	{	180	{
248	struct pthread *curthread = _get_curthread();	181	struct pthread *curthread;
249	int ret;	182	int ret;
250		183
		184	curthread = _get_curthread();
251	_thr_cancel_enter(curthread);	185	_thr_cancel_enter(curthread);
252	ret = __sys_connect(fd, name, namelen);	186	ret = __sys_connect(fd, name, namelen);
253	_thr_cancel_leave(curthread, ret == -1);	187	_thr_cancel_leave(curthread, ret == -1);
Lines 255-281 __connect(int fd, const struct sockaddr *name, socklen_t namelen) Link Here
255	return (ret);	189	return (ret);
256	}	190	}
257		191
258	__weak_reference(___creat, creat);
259		192
260	/*	193	/*
261	* Cancellation behavior:	194	* Cancellation behavior:
262	* If thread is canceled, file is not created.	195	* If thread is canceled, file is not created.
263	*/	196	*/
264	int	197	static int
265	___creat(const char *path, mode_t mode)	198	__thr_creat(const char *path, mode_t mode)
266	{	199	{
267	struct pthread *curthread = _get_curthread();	200	struct pthread *curthread;
268	int ret;	201	int ret;
269		202
		203	curthread = _get_curthread();
270	_thr_cancel_enter(curthread);	204	_thr_cancel_enter(curthread);
271	ret = __creat(path, mode);	205	ret = __libc_creat(path, mode);
272	_thr_cancel_leave(curthread, ret == -1);	206	_thr_cancel_leave(curthread, ret == -1);
273		207
274	return ret;	208	return (ret);
275	}	209	}
276		210
277	__weak_reference(__fcntl, fcntl);
278
279	/*	211	/*
280	* Cancellation behavior:	212	* Cancellation behavior:
281	* According to specification, only F_SETLKW is a cancellation point.	213	* According to specification, only F_SETLKW is a cancellation point.
Lines 283-295 __weak_reference(__fcntl, fcntl); Link Here
283	* is failure, this means the function does not generate side effect	215	* is failure, this means the function does not generate side effect
284	* if it is canceled.	216	* if it is canceled.
285	*/	217	*/
286	int	218	static int
287	__fcntl(int fd, int cmd,...)	219	__thr_fcntl(int fd, int cmd, ...)
288	{	220	{
289	struct pthread *curthread = _get_curthread();	221	struct pthread *curthread;
290	int ret;	222	int ret;
291	va_list ap;	223	va_list ap;
292		224
		225	curthread = _get_curthread();
293	va_start(ap, cmd);	226	va_start(ap, cmd);
294	if (cmd == F_OSETLKW \|\| cmd == F_SETLKW) {	227	if (cmd == F_OSETLKW \|\| cmd == F_SETLKW) {
295	_thr_cancel_enter(curthread);	228	_thr_cancel_enter(curthread);
Lines 311-328 __fcntl(int fd, int cmd,...) Link Here
311	return (ret);	244	return (ret);
312	}	245	}
313		246
314	__weak_reference(__fsync, fsync);
315
316	/*	247	/*
317	* Cancellation behavior:	248	* Cancellation behavior:
318	* Thread may be canceled after system call.	249	* Thread may be canceled after system call.
319	*/	250	*/
320	int	251	static int
321	__fsync(int fd)	252	__thr_fsync(int fd)
322	{	253	{
323	struct pthread *curthread = _get_curthread();	254	struct pthread *curthread;
324	int ret;	255	int ret;
325		256
		257	curthread = _get_curthread();
326	_thr_cancel_enter2(curthread, 0);	258	_thr_cancel_enter2(curthread, 0);
327	ret = __sys_fsync(fd);	259	ret = __sys_fsync(fd);
328	_thr_cancel_leave(curthread, 1);	260	_thr_cancel_leave(curthread, 1);
Lines 330-363 __fsync(int fd) Link Here
330	return (ret);	262	return (ret);
331	}	263	}
332		264
333	__weak_reference(__msync, msync);
334
335	/*	265	/*
336	* Cancellation behavior:	266	* Cancellation behavior:
337	* Thread may be canceled after system call.	267	* Thread may be canceled after system call.
338	*/	268	*/
339	int	269	static int
340	__msync(void *addr, size_t len, int flags)	270	__thr_msync(void *addr, size_t len, int flags)
341	{	271	{
342	struct pthread *curthread = _get_curthread();	272	struct pthread *curthread;
343	int ret;	273	int ret;
344		274
		275	curthread = _get_curthread();
345	_thr_cancel_enter2(curthread, 0);	276	_thr_cancel_enter2(curthread, 0);
346	ret = __sys_msync(addr, len, flags);	277	ret = __sys_msync(addr, len, flags);
347	_thr_cancel_leave(curthread, 1);	278	_thr_cancel_leave(curthread, 1);
348		279
349	return ret;	280	return (ret);
350	}	281	}
351		282
352	__weak_reference(__nanosleep, nanosleep);	283	static int
353		284	__thr_nanosleep(const struct timespec *time_to_sleep,
354	int
355	__nanosleep(const struct timespec *time_to_sleep,
356	struct timespec *time_remaining)	285	struct timespec *time_remaining)
357	{	286	{
358	struct pthread *curthread = _get_curthread();	287	struct pthread *curthread;
359	int ret;	288	int ret;
360		289
		290	curthread = _get_curthread();
361	_thr_cancel_enter(curthread);	291	_thr_cancel_enter(curthread);
362	ret = __sys_nanosleep(time_to_sleep, time_remaining);	292	ret = __sys_nanosleep(time_to_sleep, time_remaining);
363	_thr_cancel_leave(curthread, 1);	293	_thr_cancel_leave(curthread, 1);
Lines 365-463 __nanosleep(const struct timespec *time_to_sleep, Link Here
365	return (ret);	295	return (ret);
366	}	296	}
367		297
368	__weak_reference(__open, open);
369
370	/*	298	/*
371	* Cancellation behavior:	299	* Cancellation behavior:
372	* If the thread is canceled, file is not opened.	300	* If the thread is canceled, file is not opened.
373	*/	301	*/
374	int	302	static int
375	__open(const char *path, int flags,...)	303	__thr_open(const char *path, int flags,...)
376	{	304	{
377	struct pthread *curthread = _get_curthread();	305	struct pthread *curthread;
378	int ret;	306	int mode, ret;
379	int mode = 0;
380	va_list ap;	307	va_list ap;
381		308
382	/* Check if the file is being created: */	309	/* Check if the file is being created: */
383	if (flags & O_CREAT) {	310	if ((flags & O_CREAT) != 0) {
384	/* Get the creation mode: */	311	/* Get the creation mode: */
385	va_start(ap, flags);	312	va_start(ap, flags);
386	mode = va_arg(ap, int);	313	mode = va_arg(ap, int);
387	va_end(ap);	314	va_end(ap);
		315	} else {
		316	mode = 0;
388	}	317	}
389		318
		319	curthread = _get_curthread();
390	_thr_cancel_enter(curthread);	320	_thr_cancel_enter(curthread);
391	ret = __sys_open(path, flags, mode);	321	ret = __sys_open(path, flags, mode);
392	_thr_cancel_leave(curthread, ret == -1);	322	_thr_cancel_leave(curthread, ret == -1);
393		323
394	return ret;	324	return (ret);
395	}	325	}
396		326
397	__weak_reference(__openat, openat);
398
399	/*	327	/*
400	* Cancellation behavior:	328	* Cancellation behavior:
401	* If the thread is canceled, file is not opened.	329	* If the thread is canceled, file is not opened.
402	*/	330	*/
403	int	331	static int
404	__openat(int fd, const char *path, int flags, ...)	332	__thr_openat(int fd, const char *path, int flags, ...)
405	{	333	{
406	struct pthread *curthread = _get_curthread();	334	struct pthread *curthread;
407	int ret;	335	int mode, ret;
408	int mode = 0;
409	va_list ap;	336	va_list ap;
410		337
411		338
412	/* Check if the file is being created: */	339	/* Check if the file is being created: */
413	if (flags & O_CREAT) {	340	if ((flags & O_CREAT) != 0) {
414	/* Get the creation mode: */	341	/* Get the creation mode: */
415	va_start(ap, flags);	342	va_start(ap, flags);
416	mode = va_arg(ap, int);	343	mode = va_arg(ap, int);
417	va_end(ap);	344	va_end(ap);
		345	} else {
		346	mode = 0;
418	}	347	}
419		348
		349	curthread = _get_curthread();
420	_thr_cancel_enter(curthread);	350	_thr_cancel_enter(curthread);
421	ret = __sys_openat(fd, path, flags, mode);	351	ret = __sys_openat(fd, path, flags, mode);
422	_thr_cancel_leave(curthread, ret == -1);	352	_thr_cancel_leave(curthread, ret == -1);
423		353
424	return ret;	354	return (ret);
425	}	355	}
426		356
427	__weak_reference(__poll, poll);
428
429	/*	357	/*
430	* Cancellation behavior:	358	* Cancellation behavior:
431	* Thread may be canceled at start, but if the system call returns something,	359	* Thread may be canceled at start, but if the system call returns something,
432	* the thread is not canceled.	360	* the thread is not canceled.
433	*/	361	*/
434	int	362	static int
435	__poll(struct pollfd *fds, unsigned int nfds, int timeout)	363	__thr_poll(struct pollfd *fds, unsigned int nfds, int timeout)
436	{	364	{
437	struct pthread *curthread = _get_curthread();	365	struct pthread *curthread;
438	int ret;	366	int ret;
439		367
		368	curthread = _get_curthread();
440	_thr_cancel_enter(curthread);	369	_thr_cancel_enter(curthread);
441	ret = __sys_poll(fds, nfds, timeout);	370	ret = __sys_poll(fds, nfds, timeout);
442	_thr_cancel_leave(curthread, ret == -1);	371	_thr_cancel_leave(curthread, ret == -1);
443		372
444	return ret;	373	return (ret);
445	}	374	}
446		375
447	__weak_reference(___pselect, pselect);
448
449	/*	376	/*
450	* Cancellation behavior:	377	* Cancellation behavior:
451	* Thread may be canceled at start, but if the system call returns something,	378	* Thread may be canceled at start, but if the system call returns something,
452	* the thread is not canceled.	379	* the thread is not canceled.
453	*/	380	*/
454	int	381	static int
455	___pselect(int count, fd_set rfds, fd_set wfds, fd_set *efds,	382	__thr_pselect(int count, fd_set rfds, fd_set wfds, fd_set *efds,
456	const struct timespec timo, const sigset_t mask)	383	const struct timespec timo, const sigset_t mask)
457	{	384	{
458	struct pthread *curthread = _get_curthread();	385	struct pthread *curthread;
459	int ret;	386	int ret;
460		387
		388	curthread = _get_curthread();
461	_thr_cancel_enter(curthread);	389	_thr_cancel_enter(curthread);
462	ret = __sys_pselect(count, rfds, wfds, efds, timo, mask);	390	ret = __sys_pselect(count, rfds, wfds, efds, timo, mask);
463	_thr_cancel_leave(curthread, ret == -1);	391	_thr_cancel_leave(curthread, ret == -1);
Lines 465-785 ___pselect(int count, fd_set rfds, fd_set wfds, fd_set *efds, Link Here
465	return (ret);	393	return (ret);
466	}	394	}
467		395
468	__weak_reference(__read, read);
469
470	/*	396	/*
471	* Cancellation behavior:	397	* Cancellation behavior:
472	* Thread may be canceled at start, but if the system call got some data,	398	* Thread may be canceled at start, but if the system call got some data,
473	* the thread is not canceled.	399	* the thread is not canceled.
474	*/	400	*/
475	ssize_t	401	static ssize_t
476	__read(int fd, void *buf, size_t nbytes)	402	__thr_read(int fd, void *buf, size_t nbytes)
477	{	403	{
478	struct pthread *curthread = _get_curthread();	404	struct pthread *curthread;
479	ssize_t ret;	405	ssize_t ret;
480		406
		407	curthread = _get_curthread();
481	_thr_cancel_enter(curthread);	408	_thr_cancel_enter(curthread);
482	ret = __sys_read(fd, buf, nbytes);	409	ret = __sys_read(fd, buf, nbytes);
483	_thr_cancel_leave(curthread, ret == -1);	410	_thr_cancel_leave(curthread, ret == -1);
484		411
485	return ret;	412	return (ret);
486	}	413	}
487		414
488	__weak_reference(__readv, readv);
489
490	/*	415	/*
491	* Cancellation behavior:	416	* Cancellation behavior:
492	* Thread may be canceled at start, but if the system call got some data,	417	* Thread may be canceled at start, but if the system call got some data,
493	* the thread is not canceled.	418	* the thread is not canceled.
494	*/	419	*/
495	ssize_t	420	static ssize_t
496	__readv(int fd, const struct iovec *iov, int iovcnt)	421	__thr_readv(int fd, const struct iovec *iov, int iovcnt)
497	{	422	{
498	struct pthread *curthread = _get_curthread();	423	struct pthread *curthread;
499	ssize_t ret;	424	ssize_t ret;
500		425
		426	curthread = _get_curthread();
501	_thr_cancel_enter(curthread);	427	_thr_cancel_enter(curthread);
502	ret = __sys_readv(fd, iov, iovcnt);	428	ret = __sys_readv(fd, iov, iovcnt);
503	_thr_cancel_leave(curthread, ret == -1);	429	_thr_cancel_leave(curthread, ret == -1);
504	return ret;	430	return (ret);
505	}	431	}
506		432
507	__weak_reference(__recvfrom, recvfrom);
508
509	/*	433	/*
510	* Cancellation behavior:	434	* Cancellation behavior:
511	* Thread may be canceled at start, but if the system call got some data,	435	* Thread may be canceled at start, but if the system call got some data,
512	* the thread is not canceled.	436	* the thread is not canceled.
513	*/	437	*/
514	ssize_t	438	static ssize_t
515	__recvfrom(int s, void b, size_t l, int f, struct sockaddr from,	439	__thr_recvfrom(int s, void b, size_t l, int f, struct sockaddr from,
516	socklen_t *fl)	440	socklen_t *fl)
517	{	441	{
518	struct pthread *curthread = _get_curthread();	442	struct pthread *curthread;
519	ssize_t ret;	443	ssize_t ret;
520		444
		445	curthread = _get_curthread();
521	_thr_cancel_enter(curthread);	446	_thr_cancel_enter(curthread);
522	ret = __sys_recvfrom(s, b, l, f, from, fl);	447	ret = __sys_recvfrom(s, b, l, f, from, fl);
523	_thr_cancel_leave(curthread, ret == -1);	448	_thr_cancel_leave(curthread, ret == -1);
524	return (ret);	449	return (ret);
525	}	450	}
526		451
527	__weak_reference(__recvmsg, recvmsg);
528
529	/*	452	/*
530	* Cancellation behavior:	453	* Cancellation behavior:
531	* Thread may be canceled at start, but if the system call got some data,	454	* Thread may be canceled at start, but if the system call got some data,
532	* the thread is not canceled.	455	* the thread is not canceled.
533	*/	456	*/
534	ssize_t	457	static ssize_t
535	__recvmsg(int s, struct msghdr *m, int f)	458	__thr_recvmsg(int s, struct msghdr *m, int f)
536	{	459	{
537	struct pthread *curthread = _get_curthread();	460	struct pthread *curthread;
538	ssize_t ret;	461	ssize_t ret;
539		462
		463	curthread = _get_curthread();
540	_thr_cancel_enter(curthread);	464	_thr_cancel_enter(curthread);
541	ret = __sys_recvmsg(s, m, f);	465	ret = __sys_recvmsg(s, m, f);
542	_thr_cancel_leave(curthread, ret == -1);	466	_thr_cancel_leave(curthread, ret == -1);
543	return (ret);	467	return (ret);
544	}	468	}
545		469
546	__weak_reference(__select, select);
547
548	/*	470	/*
549	* Cancellation behavior:	471	* Cancellation behavior:
550	* Thread may be canceled at start, but if the system call returns something,	472	* Thread may be canceled at start, but if the system call returns something,
551	* the thread is not canceled.	473	* the thread is not canceled.
552	*/	474	*/
553	int	475	static int
554	__select(int numfds, fd_set readfds, fd_set writefds, fd_set *exceptfds,	476	__thr_select(int numfds, fd_set readfds, fd_set writefds, fd_set *exceptfds,
555	struct timeval *timeout)	477	struct timeval *timeout)
556	{	478	{
557	struct pthread *curthread = _get_curthread();	479	struct pthread *curthread;
558	int ret;	480	int ret;
559		481
		482	curthread = _get_curthread();
560	_thr_cancel_enter(curthread);	483	_thr_cancel_enter(curthread);
561	ret = __sys_select(numfds, readfds, writefds, exceptfds, timeout);	484	ret = __sys_select(numfds, readfds, writefds, exceptfds, timeout);
562	_thr_cancel_leave(curthread, ret == -1);	485	_thr_cancel_leave(curthread, ret == -1);
563	return ret;	486	return (ret);
564	}	487	}
565		488
566	__weak_reference(__sendmsg, sendmsg);
567
568	/*	489	/*
569	* Cancellation behavior:	490	* Cancellation behavior:
570	* Thread may be canceled at start, but if the system call sent	491	* Thread may be canceled at start, but if the system call sent
571	* data, the thread is not canceled.	492	* data, the thread is not canceled.
572	*/	493	*/
573	ssize_t	494	static ssize_t
574	__sendmsg(int s, const struct msghdr *m, int f)	495	__thr_sendmsg(int s, const struct msghdr *m, int f)
575	{	496	{
576	struct pthread *curthread = _get_curthread();	497	struct pthread *curthread;
577	ssize_t ret;	498	ssize_t ret;
578		499
		500	curthread = _get_curthread();
579	_thr_cancel_enter(curthread);	501	_thr_cancel_enter(curthread);
580	ret = __sys_sendmsg(s, m, f);	502	ret = __sys_sendmsg(s, m, f);
581	_thr_cancel_leave(curthread, ret <= 0);	503	_thr_cancel_leave(curthread, ret <= 0);
582	return (ret);	504	return (ret);
583	}	505	}
584		506
585	__weak_reference(__sendto, sendto);
586
587	/*	507	/*
588	* Cancellation behavior:	508	* Cancellation behavior:
589	* Thread may be canceled at start, but if the system call sent some	509	* Thread may be canceled at start, but if the system call sent some
590	* data, the thread is not canceled.	510	* data, the thread is not canceled.
591	*/	511	*/
592	ssize_t	512	static ssize_t
593	__sendto(int s, const void m, size_t l, int f, const struct sockaddr t,	513	__thr_sendto(int s, const void m, size_t l, int f, const struct sockaddr t,
594	socklen_t tl)	514	socklen_t tl)
595	{	515	{
596	struct pthread *curthread = _get_curthread();	516	struct pthread *curthread;
597	ssize_t ret;	517	ssize_t ret;
598		518
		519	curthread = _get_curthread();
599	_thr_cancel_enter(curthread);	520	_thr_cancel_enter(curthread);
600	ret = __sys_sendto(s, m, l, f, t, tl);	521	ret = __sys_sendto(s, m, l, f, t, tl);
601	_thr_cancel_leave(curthread, ret <= 0);	522	_thr_cancel_leave(curthread, ret <= 0);
602	return (ret);	523	return (ret);
603	}	524	}
604		525
605	__weak_reference(___sleep, sleep);	526	static unsigned int
606		527	__thr_sleep(unsigned int seconds)
607	unsigned int
608	___sleep(unsigned int seconds)
609	{	528	{
610	struct pthread *curthread = _get_curthread();	529	struct pthread *curthread;
611	unsigned int ret;	530	unsigned int ret;
612		531
		532	curthread = _get_curthread();
613	_thr_cancel_enter(curthread);	533	_thr_cancel_enter(curthread);
614	ret = __sleep(seconds);	534	ret = __libc_sleep(seconds);
615	_thr_cancel_leave(curthread, 1);	535	_thr_cancel_leave(curthread, 1);
616
617	return (ret);	536	return (ret);
618	}	537	}
619		538
620	__weak_reference(___system, system);	539	static int
621		540	__thr_system(const char *string)
622	int
623	___system(const char *string)
624	{	541	{
625	struct pthread *curthread = _get_curthread();	542	struct pthread *curthread;
626	int ret;	543	int ret;
627		544
		545	curthread = _get_curthread();
628	_thr_cancel_enter(curthread);	546	_thr_cancel_enter(curthread);
629	ret = __system(string);	547	ret = __libc_system(string);
630	_thr_cancel_leave(curthread, 1);	548	_thr_cancel_leave(curthread, 1);
631		549	return (ret);
632	return ret;
633	}	550	}
634		551
635	__weak_reference(___tcdrain, tcdrain);
636
637	/*	552	/*
638	* Cancellation behavior:	553	* Cancellation behavior:
639	* If thread is canceled, the system call is not completed,	554	* If thread is canceled, the system call is not completed,
640	* this means not all bytes were drained.	555	* this means not all bytes were drained.
641	*/	556	*/
642	int	557	static int
643	___tcdrain(int fd)	558	__thr_tcdrain(int fd)
644	{	559	{
645	struct pthread *curthread = _get_curthread();	560	struct pthread *curthread;
646	int ret;	561	int ret;
647		562
		563	curthread = _get_curthread();
648	_thr_cancel_enter(curthread);	564	_thr_cancel_enter(curthread);
649	ret = __tcdrain(fd);	565	ret = __libc_tcdrain(fd);
650	_thr_cancel_leave(curthread, ret == -1);	566	_thr_cancel_leave(curthread, ret == -1);
651	return (ret);	567	return (ret);
652	}	568	}
653		569
654	__weak_reference(___usleep, usleep);	570	static int
655		571	__thr_usleep(useconds_t useconds)
656	int
657	___usleep(useconds_t useconds)
658	{	572	{
659	struct pthread *curthread = _get_curthread();	573	struct pthread *curthread;
660	int ret;	574	int ret;
661		575
		576	curthread = _get_curthread();
662	_thr_cancel_enter(curthread);	577	_thr_cancel_enter(curthread);
663	ret = __usleep(useconds);	578	ret = __libc_usleep(useconds);
664	_thr_cancel_leave(curthread, 1);	579	_thr_cancel_leave(curthread, 1);
665
666	return (ret);	580	return (ret);
667	}	581	}
668		582
669	__weak_reference(___wait, wait);
670
671	/*	583	/*
672	* Cancellation behavior:	584	* Cancellation behavior:
673	* Thread may be canceled at start, but if the system call returns	585	* Thread may be canceled at start, but if the system call returns
674	* a child pid, the thread is not canceled.	586	* a child pid, the thread is not canceled.
675	*/	587	*/
676	pid_t	588	static pid_t
677	___wait(int *istat)	589	__thr_wait(int *istat)
678	{	590	{
679	struct pthread *curthread = _get_curthread();	591	struct pthread *curthread;
680	pid_t ret;	592	pid_t ret;
681		593
		594	curthread = _get_curthread();
682	_thr_cancel_enter(curthread);	595	_thr_cancel_enter(curthread);
683	ret = __wait(istat);	596	ret = __libc_wait(istat);
684	_thr_cancel_leave(curthread, ret <= 0);	597	_thr_cancel_leave(curthread, ret <= 0);
685		598	return (ret);
686	return ret;
687	}	599	}
688		600
689	__weak_reference(__wait3, wait3);
690
691	/*	601	/*
692	* Cancellation behavior:	602	* Cancellation behavior:
693	* Thread may be canceled at start, but if the system call returns	603	* Thread may be canceled at start, but if the system call returns
694	* a child pid, the thread is not canceled.	604	* a child pid, the thread is not canceled.
695	*/	605	*/
696	pid_t	606	static pid_t
697	__wait3(int status, int options, struct rusage rusage)	607	__thr_wait3(int status, int options, struct rusage rusage)
698	{	608	{
699	struct pthread *curthread = _get_curthread();	609	struct pthread *curthread;
700	pid_t ret;	610	pid_t ret;
701		611
		612	curthread = _get_curthread();
702	_thr_cancel_enter(curthread);	613	_thr_cancel_enter(curthread);
703	ret = _wait4(WAIT_ANY, status, options, rusage);	614	ret = __libc_wait3(status, options, rusage);
704	_thr_cancel_leave(curthread, ret <= 0);	615	_thr_cancel_leave(curthread, ret <= 0);
705
706	return (ret);	616	return (ret);
707	}	617	}
708		618
709	__weak_reference(__wait4, wait4);
710
711	/*	619	/*
712	* Cancellation behavior:	620	* Cancellation behavior:
713	* Thread may be canceled at start, but if the system call returns	621	* Thread may be canceled at start, but if the system call returns
714	* a child pid, the thread is not canceled.	622	* a child pid, the thread is not canceled.
715	*/	623	*/
716	pid_t	624	static pid_t
717	__wait4(pid_t pid, int status, int options, struct rusage rusage)	625	__thr_wait4(pid_t pid, int status, int options, struct rusage rusage)
718	{	626	{
719	struct pthread *curthread = _get_curthread();	627	struct pthread *curthread;
720	pid_t ret;	628	pid_t ret;
721		629
		630	curthread = _get_curthread();
722	_thr_cancel_enter(curthread);	631	_thr_cancel_enter(curthread);
723	ret = __sys_wait4(pid, status, options, rusage);	632	ret = __sys_wait4(pid, status, options, rusage);
724	_thr_cancel_leave(curthread, ret <= 0);	633	_thr_cancel_leave(curthread, ret <= 0);
725		634	return (ret);
726	return ret;
727	}	635	}
728		636
729	__weak_reference(___waitpid, waitpid);
730
731	/*	637	/*
732	* Cancellation behavior:	638	* Cancellation behavior:
733	* Thread may be canceled at start, but if the system call returns	639	* Thread may be canceled at start, but if the system call returns
734	* a child pid, the thread is not canceled.	640	* a child pid, the thread is not canceled.
735	*/	641	*/
736	pid_t	642	static pid_t
737	___waitpid(pid_t wpid, int *status, int options)	643	__thr_waitpid(pid_t wpid, int *status, int options)
738	{	644	{
739	struct pthread *curthread = _get_curthread();	645	struct pthread *curthread;
740	pid_t ret;	646	pid_t ret;
741		647
		648	curthread = _get_curthread();
742	_thr_cancel_enter(curthread);	649	_thr_cancel_enter(curthread);
743	ret = __waitpid(wpid, status, options);	650	ret = __libc_waitpid(wpid, status, options);
744	_thr_cancel_leave(curthread, ret <= 0);	651	_thr_cancel_leave(curthread, ret <= 0);
745		652	return (ret);
746	return ret;
747	}	653	}
748		654
749	__weak_reference(__write, write);
750
751	/*	655	/*
752	* Cancellation behavior:	656	* Cancellation behavior:
753	* Thread may be canceled at start, but if the thread wrote some data,	657	* Thread may be canceled at start, but if the thread wrote some data,
754	* it is not canceled.	658	* it is not canceled.
755	*/	659	*/
756	ssize_t	660	static ssize_t
757	__write(int fd, const void *buf, size_t nbytes)	661	__thr_write(int fd, const void *buf, size_t nbytes)
758	{	662	{
759	struct pthread *curthread = _get_curthread();	663	struct pthread *curthread;
760	ssize_t ret;	664	ssize_t ret;
761		665
		666	curthread = _get_curthread();
762	_thr_cancel_enter(curthread);	667	_thr_cancel_enter(curthread);
763	ret = __sys_write(fd, buf, nbytes);	668	ret = __sys_write(fd, buf, nbytes);
764	_thr_cancel_leave(curthread, (ret <= 0));	669	_thr_cancel_leave(curthread, (ret <= 0));
765	return ret;	670	return (ret);
766	}	671	}
767		672
768	__weak_reference(__writev, writev);
769
770	/*	673	/*
771	* Cancellation behavior:	674	* Cancellation behavior:
772	* Thread may be canceled at start, but if the thread wrote some data,	675	* Thread may be canceled at start, but if the thread wrote some data,
773	* it is not canceled.	676	* it is not canceled.
774	*/	677	*/
775	ssize_t	678	static ssize_t
776	__writev(int fd, const struct iovec *iov, int iovcnt)	679	__thr_writev(int fd, const struct iovec *iov, int iovcnt)
777	{	680	{
778	struct pthread *curthread = _get_curthread();	681	struct pthread *curthread;
779	ssize_t ret;	682	ssize_t ret;
780		683
		684	curthread = _get_curthread();
781	_thr_cancel_enter(curthread);	685	_thr_cancel_enter(curthread);
782	ret = __sys_writev(fd, iov, iovcnt);	686	ret = __sys_writev(fd, iov, iovcnt);
783	_thr_cancel_leave(curthread, (ret <= 0));	687	_thr_cancel_leave(curthread, (ret <= 0));
784	return ret;	688	return (ret);
		689	}
		690
		691	void
		692	__thr_interpose_libc(void)
		693	{
		694
		695	__error_selector = __error_threaded;
		696	#define SLOT(name) \
		697	*(__libc_interposing_slot(INTERPOS_##name)) = \
		698	(interpos_func_t)__thr_##name;
		699	SLOT(accept);
		700	SLOT(accept4);
		701	SLOT(aio_suspend);
		702	SLOT(close);
		703	SLOT(connect);
		704	SLOT(creat);
		705	SLOT(fcntl);
		706	SLOT(fsync);
		707	SLOT(msync);
		708	SLOT(nanosleep);
		709	SLOT(open);
		710	SLOT(openat);
		711	SLOT(poll);
		712	SLOT(pselect);
		713	SLOT(raise);
		714	SLOT(read);
		715	SLOT(readv);
		716	SLOT(recvfrom);
		717	SLOT(recvmsg);
		718	SLOT(select);
		719	SLOT(sendmsg);
		720	SLOT(sendto);
		721	SLOT(setcontext);
		722	SLOT(sigaction);
		723	SLOT(sigprocmask);
		724	SLOT(sigsuspend);
		725	SLOT(sigwait);
		726	SLOT(sigtimedwait);
		727	SLOT(sigwaitinfo);
		728	SLOT(swapcontext);
		729	SLOT(system);
		730	SLOT(sleep);
		731	SLOT(tcdrain);
		732	SLOT(usleep);
		733	SLOT(pause);
		734	SLOT(wait);
		735	SLOT(wait3);
		736	SLOT(wait4);
		737	SLOT(waitpid);
		738	SLOT(write);
		739	SLOT(writev);
		740	#undef SLOT
		741	*(__libc_interposing_slot(
		742	INTERPOS__pthread_mutex_init_calloc_cb)) =
		743	(interpos_func_t)_pthread_mutex_init_calloc_cb;
785	}	744	}

Lines 30-34 FBSDprivate_1.0 { Link Here

(-)b/libexec/rtld-elf/Symbol.map (+1 lines)
30	_rtld_atfork_post;	30	_rtld_atfork_post;
31	_rtld_addr_phdr;	31	_rtld_addr_phdr;
32	_rtld_get_stack_prot;	32	_rtld_get_stack_prot;
		33	_rtld_is_dlopened;
33	_r_debug_postinit;	34	_r_debug_postinit;
34	};	35	};




	return (NULL);
    }

    obj->dlopened = (flags & RTLD_LO_DLOPEN) != 0;
    *obj_tail = obj;
    obj_tail = &obj->next;
    obj_count++;

	return (stack_prot);
}

int
_rtld_is_dlopened(void *arg)
{
	Obj_Entry *obj;
	RtldLockState lockstate;
	int res;

	rlock_acquire(rtld_bind_lock, &lockstate);
	obj = dlcheck(arg);
	if (obj == NULL)
		obj = obj_from_addr(arg);
	if (obj == NULL) {
		_rtld_error("No shared object contains address");
		lock_release(rtld_bind_lock, &lockstate);
		return (-1);
	}
	res = obj->dlopened ? 1 : 0;
	lock_release(rtld_bind_lock, &lockstate);
	return (res);
}

static void
map_stacks_exec(RtldLockState *lockstate)
{

Lines 275-280 typedef struct Struct_Obj_Entry { Link Here

(-)b/libexec/rtld-elf/rtld.h (+1 lines)
275	bool crt_no_init : 1; /* Object' crt does not call _init/_fini */	275	bool crt_no_init : 1; /* Object' crt does not call _init/_fini */
276	bool valid_hash_sysv : 1; /* A valid System V hash hash tag is available */	276	bool valid_hash_sysv : 1; /* A valid System V hash hash tag is available */
277	bool valid_hash_gnu : 1; /* A valid GNU hash tag is available */	277	bool valid_hash_gnu : 1; /* A valid GNU hash tag is available */
		278	bool dlopened : 1; /* dlopen()-ed (vs. load statically) */
278		279
279	struct link_map linkmap; /* For GDB and dlinfo() */	280	struct link_map linkmap; /* For GDB and dlinfo() */
280	Objlist dldags; /* Object belongs to these dlopened DAGs (%) */	281	Objlist dldags; /* Object belongs to these dlopened DAGs (%) */

Lines 94-99 typedef int (__dl_iterate_hdr_callback)(struct dl_phdr_info , size_t, void *); Link Here

(-)b/sys/sys/link_elf.h (+1 lines)
94	extern int dl_iterate_phdr(__dl_iterate_hdr_callback, void *);	94	extern int dl_iterate_phdr(__dl_iterate_hdr_callback, void *);
95	int _rtld_addr_phdr(const void , struct dl_phdr_info );	95	int _rtld_addr_phdr(const void , struct dl_phdr_info );
96	int _rtld_get_stack_prot(void);	96	int _rtld_get_stack_prot(void);
		97	int _rtld_is_dlopened(void *);
97		98
98	#ifdef __ARM_EABI__	99	#ifdef __ARM_EABI__
99	void * dl_unwind_find_exidx(const void , int );	100	void * dl_unwind_find_exidx(const void , int );

Return to bug 196354

Lines 67-81 pthread_create(pthread_t *__restrict thread, Link Here

(-)b/contrib/jemalloc/src/mutex.c (-6 / +17 lines)
67	JEMALLOC_EXPORT int _pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,	67	JEMALLOC_EXPORT int _pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
68	void *(calloc_cb)(size_t, size_t));	68	void *(calloc_cb)(size_t, size_t));
69		69
70	__weak_reference(_pthread_mutex_init_calloc_cb_stub,	70	#pragma weak _pthread_mutex_init_calloc_cb
71	_pthread_mutex_init_calloc_cb);
72
73	int	71	int
74	_pthread_mutex_init_calloc_cb_stub(pthread_mutex_t *mutex,	72	_pthread_mutex_init_calloc_cb(pthread_mutex_t *mutex,
75	void *(calloc_cb)(size_t, size_t))	73	void *(calloc_cb)(size_t, size_t))
76	{	74	{
77		75
78	return (0);	76	return (((int ()(pthread_mutex_t , void ()(size_t, size_t)))
		77	__libc_interposing[INTERPOS__pthread_mutex_init_calloc_cb])(
		78	mutex, calloc_cb));
79	}	79	}
80	#endif	80	#endif
81		81
Lines 144-150 malloc_mutex_postfork_child(malloc_mutex_t *mutex) Link Here
144	}	144	}
145		145
146	bool	146	bool
147	mutex_boot(void)	147	malloc_mutex_first_thread(void)
148	{	148	{
149		149
150	#ifdef JEMALLOC_MUTEX_INIT_CB	150	#ifdef JEMALLOC_MUTEX_INIT_CB
Lines 158-160 mutex_boot(void) Link Here
158	#endif	158	#endif
159	return (false);	159	return (false);
160	}	160	}
		161
		162	bool
		163	mutex_boot(void)
		164	{
		165
		166	#ifndef JEMALLOC_MUTEX_INIT_CB
		167	return (malloc_mutex_first_thread());
		168	#else
		169	return (false);
		170	#endif
		171	}

Lines 487-492 FBSDprivate_1.0 { Link Here

(-)b/lib/libc/gen/Symbol.map (+11 lines)
487	_rtld_atfork_post;	487	_rtld_atfork_post;
488	_rtld_error; /* for private use */	488	_rtld_error; /* for private use */
489	_rtld_get_stack_prot;	489	_rtld_get_stack_prot;
		490	_rtld_is_dlopened;
490	_rtld_thread_init; /* for private use */	491	_rtld_thread_init; /* for private use */
491	__elf_phdr_match_addr;	492	__elf_phdr_match_addr;
492	_err;	493	_err;
Lines 532-537 FBSDprivate_1.0 { Link Here
532	_libc_sem_post_compat;	533	_libc_sem_post_compat;
533	_libc_sem_getvalue_compat;	534	_libc_sem_getvalue_compat;
534		535
		536	__libc_pause;
		537	__libc_raise;
		538	__libc_system;
		539	__libc_sleep;
		540	__libc_tcdrain;
		541	__libc_usleep;
		542	__libc_wait;
		543	__libc_wait3;
		544	__libc_waitpid;
		545
535	__elf_aux_vector;	546	__elf_aux_vector;
536	__pthread_map_stacks_exec;	547	__pthread_map_stacks_exec;
537	__fillcontextx;	548	__fillcontextx;

Added Link Here

(-)b/lib/libc/gen/__pthread_mutex_init_calloc_cb_stub.c (+45 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <pthread.h>
37	#include "libc_private.h"
38
39	int
40	_pthread_mutex_init_calloc_cb_stub(pthread_mutex_t *mutex,
41	void *(calloc_cb)(size_t, size_t))
42	{
43
44	return (0);
45	}

Lines 36-46 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/raise.c (-4 / +16 lines)
36	#include <signal.h>	36	#include <signal.h>
37	#include <unistd.h>	37	#include <unistd.h>
38		38
39	__weak_reference(__raise, raise);	39	#include "libc_private.h"
40	__weak_reference(__raise, _raise);
41		40
		41	__weak_reference(__libc_raise, __raise);
		42	__weak_reference(__libc_raise, _raise);
		43
		44	#pragma weak raise
42	int	45	int
43	__raise(int s)	46	raise(int s)
44	{	47	{
45	return(kill(getpid(), s));	48
		49	return (((int (*)(int))
		50	__libc_interposing[INTERPOS_raise])(s));
		51	}
		52
		53	int
		54	__libc_raise(int s)
		55	{
		56
		57	return (kill(getpid(), s));
46	}	58	}

Lines 40-47 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/sleep.c (-4 / +15 lines)
40	#include <unistd.h>	40	#include <unistd.h>
41	#include "un-namespace.h"	41	#include "un-namespace.h"
42		42
		43	#include "libc_private.h"
		44
		45	#pragma weak sleep
		46	unsigned int
		47	sleep(unsigned int seconds)
		48	{
		49
		50	return (((unsigned int (*)(unsigned int))
		51	__libc_interposing[INTERPOS_sleep])(seconds));
		52	}
		53
43	unsigned int	54	unsigned int
44	__sleep(unsigned int seconds)	55	__libc_sleep(unsigned int seconds)
45	{	56	{
46	struct timespec time_to_sleep;	57	struct timespec time_to_sleep;
47	struct timespec time_remaining;	58	struct timespec time_remaining;
Lines 51-57 __sleep(unsigned int seconds) Link Here
51	* the maximum value for a time_t is >= INT_MAX.	62	* the maximum value for a time_t is >= INT_MAX.
52	*/	63	*/
53	if (seconds > INT_MAX)	64	if (seconds > INT_MAX)
54	return (seconds - INT_MAX + __sleep(INT_MAX));	65	return (seconds - INT_MAX + __libc_sleep(INT_MAX));
55		66
56	time_to_sleep.tv_sec = seconds;	67	time_to_sleep.tv_sec = seconds;
57	time_to_sleep.tv_nsec = 0;	68	time_to_sleep.tv_nsec = 0;
Lines 63-67 __sleep(unsigned int seconds) Link Here
63	(time_remaining.tv_nsec != 0)); /* round up */	74	(time_remaining.tv_nsec != 0)); /* round up */
64	}	75	}
65		76
66	__weak_reference(__sleep, sleep);	77	__weak_reference(__libc_sleep, __sleep);
67	__weak_reference(__sleep, _sleep);	78	__weak_reference(__libc_sleep, _sleep);

Removed Link Here

(-)a/lib/libc/gen/swapcontext.c (-55 lines)
1	/*
2	* Copyright (c) 2001 Daniel M. Eischen <deischen@freebsd.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Neither the name of the author nor the names of its contributors
11	* may be used to endorse or promote products derived from this software
12	* without specific prior written permission.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*/
26
27	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");
29
30	#include <sys/param.h>
31	#include <sys/signal.h>
32	#include <sys/ucontext.h>
33
34	#include <errno.h>
35	#include <stddef.h>
36
37	__weak_reference(__swapcontext, swapcontext);
38
39	int
40	__swapcontext(ucontext_t oucp, const ucontext_t ucp)
41	{
42	int ret;
43
44	if ((oucp == NULL) \|\| (ucp == NULL)) {
45	errno = EINVAL;
46	return (-1);
47	}
48	oucp->uc_flags &= ~UCF_SWAPPED;
49	ret = getcontext(oucp);
50	if ((ret == 0) && !(oucp->uc_flags & UCF_SWAPPED)) {
51	oucp->uc_flags \|= UCF_SWAPPED;
52	ret = setcontext(ucp);
53	}
54	return (ret);
55	}

Lines 38-45 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/usleep.c (-3 / +14 lines)
38	#include <unistd.h>	38	#include <unistd.h>
39	#include "un-namespace.h"	39	#include "un-namespace.h"
40		40
		41	#include "libc_private.h"
		42
		43	#pragma weak usleep
		44	int
		45	usleep(useconds_t useconds)
		46	{
		47
		48	return (((int (*)(useconds_t))
		49	__libc_interposing[INTERPOS_usleep])(useconds));
		50	}
		51
41	int	52	int
42	__usleep(useconds_t useconds)	53	__libc_usleep(useconds_t useconds)
43	{	54	{
44	struct timespec time_to_sleep;	55	struct timespec time_to_sleep;
45		56
Lines 48-52 __usleep(useconds_t useconds) Link Here
48	return (_nanosleep(&time_to_sleep, NULL));	59	return (_nanosleep(&time_to_sleep, NULL));
49	}	60	}
50		61
51	__weak_reference(__usleep, usleep);	62	__weak_reference(__libc_usleep, __usleep);
52	__weak_reference(__usleep, _usleep);	63	__weak_reference(__libc_usleep, _usleep);

Lines 40-50 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/gen/wait3.c (-5 / +16 lines)
40	#include <sys/resource.h>	40	#include <sys/resource.h>
41	#include "un-namespace.h"	41	#include "un-namespace.h"
42		42
		43	#include "libc_private.h"
		44
		45	#pragma weak wait3
		46	pid_t
		47	wait3(int istat, int options, struct rusage rup)
		48	{
		49
		50	return (((pid_t ()(int , int, struct rusage *))
		51	__libc_interposing[INTERPOS_wait3])(istat, options, rup));
		52	}
		53
		54	__weak_reference(__libc_wait3, __wait3);
		55
43	pid_t	56	pid_t
44	wait3(istat, options, rup)	57	__libc_wait3(int istat, int options, struct rusage rup)
45	int *istat;
46	int options;
47	struct rusage *rup;
48	{	58	{
49	return (_wait4(WAIT_ANY, istat, options, rup));	59
		60	return (__sys_wait4(WAIT_ANY, istat, options, rup));
50	}	61	}

Lines 173-178 typedef pthread_func_t pthread_func_entry_t[2]; Link Here

(-)b/lib/libc/include/libc_private.h (-20 / +138 lines)
173		173
174	extern pthread_func_entry_t __thr_jtable[];	174	extern pthread_func_entry_t __thr_jtable[];
175		175
		176	extern int (__error_selector)(void);
		177	int _pthread_mutex_init_calloc_cb_stub(pthread_mutex_t *mutex,
		178	void *(calloc_cb)(__size_t, __size_t));
		179
		180	typedef int (*interpos_func_t)(void);
		181	interpos_func_t *__libc_interposing_slot(int interposno);
		182	extern interpos_func_t __libc_interposing[];
		183
		184	enum {
		185	INTERPOS_accept,
		186	INTERPOS_accept4,
		187	INTERPOS_aio_suspend,
		188	INTERPOS_close,
		189	INTERPOS_connect,
		190	INTERPOS_creat,
		191	INTERPOS_fcntl,
		192	INTERPOS_fsync,
		193	INTERPOS_msync,
		194	INTERPOS_nanosleep,
		195	INTERPOS_open,
		196	INTERPOS_openat,
		197	INTERPOS_poll,
		198	INTERPOS_pselect,
		199	INTERPOS_raise,
		200	INTERPOS_recvfrom,
		201	INTERPOS_recvmsg,
		202	INTERPOS_select,
		203	INTERPOS_sendmsg,
		204	INTERPOS_sendto,
		205	INTERPOS_setcontext,
		206	INTERPOS_sigaction,
		207	INTERPOS_sigprocmask,
		208	INTERPOS_sigsuspend,
		209	INTERPOS_sigwait,
		210	INTERPOS_sigtimedwait,
		211	INTERPOS_sigwaitinfo,
		212	INTERPOS_swapcontext,
		213	INTERPOS_system,
		214	INTERPOS_sleep,
		215	INTERPOS_tcdrain,
		216	INTERPOS_usleep,
		217	INTERPOS_pause,
		218	INTERPOS_read,
		219	INTERPOS_readv,
		220	INTERPOS_wait,
		221	INTERPOS_wait3,
		222	INTERPOS_wait4,
		223	INTERPOS_waitpid,
		224	INTERPOS_write,
		225	INTERPOS_writev,
		226	INTERPOS__pthread_mutex_init_calloc_cb,
		227	INTERPOS_MAX
		228	};
		229
176	/*	230	/*
177	* yplib internal interfaces	231	* yplib internal interfaces
178	*/	232	*/
Lines 215-256 void _malloc_thread_cleanup(void); Link Here
215	void _malloc_prefork(void);	269	void _malloc_prefork(void);
216	void _malloc_postfork(void);	270	void _malloc_postfork(void);
217		271
		272	void _malloc_first_thread(void);
		273
218	/*	274	/*
219	* Function to clean up streams, called from abort() and exit().	275	* Function to clean up streams, called from abort() and exit().
220	*/	276	*/
221	extern void (*__cleanup)(void) __hidden;	277	void (*__cleanup)(void) __hidden;
222		278
223	/*	279	/*
224	* Get kern.osreldate to detect ABI revisions. Explicitly	280	* Get kern.osreldate to detect ABI revisions. Explicitly
225	* ignores value of $OSVERSION and caches result. Prototypes	281	* ignores value of $OSVERSION and caches result. Prototypes
226	* for the wrapped "new" pad-less syscalls are here for now.	282	* for the wrapped "new" pad-less syscalls are here for now.
227	*/	283	*/
228	extern int __getosreldate(void);	284	int __getosreldate(void);
229	#include <sys/_types.h>	285	#include <sys/_types.h>
230	/* Without pad */	286	#include <sys/_sigset.h>
231	extern __off_t __sys_lseek(int, __off_t, int);
232	extern int __sys_ftruncate(int, __off_t);
233	extern int __sys_truncate(const char *, __off_t);
234	extern __ssize_t __sys_pread(int, void *, __size_t, __off_t);
235	extern __ssize_t __sys_pwrite(int, const void *, __size_t, __off_t);
236	extern void * __sys_mmap(void *, __size_t, int, int, int, __off_t);
237		287
238	/* With pad */	288	/* With pad */
239	extern __off_t __sys_freebsd6_lseek(int, int, __off_t, int);	289	__off_t __sys_freebsd6_lseek(int, int, __off_t, int);
240	extern int __sys_freebsd6_ftruncate(int, int, __off_t);	290	int __sys_freebsd6_ftruncate(int, int, __off_t);
241	extern int __sys_freebsd6_truncate(const char *, int, __off_t);	291	int __sys_freebsd6_truncate(const char *, int, __off_t);
242	extern __ssize_t __sys_freebsd6_pread(int, void *, __size_t, int, __off_t);	292	__ssize_t __sys_freebsd6_pread(int, void *, __size_t, int, __off_t);
243	extern __ssize_t __sys_freebsd6_pwrite(int, const void *, __size_t, int, __off_t);	293	__ssize_t __sys_freebsd6_pwrite(int, const void *, __size_t, int, __off_t);
244	extern void * __sys_freebsd6_mmap(void *, __size_t, int, int, int, int, __off_t);	294	void * __sys_freebsd6_mmap(void *, __size_t, int, int, int, int, __off_t);
245
246	/* Without back-compat translation */
247	extern int __sys_fcntl(int, int, ...);
248		295
		296	struct aiocb;
		297	struct fd_set;
		298	struct iovec;
		299	struct msghdr;
		300	struct pollfd;
		301	struct rusage;
		302	struct sigaction;
		303	struct sockaddr;
249	struct timespec;	304	struct timespec;
250	struct timeval;	305	struct timeval;
251	struct timezone;	306	struct timezone;
252	int __sys_gettimeofday(struct timeval , struct timezone );	307	struct __siginfo;
253	int __sys_clock_gettime(__clockid_t, struct timespec *ts);	308	struct __ucontext;
		309	int __sys_aio_suspend(const struct aiocb * const[], int,
		310	const struct timespec *);
		311	int __sys_accept(int, struct sockaddr , __socklen_t );
		312	int __sys_accept4(int, struct sockaddr , __socklen_t , int);
		313	int __sys_clock_gettime(__clockid_t, struct timespec *ts);
		314	int __sys_close(int);
		315	int __sys_connect(int, const struct sockaddr *, __socklen_t);
		316	int __sys_fcntl(int, int, ...);
		317	int __sys_fsync(int);
		318	int __sys_ftruncate(int, __off_t);
		319	int __sys_gettimeofday(struct timeval , struct timezone );
		320	__off_t __sys_lseek(int, __off_t, int);
		321	void __sys_mmap(void , __size_t, int, int, int, __off_t);
		322	int __sys_msync(void *, __size_t, int);
		323	int __sys_nanosleep(const struct timespec , struct timespec );
		324	int __sys_open(const char *, int, ...);
		325	int __sys_openat(int, const char *, int, ...);
		326	int __sys_pselect(int, struct fd_set , struct fd_set ,
		327	struct fd_set , const struct timespec ,
		328	const __sigset_t *);
		329	int __sys_poll(struct pollfd *, unsigned, int);
		330	__ssize_t __sys_pread(int, void *, __size_t, __off_t);
		331	__ssize_t __sys_pwrite(int, const void *, __size_t, __off_t);
		332	__ssize_t __sys_read(int, void *, __size_t);
		333	__ssize_t __sys_readv(int, const struct iovec *, int);
		334	__ssize_t __sys_recv(int, void *, __size_t, int);
		335	__ssize_t __sys_recvfrom(int, void , __size_t, int, struct sockaddr ,
		336	__socklen_t *);
		337	__ssize_t __sys_recvmsg(int, struct msghdr *, int);
		338	int __sys_select(int, struct fd_set , struct fd_set ,
		339	struct fd_set , struct timeval );
		340	__ssize_t __sys_sendmsg(int, const struct msghdr *, int);
		341	__ssize_t __sys_sendto(int, const void *, __size_t, int,
		342	const struct sockaddr *, __socklen_t);
		343	int __sys_setcontext(const struct __ucontext *);
		344	int __sys_sigaction(int, const struct sigaction *,
		345	struct sigaction *);
		346	int __sys_sigprocmask(int, const __sigset_t , __sigset_t );
		347	int __sys_sigsuspend(const __sigset_t *);
		348	int __sys_sigtimedwait(const __sigset_t , struct __siginfo ,
		349	const struct timespec *);
		350	int __sys_sigwait(const __sigset_t , int );
		351	int __sys_sigwaitinfo(const __sigset_t , struct __siginfo );
		352	int __sys_swapcontext(struct __ucontext *,
		353	const struct __ucontext *);
		354	int __sys_truncate(const char *, __off_t);
		355	__pid_t __sys_wait4(__pid_t, int , int, struct rusage );
		356	__ssize_t __sys_write(int, const void *, __size_t);
		357	__ssize_t __sys_writev(int, const struct iovec *, int);
		358
		359	int __libc_creat(const char *path, __mode_t mode);
		360	int __libc_pause(void);
		361	int __libc_raise(int);
		362	int __libc_sigwait(const __sigset_t * __restrict,
		363	int * restrict sig);
		364	int __libc_system(const char *);
		365	unsigned int __libc_sleep(unsigned int);
		366	int __libc_tcdrain(int);
		367	int __libc_usleep(__useconds_t);
		368	__pid_t __libc_wait(int *);
		369	__pid_t __libc_wait3(int , int, struct rusage );
		370	__pid_t __libc_waitpid(__pid_t, int *, int);
		371	int __fcntl_compat(int fd, int cmd, ...);
254		372
255	/* execve() with PATH processing to implement posix_spawnp() */	373	/* execve() with PATH processing to implement posix_spawnp() */
256	int _execvpe(const char , char const , char const *);	374	int _execvpe(const char , char const , char const *);

Lines 46-53 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/stdlib/system.c (-3 / +12 lines)
46	#include "un-namespace.h"	46	#include "un-namespace.h"
47	#include "libc_private.h"	47	#include "libc_private.h"
48		48
		49	#pragma weak system
49	int	50	int
50	__system(const char *command)	51	system(const char *command)
		52	{
		53
		54	return (((int ()(const char ))
		55	__libc_interposing[INTERPOS_system])(command));
		56	}
		57
		58	int
		59	__libc_system(const char *command)
51	{	60	{
52	pid_t pid, savedpid;	61	pid_t pid, savedpid;
53	int pstat;	62	int pstat;
Lines 95-99 __system(const char *command) Link Here
95	return(pid == -1 ? -1 : pstat);	104	return(pid == -1 ? -1 : pstat);
96	}	105	}
97		106
98	__weak_reference(__system, system);	107	__weak_reference(__libc_system, __system);
99	__weak_reference(__system, _system);	108	__weak_reference(__libc_system, _system);

Lines 32-45 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/sys/__error.c (-6 / +9 lines)
32		32
33	extern int errno;	33	extern int errno;
34		34
35	/*
36	* Declare a weak reference in case the application is not linked
37	* with libpthread.
38	*/
39	__weak_reference(__error_unthreaded, __error);
40
41	int *	35	int *
42	__error_unthreaded(void)	36	__error_unthreaded(void)
43	{	37	{
44	return(&errno);	38	return(&errno);
45	}	39	}
		40
		41	int (__error_selector)(void) = __error_unthreaded;
		42
		43	int *
		44	__error(void)
		45	{
		46
		47	return (__error_selector());
		48	}

Added Link Here

(-)b/lib/libc/sys/accept.c (+50 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/syscall.h>
38	#include <sys/socket.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_accept, __accept);
42
43	#pragma weak accept
44	int
45	accept(int s, struct sockaddr addr, socklen_t addrlen)
46	{
47
48	return (((int ()(int, struct sockaddr , socklen_t *))
49	__libc_interposing[INTERPOS_accept])(s, addr, addrlen));
50	}

Added Link Here

(-)b/lib/libc/sys/accept4.c (+50 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/syscall.h>
38	#include <sys/socket.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_accept4, __accept4);
42
43	#pragma weak accept4
44	int
45	accept4(int s, struct sockaddr addr, socklen_t addrlen, int flags)
46	{
47
48	return (((int ()(int, struct sockaddr , socklen_t *, int))
49	__libc_interposing[INTERPOS_accept4])(s, addr, addrlen, flags));
50	}

Added Link Here

(-)b/lib/libc/sys/aio_suspend.c (+51 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/aio.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_aio_suspend, __aio_suspend);
41
42	#pragma weak aio_suspend
43	int
44	aio_suspend(const struct aiocb * const iocbs[], int niocb,
45	const struct timespec *timeout)
46	{
47
48	return (((int ()(const struct aiocb const[], int,
49	const struct timespec *))
50	__libc_interposing[INTERPOS_aio_suspend])(iocbs, niocb, timeout));
51	}

Added Link Here

(-)b/lib/libc/sys/close.c (+48 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/fcntl.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_close, __close);
41
42	#pragma weak close
43	int
44	close(int fd)
45	{
46
47	return (((int (*)(int))__libc_interposing[INTERPOS_close])(fd));
48	}

Added Link Here

(-)b/lib/libc/sys/connect.c (+50 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/syscall.h>
38	#include <sys/socket.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_connect, __connect);
42
43	#pragma weak connect
44	int
45	connect(int s, const struct sockaddr *addr, socklen_t addrlen)
46	{
47
48	return (((int ()(int, const struct sockaddr , socklen_t))
49	__libc_interposing[INTERPOS_connect])(s, addr, addrlen));
50	}

Lines 34-40 __FBSDID("$FreeBSD$"); Link Here

(-)b/lib/libc/sys/fcntl.c (-1 / +21 lines)
34	#include <sys/syscall.h>	34	#include <sys/syscall.h>
35	#include "libc_private.h"	35	#include "libc_private.h"
36		36
37	__weak_reference(__fcntl_compat, fcntl);	37	#pragma weak fcntl
		38	int
		39	fcntl(int fd, int cmd, ...)
		40	{
		41	va_list args;
		42	long arg;
		43
		44	va_start(args, cmd);
		45	arg = va_arg(args, long);
		46	va_end(args);
		47
		48	return (((int (*)(int, int, ...))
		49	__libc_interposing[INTERPOS_fcntl])(fd, cmd, arg));
		50	}
		51
		52	#ifdef SYSCALL_COMPAT
		53	__weak_reference(__fcntl_compat, __fcntl);
38		54
39	int	55	int
40	__fcntl_compat(int fd, int cmd, ...)	56	__fcntl_compat(int fd, int cmd, ...)
Lines 87-89 __fcntl_compat(int fd, int cmd, ...) Link Here
87	return (__sys_fcntl(fd, cmd, arg));	103	return (__sys_fcntl(fd, cmd, arg));
88	}	104	}
89	}	105	}
		106	#else
		107	__weak_reference(__sys_fcntl, __fcntl_compat);
		108	__weak_reference(__sys_fcntl, __fcntl);
		109	#endif

Added Link Here

(-)b/lib/libc/sys/fsync.c (+47 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/fcntl.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_fsync, __fsync);
41
42	int
43	fsync(int fd)
44	{
45
46	return (((int (*)(int))__libc_interposing[INTERPOS_fsync])(fd));
47	}

Added Link Here

(-)b/lib/libc/sys/interposing_table.c (+92 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include "libc_private.h"
38
39	#define SLOT(a, b) \
40	[INTERPOS_##a] = (interpos_func_t)b
41	interpos_func_t __libc_interposing[INTERPOS_MAX] = {
42	SLOT(accept, __sys_accept),
43	SLOT(accept4, __sys_accept4),
44	SLOT(aio_suspend, __sys_aio_suspend),
45	SLOT(close, __sys_close),
46	SLOT(connect, __sys_connect),
47	SLOT(creat, __libc_creat),
48	SLOT(fcntl, __fcntl_compat),
49	SLOT(fsync, __sys_fsync),
50	SLOT(msync, __sys_msync),
51	SLOT(nanosleep, __sys_nanosleep),
52	SLOT(open, __sys_open),
53	SLOT(openat, __sys_openat),
54	SLOT(poll, __sys_poll),
55	SLOT(pselect, __sys_pselect),
56	SLOT(raise, __libc_raise),
57	SLOT(read, __sys_read),
58	SLOT(readv, __sys_readv),
59	SLOT(recvfrom, __sys_recvfrom),
60	SLOT(recvmsg, __sys_recvmsg),
61	SLOT(select, __sys_select),
62	SLOT(sendmsg, __sys_sendmsg),
63	SLOT(sendto, __sys_sendto),
64	SLOT(setcontext, __sys_setcontext),
65	SLOT(sigaction, __sys_sigaction),
66	SLOT(sigprocmask, __sys_sigprocmask),
67	SLOT(sigsuspend, __sys_sigsuspend),
68	SLOT(sigwait, __libc_sigwait),
69	SLOT(sigtimedwait, __sys_sigtimedwait),
70	SLOT(sigwaitinfo, __sys_sigwaitinfo),
71	SLOT(swapcontext, __sys_swapcontext),
72	SLOT(system, __libc_system),
73	SLOT(sleep, __libc_sleep),
74	SLOT(tcdrain, __libc_tcdrain),
75	SLOT(usleep, __libc_usleep),
76	SLOT(pause, __libc_pause),
77	SLOT(wait, __libc_wait),
78	SLOT(wait3, __libc_wait3),
79	SLOT(wait4, __sys_wait4),
80	SLOT(waitpid, __libc_waitpid),
81	SLOT(write, __sys_write),
82	SLOT(writev, __sys_writev),
83	SLOT(_pthread_mutex_init_calloc_cb, _pthread_mutex_init_calloc_cb_stub),
84	};
85	#undef SLOT
86
87	interpos_func_t *
88	__libc_interposing_slot(int interposno)
89	{
90
91	return (&__libc_interposing[interposno]);
92	}

Added Link Here

(-)b/lib/libc/sys/msync.c (+49 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/fcntl.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_msync, __msync);
41
42	#pragma weak msync
43	int
44	msync(void *addr, size_t len, int flags)
45	{
46
47	return (((int ()(void , size_t, int))
48	__libc_interposing[INTERPOS_msync])(addr, len, flags));
49	}

Added Link Here

(-)b/lib/libc/sys/nanosleep.c (+49 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <time.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_nanosleep, __nanosleep);
41
42	#pragma weak nanosleep
43	int
44	nanosleep(const struct timespec rqtp, struct timespec rmtp)
45	{
46
47	return (((int ()(const struct timespec , struct timespec *))
48	__libc_interposing[INTERPOS_nanosleep])(rqtp, rmtp));
49	}

Added Link Here

(-)b/lib/libc/sys/open.c (+59 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/fcntl.h>
38	#include <stdarg.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_open, __open);
42
43	#pragma weak open
44	int
45	open(const char *path, int flags, ...)
46	{
47	va_list ap;
48	int mode;
49
50	if ((flags & O_CREAT) != 0) {
51	va_start(ap, flags);
52	mode = va_arg(ap, int);
53	va_end(ap);
54	} else {
55	mode = 0;
56	}
57	return (((int ()(const char , int, ...))
58	__libc_interposing[INTERPOS_open])(path, flags, mode));
59	}

Added Link Here

(-)b/lib/libc/sys/openat.c (+59 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/fcntl.h>
38	#include <stdarg.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_openat, __openat);
42
43	#pragma weak openat
44	int
45	openat(int fd, const char *path, int flags, ...)
46	{
47	va_list ap;
48	int mode;
49
50	if ((flags & O_CREAT) != 0) {
51	va_start(ap, flags);
52	mode = va_arg(ap, int);
53	va_end(ap);
54	} else {
55	mode = 0;
56	}
57	return (((int ()(int, const char , int, ...))
58	__libc_interposing[INTERPOS_openat])(fd, path, flags, mode));
59	}

Added Link Here

(-)b/lib/libc/sys/poll.c (+49 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/poll.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_poll, __poll);
41
42	#pragma weak poll
43	int
44	poll(struct pollfd pfd[], nfds_t nfds, int timeout)
45	{
46
47	return (((int ()(struct pollfd , nfds_t, int))
48	__libc_interposing[INTERPOS_poll])(pfd, nfds, timeout));
49	}

Added Link Here

(-)b/lib/libc/sys/pselect.c (+51 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/select.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_pselect, __pselect);
41
42	#pragma weak pselect
43	int
44	pselect(int n, fd_set rs, fd_set ws, fd_set es, const struct timespec t,
45	const sigset_t *s)
46	{
47
48	return (((int ()(int, fd_set , fd_set , fd_set ,
49	const struct timespec , const sigset_t ))
50	__libc_interposing[INTERPOS_pselect])(n, rs, ws, es, t, s));
51	}

Added Link Here

(-)b/lib/libc/sys/read.c (+50 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/syscall.h>
38	#include <unistd.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_read, __read);
42
43	#pragma weak read
44	ssize_t
45	read(int fd, void *buf, size_t nbytes)
46	{
47
48	return (((ssize_t ()(int, void , size_t))
49	__libc_interposing[INTERPOS_read])(fd, buf, nbytes));
50	}

Added Link Here

(-)b/lib/libc/sys/readv.c (+50 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/syscall.h>
38	#include <unistd.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_readv, __readv);
42
43	#pragma weak readv
44	ssize_t
45	readv(int fd, const struct iovec *iov, int iovcnt)
46	{
47
48	return (((ssize_t ()(int, const struct iovec , int))
49	__libc_interposing[INTERPOS_readv])(fd, iov, iovcnt));
50	}

Added Link Here

(-)b/lib/libc/sys/recvfrom.c (+53 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/syscall.h>
38	#include <sys/socket.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_recvfrom, __recvfrom);
42
43	#pragma weak recvfrom
44	ssize_t
45	recvfrom(int s, void *buf, size_t len, int flags,
46	struct sockaddr * __restrict from, socklen_t * __restrict fromlen)
47	{
48
49	return (((ssize_t ()(int, void , size_t, int,
50	struct sockaddr , socklen_t ))
51	__libc_interposing[INTERPOS_recvfrom])(s, buf, len, flags,
52	from, fromlen));
53	}

Added Link Here

(-)b/lib/libc/sys/recvmsg.c (+50 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/syscall.h>
38	#include <sys/socket.h>
39	#include "libc_private.h"
40
41	__weak_reference(__sys_recvmsg, __recvmsg);
42
43	#pragma weak recvmsg
44	ssize_t
45	recvmsg(int s, struct msghdr *msg, int flags)
46	{
47
48	return (((int ()(int, struct msghdr , int))
49	__libc_interposing[INTERPOS_recvmsg])(s, msg, flags));
50	}

Added Link Here

(-)b/lib/libc/sys/select.c (+49 lines)
1	/*
2	* Copyright (c) 2014 The FreeBSD Foundation.
3	* All rights reserved.
4	*
5	* Portions of this software were developed by Konstantin Belousov
6	* under sponsorship from the FreeBSD Foundation.
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	* 1. Redistributions of source code must retain the above copyright
12	* notice(s), this list of conditions and the following disclaimer as
13	* the first lines of this file unmodified other than the possible
14	* addition of one or more copyright notices.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice(s), this list of conditions and the following disclaimer in
17	* the documentation and/or other materials provided with the
18	* distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
21	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
24	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");
35
36	#include <sys/types.h>
37	#include <sys/select.h>
38	#include "libc_private.h"
39
40	__weak_reference(__sys_select, __select);
41
42	#pragma weak select
43	int
44	select(int n, fd_set rs, fd_set ws, fd_set es, struct timeval t)
45	{
46
47	return (((int ()(int, fd_set , fd_set , fd_set , struct timeval *))
48	__libc_interposing[INTERPOS_select])(n, rs, ws, es, t));
49	}