d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove hacks to allow libkse to export its symbols in the LIBTHREAD_1_0

Browse Source 
version namespace which was needed before the library version was
bumped.
This commit is contained in:
Daniel Eischen 2007-12-16 23:29:57 +00:00
parent 64577b835b
commit 3d6d3ed091
102 changed files with 0 additions and 481 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/libkse/sys/thr_error.c
View File

@ -41,8 +41,6 @@
#undef errno
extern int errno;
LT10_COMPAT_DEFAULT(__error);
int *
__error(void)
{

4
lib/libkse/thread/thr_accept.c
View File

@ -32,12 +32,8 @@ __FBSDID("$FreeBSD$");
#include <pthread.h>
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__accept);
LT10_COMPAT_DEFAULT(accept);
int __accept(int s, struct sockaddr *addr, socklen_t *addrlen);
__weak_reference(__accept, accept);
int

3
lib/libkse/thread/thr_aio_suspend.c
View File

@ -33,9 +33,6 @@
#include <pthread.h>
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_aio_suspend);
LT10_COMPAT_DEFAULT(aio_suspend);
int
_aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct

3
lib/libkse/thread/thr_atfork.c
View File

@ -33,9 +33,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_atfork);
LT10_COMPAT_DEFAULT(pthread_atfork);
__weak_reference(_pthread_atfork, pthread_atfork);
int

3
lib/libkse/thread/thr_attr_destroy.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_destroy);
LT10_COMPAT_DEFAULT(pthread_attr_destroy);
__weak_reference(_pthread_attr_destroy, pthread_attr_destroy);
int

3
lib/libkse/thread/thr_attr_get_np.c
View File

@ -34,9 +34,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_get_np);
LT10_COMPAT_DEFAULT(pthread_attr_get_np);
__weak_reference(_pthread_attr_get_np, pthread_attr_get_np);
int

3
lib/libkse/thread/thr_attr_getdetachstate.c
View File

@ -34,9 +34,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getdetachstate);
LT10_COMPAT_DEFAULT(pthread_attr_getdetachstate);
__weak_reference(_pthread_attr_getdetachstate, pthread_attr_getdetachstate);
int

3
lib/libkse/thread/thr_attr_getguardsize.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getguardsize);
LT10_COMPAT_DEFAULT(pthread_attr_getguardsize);
__weak_reference(_pthread_attr_getguardsize, pthread_attr_getguardsize);
int

3
lib/libkse/thread/thr_attr_getinheritsched.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getinheritsched);
LT10_COMPAT_DEFAULT(pthread_attr_getinheritsched);
__weak_reference(_pthread_attr_getinheritsched, pthread_attr_getinheritsched);
int

3
lib/libkse/thread/thr_attr_getschedparam.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getschedparam);
LT10_COMPAT_DEFAULT(pthread_attr_getschedparam);
__weak_reference(_pthread_attr_getschedparam, pthread_attr_getschedparam);
int

3
lib/libkse/thread/thr_attr_getschedpolicy.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getschedpolicy);
LT10_COMPAT_DEFAULT(pthread_attr_getschedpolicy);
__weak_reference(_pthread_attr_getschedpolicy, pthread_attr_getschedpolicy);
int

3
lib/libkse/thread/thr_attr_getscope.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getscope);
LT10_COMPAT_DEFAULT(pthread_attr_getscope);
__weak_reference(_pthread_attr_getscope, pthread_attr_getscope);
int

3
lib/libkse/thread/thr_attr_getstack.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getstack);
LT10_COMPAT_DEFAULT(pthread_attr_getstack);
__weak_reference(_pthread_attr_getstack, pthread_attr_getstack);
int

3
lib/libkse/thread/thr_attr_getstackaddr.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getstackaddr);
LT10_COMPAT_DEFAULT(pthread_attr_getstackaddr);
__weak_reference(_pthread_attr_getstackaddr, pthread_attr_getstackaddr);
int

3
lib/libkse/thread/thr_attr_getstacksize.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_getstacksize);
LT10_COMPAT_DEFAULT(pthread_attr_getstacksize);
__weak_reference(_pthread_attr_getstacksize, pthread_attr_getstacksize);
int

3
lib/libkse/thread/thr_attr_init.c
View File

@ -37,9 +37,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_init);
LT10_COMPAT_DEFAULT(pthread_attr_init);
__weak_reference(_pthread_attr_init, pthread_attr_init);
int

3
lib/libkse/thread/thr_attr_setcreatesuspend_np.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setcreatesuspend_np);
LT10_COMPAT_DEFAULT(pthread_attr_setcreatesuspend_np);
int _pthread_attr_setcreatesuspend_np(pthread_attr_t *attr);
__weak_reference(_pthread_attr_setcreatesuspend_np, pthread_attr_setcreatesuspend_np);

3
lib/libkse/thread/thr_attr_setdetachstate.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setdetachstate);
LT10_COMPAT_DEFAULT(pthread_attr_setdetachstate);
__weak_reference(_pthread_attr_setdetachstate, pthread_attr_setdetachstate);
int

3
lib/libkse/thread/thr_attr_setguardsize.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setguardsize);
LT10_COMPAT_DEFAULT(pthread_attr_setguardsize);
__weak_reference(_pthread_attr_setguardsize, pthread_attr_setguardsize);
int

3
lib/libkse/thread/thr_attr_setinheritsched.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setinheritsched);
LT10_COMPAT_DEFAULT(pthread_attr_setinheritsched);
__weak_reference(_pthread_attr_setinheritsched, pthread_attr_setinheritsched);
int

3
lib/libkse/thread/thr_attr_setschedparam.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setschedparam);
LT10_COMPAT_DEFAULT(pthread_attr_setschedparam);
__weak_reference(_pthread_attr_setschedparam, pthread_attr_setschedparam);
int

3
lib/libkse/thread/thr_attr_setschedpolicy.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setschedpolicy);
LT10_COMPAT_DEFAULT(pthread_attr_setschedpolicy);
__weak_reference(_pthread_attr_setschedpolicy, pthread_attr_setschedpolicy);
int

3
lib/libkse/thread/thr_attr_setscope.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setscope);
LT10_COMPAT_DEFAULT(pthread_attr_setscope);
__weak_reference(_pthread_attr_setscope, pthread_attr_setscope);
int

3
lib/libkse/thread/thr_attr_setstack.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setstack);
LT10_COMPAT_DEFAULT(pthread_attr_setstack);
__weak_reference(_pthread_attr_setstack, pthread_attr_setstack);
int

3
lib/libkse/thread/thr_attr_setstackaddr.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setstackaddr);
LT10_COMPAT_DEFAULT(pthread_attr_setstackaddr);
__weak_reference(_pthread_attr_setstackaddr, pthread_attr_setstackaddr);
int

3
lib/libkse/thread/thr_attr_setstacksize.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_attr_setstacksize);
LT10_COMPAT_DEFAULT(pthread_attr_setstacksize);
__weak_reference(_pthread_attr_setstacksize, pthread_attr_setstacksize);
int

7
lib/libkse/thread/thr_barrier.c
View File

@ -33,13 +33,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_barrier_init);
LT10_COMPAT_DEFAULT(pthread_barrier_init);
LT10_COMPAT_PRIVATE(_pthread_barrier_wait);
LT10_COMPAT_DEFAULT(pthread_barrier_wait);
LT10_COMPAT_PRIVATE(_pthread_barrier_destroy);
LT10_COMPAT_DEFAULT(pthread_barrier_destroy);
__weak_reference(_pthread_barrier_init, pthread_barrier_init);
__weak_reference(_pthread_barrier_wait, pthread_barrier_wait);
__weak_reference(_pthread_barrier_destroy, pthread_barrier_destroy);

9
lib/libkse/thread/thr_barrierattr.c
View File

@ -35,15 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_barrierattr_destroy);
LT10_COMPAT_DEFAULT(pthread_barrierattr_destroy);
LT10_COMPAT_PRIVATE(_pthread_barrierattr_init);
LT10_COMPAT_DEFAULT(pthread_barrierattr_init);
LT10_COMPAT_PRIVATE(_pthread_barrierattr_setpshared);
LT10_COMPAT_DEFAULT(pthread_barrierattr_setpshared);
LT10_COMPAT_PRIVATE(_pthread_barrierattr_getpshared);
LT10_COMPAT_DEFAULT(pthread_barrierattr_getpshared);
__weak_reference(_pthread_barrierattr_destroy, pthread_barrierattr_destroy);
__weak_reference(_pthread_barrierattr_init, pthread_barrierattr_init);
__weak_reference(_pthread_barrierattr_setpshared,

9
lib/libkse/thread/thr_cancel.c
View File

@ -8,15 +8,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_cancel);
LT10_COMPAT_DEFAULT(pthread_cancel);
LT10_COMPAT_PRIVATE(_pthread_setcancelstate);
LT10_COMPAT_DEFAULT(pthread_setcancelstate);
LT10_COMPAT_PRIVATE(_pthread_setcanceltype);
LT10_COMPAT_DEFAULT(pthread_setcanceltype);
LT10_COMPAT_PRIVATE(_pthread_testcancel);
LT10_COMPAT_DEFAULT(pthread_testcancel);
__weak_reference(_pthread_cancel, pthread_cancel);
__weak_reference(_pthread_setcancelstate, pthread_setcancelstate);
__weak_reference(_pthread_setcanceltype, pthread_setcanceltype);

5
lib/libkse/thread/thr_clean.c
View File

@ -37,11 +37,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_cleanup_push);
LT10_COMPAT_DEFAULT(pthread_cleanup_push);
LT10_COMPAT_PRIVATE(_pthread_cleanup_pop);
LT10_COMPAT_DEFAULT(pthread_cleanup_pop);
__weak_reference(_pthread_cleanup_push, pthread_cleanup_push);
__weak_reference(_pthread_cleanup_pop, pthread_cleanup_pop);

3
lib/libkse/thread/thr_close.c
View File

@ -39,9 +39,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__close);
LT10_COMPAT_DEFAULT(close);
int __close(int fd);
__weak_reference(__close, close);

5
lib/libkse/thread/thr_concurrency.c
View File

@ -36,11 +36,6 @@
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_getconcurrency);
LT10_COMPAT_DEFAULT(pthread_getconcurrency);
LT10_COMPAT_PRIVATE(_pthread_setconcurrency);
LT10_COMPAT_DEFAULT(pthread_setconcurrency);
/*#define DEBUG_CONCURRENCY */
#ifdef DEBUG_CONCURRENCY
#define DBG_MSG stdout_debug

15
lib/libkse/thread/thr_cond.c
View File

@ -37,21 +37,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__pthread_cond_wait);
LT10_COMPAT_PRIVATE(_pthread_cond_wait);
LT10_COMPAT_DEFAULT(pthread_cond_wait);
LT10_COMPAT_PRIVATE(__pthread_cond_timedwait);
LT10_COMPAT_PRIVATE(_pthread_cond_timedwait);
LT10_COMPAT_DEFAULT(pthread_cond_timedwait);
LT10_COMPAT_PRIVATE(_pthread_cond_init);
LT10_COMPAT_DEFAULT(pthread_cond_init);
LT10_COMPAT_PRIVATE(_pthread_cond_destroy);
LT10_COMPAT_DEFAULT(pthread_cond_destroy);
LT10_COMPAT_PRIVATE(_pthread_cond_signal);
LT10_COMPAT_DEFAULT(pthread_cond_signal);
LT10_COMPAT_PRIVATE(_pthread_cond_broadcast);
LT10_COMPAT_DEFAULT(pthread_cond_broadcast);
#define THR_IN_CONDQ(thr) (((thr)->sflags & THR_FLAGS_IN_SYNCQ) != 0)
#define THR_CONDQ_SET(thr) (thr)->sflags |= THR_FLAGS_IN_SYNCQ
#define THR_CONDQ_CLEAR(thr) (thr)->sflags &= ~THR_FLAGS_IN_SYNCQ

3
lib/libkse/thread/thr_condattr_destroy.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_condattr_destroy);
LT10_COMPAT_DEFAULT(pthread_condattr_destroy);
__weak_reference(_pthread_condattr_destroy, pthread_condattr_destroy);
int

3
lib/libkse/thread/thr_condattr_init.c
View File

@ -37,9 +37,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_condattr_init);
LT10_COMPAT_DEFAULT(pthread_condattr_init);
__weak_reference(_pthread_condattr_init, pthread_condattr_init);
int

3
lib/libkse/thread/thr_connect.c
View File

@ -32,9 +32,6 @@ __FBSDID("$FreeBSD$");
#include <pthread.h>
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__connect);
LT10_COMPAT_DEFAULT(connect);
int __connect(int fd, const struct sockaddr *name, socklen_t namelen);
__weak_reference(__connect, connect);

3
lib/libkse/thread/thr_creat.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(___creat);
LT10_COMPAT_DEFAULT(creat);
extern int __creat(const char *, mode_t);
int ___creat(const char *path, mode_t mode);

3
lib/libkse/thread/thr_create.c
View File

@ -44,9 +44,6 @@
#include "thr_private.h"
#include "libc_private.h"
LT10_COMPAT_PRIVATE(_pthread_create);
LT10_COMPAT_DEFAULT(pthread_create);
static void free_thread(struct pthread *curthread, struct pthread *thread);
static int create_stack(struct pthread_attr *pattr);
static void free_stack(struct pthread_attr *pattr);

3
lib/libkse/thread/thr_detach.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_detach);
LT10_COMPAT_DEFAULT(pthread_detach);
__weak_reference(_pthread_detach, pthread_detach);
int

3
lib/libkse/thread/thr_equal.c
View File

@ -34,9 +34,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_equal);
LT10_COMPAT_DEFAULT(pthread_equal);
__weak_reference(_pthread_equal, pthread_equal);
int

3
lib/libkse/thread/thr_execve.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_execve);
LT10_COMPAT_DEFAULT(execve);
__weak_reference(_execve, execve);
int

3
lib/libkse/thread/thr_exit.c
View File

@ -40,9 +40,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_exit);
LT10_COMPAT_DEFAULT(pthread_exit);
void _pthread_exit(void *status);
__weak_reference(_pthread_exit, pthread_exit);

3
lib/libkse/thread/thr_fcntl.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__fcntl);
LT10_COMPAT_DEFAULT(fcntl);
int __fcntl(int fd, int cmd,...);
__weak_reference(__fcntl, fcntl);

3
lib/libkse/thread/thr_fork.c
View File

@ -43,9 +43,6 @@
#include "libc_private.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_fork);
LT10_COMPAT_DEFAULT(fork);
pid_t _fork(void);
__weak_reference(_fork, fork);

3
lib/libkse/thread/thr_fsync.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__fsync);
LT10_COMPAT_DEFAULT(fsync);
int __fsync(int fd);
__weak_reference(__fsync, fsync);

3
lib/libkse/thread/thr_getprio.c
View File

@ -36,9 +36,6 @@
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_getprio);
LT10_COMPAT_DEFAULT(pthread_getprio);
__weak_reference(_pthread_getprio, pthread_getprio);
int

3
lib/libkse/thread/thr_getschedparam.c
View File

@ -38,9 +38,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_getschedparam);
LT10_COMPAT_DEFAULT(pthread_getschedparam);
__weak_reference(_pthread_getschedparam, pthread_getschedparam);
int

3
lib/libkse/thread/thr_info.c
View File

@ -44,9 +44,6 @@
#define NELEMENTS(arr) (sizeof(arr) / sizeof(arr[0]))
#endif
LT10_COMPAT_PRIVATE(_pthread_set_name_np);
LT10_COMPAT_DEFAULT(pthread_set_name_np);
static void dump_thread(int fd, pthread_t pthread, int long_version);
void _pthread_set_name_np(pthread_t thread, char *name);

5
lib/libkse/thread/thr_init.c
View File

@ -66,11 +66,6 @@
#include "libc_private.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_libkse_debug);
LT10_COMPAT_PRIVATE(_thread_activated);
LT10_COMPAT_PRIVATE(_thread_active_threads);
LT10_COMPAT_PRIVATE(_thread_list);
int __pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *);
int __pthread_mutex_lock(pthread_mutex_t *);
int __pthread_mutex_trylock(pthread_mutex_t *);

3
lib/libkse/thread/thr_join.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_join);
LT10_COMPAT_DEFAULT(pthread_join);
__weak_reference(_pthread_join, pthread_join);
int

3
lib/libkse/thread/thr_kill.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_kill);
LT10_COMPAT_DEFAULT(pthread_kill);
__weak_reference(_pthread_kill, pthread_kill);
int

3
lib/libkse/thread/thr_main_np.c
View File

@ -33,9 +33,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_main_np);
LT10_COMPAT_DEFAULT(pthread_main_np);
__weak_reference(_pthread_main_np, pthread_main_np);
/*

3
lib/libkse/thread/thr_mattr_init.c
View File

@ -40,9 +40,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_mutexattr_init);
LT10_COMPAT_DEFAULT(pthread_mutexattr_init);
__weak_reference(_pthread_mutexattr_init, pthread_mutexattr_init);
int

9
lib/libkse/thread/thr_mattr_kind_np.c
View File

@ -35,15 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_mutexattr_setkind_np);
LT10_COMPAT_DEFAULT(pthread_mutexattr_setkind_np);
LT10_COMPAT_PRIVATE(_pthread_mutexattr_getkind_np);
LT10_COMPAT_DEFAULT(pthread_mutexattr_getkind_np);
LT10_COMPAT_PRIVATE(_pthread_mutexattr_gettype);
LT10_COMPAT_DEFAULT(pthread_mutexattr_gettype);
LT10_COMPAT_PRIVATE(_pthread_mutexattr_settype);
LT10_COMPAT_DEFAULT(pthread_mutexattr_settype);
int _pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind);
int _pthread_mutexattr_getkind_np(pthread_mutexattr_t attr);

3
lib/libkse/thread/thr_msync.c
View File

@ -13,9 +13,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__msync);
LT10_COMPAT_DEFAULT(msync);
int __msync(void *addr, size_t len, int flags);
__weak_reference(__msync, msync);

3
lib/libkse/thread/thr_multi_np.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_multi_np);
LT10_COMPAT_DEFAULT(pthread_multi_np);
__weak_reference(_pthread_multi_np, pthread_multi_np);
int

17
lib/libkse/thread/thr_mutex.c
View File

@ -101,23 +101,6 @@ static struct pthread_mutex_attr static_mutex_attr =
PTHREAD_MUTEXATTR_STATIC_INITIALIZER;
static pthread_mutexattr_t static_mattr = &static_mutex_attr;
LT10_COMPAT_PRIVATE(__pthread_mutex_init);
LT10_COMPAT_PRIVATE(_pthread_mutex_init);
LT10_COMPAT_DEFAULT(pthread_mutex_init);
LT10_COMPAT_PRIVATE(__pthread_mutex_lock);
LT10_COMPAT_PRIVATE(_pthread_mutex_lock);
LT10_COMPAT_DEFAULT(pthread_mutex_lock);
LT10_COMPAT_PRIVATE(__pthread_mutex_timedlock);
LT10_COMPAT_PRIVATE(_pthread_mutex_timedlock);
LT10_COMPAT_DEFAULT(pthread_mutex_timedlock);
LT10_COMPAT_PRIVATE(__pthread_mutex_trylock);
LT10_COMPAT_PRIVATE(_pthread_mutex_trylock);
LT10_COMPAT_DEFAULT(pthread_mutex_trylock);
LT10_COMPAT_PRIVATE(_pthread_mutex_destroy);
LT10_COMPAT_DEFAULT(pthread_mutex_destroy);
LT10_COMPAT_PRIVATE(_pthread_mutex_unlock);
LT10_COMPAT_DEFAULT(pthread_mutex_unlock);
/* Single underscore versions provided for libc internal usage: */
__weak_reference(__pthread_mutex_init, pthread_mutex_init);
__weak_reference(__pthread_mutex_lock, pthread_mutex_lock);

9
lib/libkse/thread/thr_mutex_prioceiling.c
View File

@ -40,15 +40,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_mutexattr_getprioceiling);
LT10_COMPAT_DEFAULT(pthread_mutexattr_getprioceiling);
LT10_COMPAT_PRIVATE(_pthread_mutexattr_setprioceiling);
LT10_COMPAT_DEFAULT(pthread_mutexattr_setprioceiling);
LT10_COMPAT_PRIVATE(_pthread_mutex_getprioceiling);
LT10_COMPAT_DEFAULT(pthread_mutex_getprioceiling);
LT10_COMPAT_PRIVATE(_pthread_mutex_setprioceiling);
LT10_COMPAT_DEFAULT(pthread_mutex_setprioceiling);
__weak_reference(_pthread_mutexattr_getprioceiling, pthread_mutexattr_getprioceiling);
__weak_reference(_pthread_mutexattr_setprioceiling, pthread_mutexattr_setprioceiling);
__weak_reference(_pthread_mutex_getprioceiling, pthread_mutex_getprioceiling);

5
lib/libkse/thread/thr_mutex_protocol.c
View File

@ -40,11 +40,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_mutexattr_getprotocol);
LT10_COMPAT_DEFAULT(pthread_mutexattr_getprotocol);
LT10_COMPAT_PRIVATE(_pthread_mutexattr_setprotocol);
LT10_COMPAT_DEFAULT(pthread_mutexattr_setprotocol);
__weak_reference(_pthread_mutexattr_getprotocol, pthread_mutexattr_getprotocol);
__weak_reference(_pthread_mutexattr_setprotocol, pthread_mutexattr_setprotocol);

3
lib/libkse/thread/thr_mutexattr_destroy.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_mutexattr_destroy);
LT10_COMPAT_DEFAULT(pthread_mutexattr_destroy);
__weak_reference(_pthread_mutexattr_destroy, pthread_mutexattr_destroy);
int

4
lib/libkse/thread/thr_nanosleep.c
View File

@ -39,10 +39,6 @@
int __nanosleep(const struct timespec *time_to_sleep,
struct timespec *time_remaining);
LT10_COMPAT_PRIVATE(__nanosleep);
LT10_COMPAT_PRIVATE(_nanosleep);
LT10_COMPAT_DEFAULT(nanosleep);
__weak_reference(__nanosleep, nanosleep);
int

3
lib/libkse/thread/thr_once.c
View File

@ -34,9 +34,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_once);
LT10_COMPAT_DEFAULT(pthread_once);
__weak_reference(_pthread_once, pthread_once);
#define ONCE_NEVER_DONE PTHREAD_NEEDS_INIT

3
lib/libkse/thread/thr_open.c
View File

@ -42,9 +42,6 @@
int __open(const char *path, int flags,...);
LT10_COMPAT_PRIVATE(__open);
LT10_COMPAT_DEFAULT(open);
__weak_reference(__open, open);
int

3
lib/libkse/thread/thr_pause.c
View File

@ -39,9 +39,6 @@ int _pause(void);
extern int __pause(void);
LT10_COMPAT_PRIVATE(_pause);
LT10_COMPAT_DEFAULT(pause);
__weak_reference(_pause, pause);
int

3
lib/libkse/thread/thr_poll.c
View File

@ -44,9 +44,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__poll);
LT10_COMPAT_DEFAULT(poll);
int __poll(struct pollfd *fds, unsigned int nfds, int timeout);
__weak_reference(__poll, poll);

33
lib/libkse/thread/thr_private.h
View File

@ -56,39 +56,6 @@
#include "pthread_md.h"
#endif
/*
* Unfortunately, libpthread had symbol versioning before libc.
* But now libc has symbol versioning, we need to occupy the
* same version namespace in order to override some libc functions.
* So in order to avoid breaking binaries requiring symbols from
* LIBTHREAD_1_0, we need to provide a compatible interface for
* those symbols.
*/
#if 0
#define SYM_LT10(sym) __CONCAT(sym, _lt10)
#define SYM_FB10(sym) __CONCAT(sym, _fb10)
#define SYM_FBP10(sym) __CONCAT(sym, _fbp10)
#define WEAK_REF(sym, alias) __weak_reference(sym, alias)
#define SYM_COMPAT(sym, impl, ver) __sym_compat(sym, impl, ver)
#define SYM_DEFAULT(sym, impl, ver) __sym_default(sym, impl, ver)
#define LT10_COMPAT(sym) \
WEAK_REF(sym, SYM_LT10(sym)); \
SYM_COMPAT(sym, SYM_LT10(sym), LIBTHREAD_1_0)
#define LT10_COMPAT_DEFAULT(sym) \
LT10_COMPAT(sym); \
WEAK_REF(sym, SYM_FB10(sym)); \
SYM_DEFAULT(sym, SYM_FB10(sym), FBSD_1.0)
#define LT10_COMPAT_PRIVATE(sym) \
LT10_COMPAT(sym); \
WEAK_REF(sym, SYM_FBP10(sym)); \
SYM_DEFAULT(sym, SYM_FBP10(sym), FBSDprivate_1.0)
#else
#define LT10_COMPAT_DEFAULT(sym)
#define LT10_COMPAT_PRIVATE(sym)
#endif
/*
* Evaluate the storage class specifier.

3
lib/libkse/thread/thr_pselect.c
View File

@ -44,9 +44,6 @@ extern int __pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds,
int _pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds,
const struct timespec *timo, const sigset_t *mask);
LT10_COMPAT_PRIVATE(_pselect);
LT10_COMPAT_DEFAULT(pselect);
__weak_reference(_pselect, pselect);
int

11
lib/libkse/thread/thr_pspinlock.c
View File

@ -39,17 +39,6 @@
#define SPIN_COUNT 10000
LT10_COMPAT_PRIVATE(_pthread_spin_init);
LT10_COMPAT_DEFAULT(pthread_spin_init);
LT10_COMPAT_PRIVATE(_pthread_spin_destroy);
LT10_COMPAT_DEFAULT(pthread_spin_destroy);
LT10_COMPAT_PRIVATE(_pthread_spin_trylock);
LT10_COMPAT_DEFAULT(pthread_spin_trylock);
LT10_COMPAT_PRIVATE(_pthread_spin_lock);
LT10_COMPAT_DEFAULT(pthread_spin_lock);
LT10_COMPAT_PRIVATE(_pthread_spin_unlock);
LT10_COMPAT_DEFAULT(pthread_spin_unlock);
__weak_reference(_pthread_spin_init, pthread_spin_init);
__weak_reference(_pthread_spin_destroy, pthread_spin_destroy);
__weak_reference(_pthread_spin_trylock, pthread_spin_trylock);

3
lib/libkse/thread/thr_raise.c
View File

@ -37,9 +37,6 @@
int _raise(int sig);
LT10_COMPAT_PRIVATE(_raise);
LT10_COMPAT_DEFAULT(raise);
__weak_reference(_raise, raise);
int

3
lib/libkse/thread/thr_read.c
View File

@ -42,9 +42,6 @@
ssize_t __read(int fd, void *buf, size_t nbytes);
LT10_COMPAT_PRIVATE(__read);
LT10_COMPAT_DEFAULT(read);
__weak_reference(__read, read);
ssize_t

3
lib/libkse/thread/thr_readv.c
View File

@ -42,9 +42,6 @@
ssize_t __readv(int fd, const struct iovec *iov, int iovcnt);
LT10_COMPAT_PRIVATE(__readv);
LT10_COMPAT_DEFAULT(readv);
__weak_reference(__readv, readv);
ssize_t

5
lib/libkse/thread/thr_resume_np.c
View File

@ -40,11 +40,6 @@ void _pthread_resume_all_np(void);
static struct kse_mailbox *resume_common(struct pthread *);
LT10_COMPAT_PRIVATE(_pthread_resume_np);
LT10_COMPAT_DEFAULT(pthread_resume_np);
LT10_COMPAT_PRIVATE(_pthread_resume_all_np);
LT10_COMPAT_DEFAULT(pthread_resume_all_np);
__weak_reference(_pthread_resume_np, pthread_resume_np);
__weak_reference(_pthread_resume_all_np, pthread_resume_all_np);

19
lib/libkse/thread/thr_rwlock.c
View File

@ -37,25 +37,6 @@
/* maximum number of times a read lock may be obtained */
#define MAX_READ_LOCKS (INT_MAX - 1)
LT10_COMPAT_PRIVATE(_pthread_rwlock_destroy);
LT10_COMPAT_DEFAULT(pthread_rwlock_destroy);
LT10_COMPAT_PRIVATE(_pthread_rwlock_init);
LT10_COMPAT_DEFAULT(pthread_rwlock_init);
LT10_COMPAT_PRIVATE(_pthread_rwlock_rdlock);
LT10_COMPAT_DEFAULT(pthread_rwlock_rdlock);
LT10_COMPAT_PRIVATE(_pthread_rwlock_timedrdlock);
LT10_COMPAT_DEFAULT(pthread_rwlock_timedrdlock);
LT10_COMPAT_PRIVATE(_pthread_rwlock_tryrdlock);
LT10_COMPAT_DEFAULT(pthread_rwlock_tryrdlock);
LT10_COMPAT_PRIVATE(_pthread_rwlock_trywrlock);
LT10_COMPAT_DEFAULT(pthread_rwlock_trywrlock);
LT10_COMPAT_PRIVATE(_pthread_rwlock_unlock);
LT10_COMPAT_DEFAULT(pthread_rwlock_unlock);
LT10_COMPAT_PRIVATE(_pthread_rwlock_wrlock);
LT10_COMPAT_DEFAULT(pthread_rwlock_wrlock);
LT10_COMPAT_PRIVATE(_pthread_rwlock_timedwrlock);
LT10_COMPAT_DEFAULT(pthread_rwlock_timedwrlock);
__weak_reference(_pthread_rwlock_destroy, pthread_rwlock_destroy);
__weak_reference(_pthread_rwlock_init, pthread_rwlock_init);
__weak_reference(_pthread_rwlock_rdlock, pthread_rwlock_rdlock);

9
lib/libkse/thread/thr_rwlockattr.c
View File

@ -33,15 +33,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_rwlockattr_destroy);
LT10_COMPAT_DEFAULT(pthread_rwlockattr_destroy);
LT10_COMPAT_PRIVATE(_pthread_rwlockattr_getpshared);
LT10_COMPAT_DEFAULT(pthread_rwlockattr_getpshared);
LT10_COMPAT_PRIVATE(_pthread_rwlockattr_init);
LT10_COMPAT_DEFAULT(pthread_rwlockattr_init);
LT10_COMPAT_PRIVATE(_pthread_rwlockattr_setpshared);
LT10_COMPAT_DEFAULT(pthread_rwlockattr_setpshared);
__weak_reference(_pthread_rwlockattr_destroy, pthread_rwlockattr_destroy);
__weak_reference(_pthread_rwlockattr_getpshared, pthread_rwlockattr_getpshared);
__weak_reference(_pthread_rwlockattr_init, pthread_rwlockattr_init);

3
lib/libkse/thread/thr_select.c
View File

@ -46,9 +46,6 @@
int __select(int numfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
LT10_COMPAT_PRIVATE(__select);
LT10_COMPAT_DEFAULT(select);
__weak_reference(__select, select);
int

3
lib/libkse/thread/thr_self.c
View File

@ -34,9 +34,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_self);
LT10_COMPAT_DEFAULT(pthread_self);
__weak_reference(_pthread_self, pthread_self);
pthread_t

9
lib/libkse/thread/thr_sem.c
View File

@ -43,15 +43,6 @@
#include "libc_private.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_sem_init);
LT10_COMPAT_DEFAULT(sem_init);
LT10_COMPAT_PRIVATE(_sem_wait);
LT10_COMPAT_DEFAULT(sem_wait);
LT10_COMPAT_PRIVATE(_sem_timedwait);
LT10_COMPAT_DEFAULT(sem_timedwait);
LT10_COMPAT_PRIVATE(_sem_post);
LT10_COMPAT_DEFAULT(sem_post);
__weak_reference(_sem_init, sem_init);
__weak_reference(_sem_wait, sem_wait);
__weak_reference(_sem_timedwait, sem_timedwait);

3
lib/libkse/thread/thr_setprio.c
View File

@ -36,9 +36,6 @@
int _pthread_setprio(pthread_t pthread, int prio);
LT10_COMPAT_PRIVATE(_pthread_setprio);
LT10_COMPAT_DEFAULT(pthread_setprio);
__weak_reference(_pthread_setprio, pthread_setprio);
int

3
lib/libkse/thread/thr_setschedparam.c
View File

@ -39,9 +39,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_setschedparam);
LT10_COMPAT_DEFAULT(pthread_setschedparam);
__weak_reference(_pthread_setschedparam, pthread_setschedparam);
int

3
lib/libkse/thread/thr_sigaction.c
View File

@ -36,9 +36,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_sigaction);
LT10_COMPAT_DEFAULT(sigaction);
__weak_reference(_sigaction, sigaction);
int

3
lib/libkse/thread/thr_sigaltstack.c
View File

@ -35,9 +35,6 @@ __FBSDID("$FreeBSD$");
int _sigaltstack(stack_t *_ss, stack_t *_oss);
LT10_COMPAT_PRIVATE(_sigaltstack);
LT10_COMPAT_DEFAULT(sigaltstack);
__weak_reference(_sigaltstack, sigaltstack);
int

3
lib/libkse/thread/thr_sigmask.c
View File

@ -40,9 +40,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_sigmask);
LT10_COMPAT_DEFAULT(pthread_sigmask);
__weak_reference(_pthread_sigmask, pthread_sigmask);
int

3
lib/libkse/thread/thr_sigpending.c
View File

@ -44,9 +44,6 @@
int _sigpending(sigset_t *set);
LT10_COMPAT_PRIVATE(_sigpending);
LT10_COMPAT_DEFAULT(sigpending);
__weak_reference(_sigpending, sigpending);
int

3
lib/libkse/thread/thr_sigprocmask.c
View File

@ -39,9 +39,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_sigprocmask);
LT10_COMPAT_DEFAULT(sigprocmask);
__weak_reference(_sigprocmask, sigprocmask);
int

4
lib/libkse/thread/thr_sigsuspend.c
View File

@ -41,10 +41,6 @@
int __sigsuspend(const sigset_t * set);
LT10_COMPAT_PRIVATE(__sigsuspend);
LT10_COMPAT_PRIVATE(_sigsuspend);
LT10_COMPAT_DEFAULT(sigsuspend);
__weak_reference(__sigsuspend, sigsuspend);
int

10
lib/libkse/thread/thr_sigwait.c
View File

@ -48,16 +48,6 @@ int _sigtimedwait(const sigset_t *set, siginfo_t *info,
int _sigwaitinfo(const sigset_t *set, siginfo_t *info);
int _sigwait(const sigset_t *set, int *sig);
LT10_COMPAT_PRIVATE(__sigwait);
LT10_COMPAT_PRIVATE(_sigwait);
LT10_COMPAT_DEFAULT(sigwait);
LT10_COMPAT_PRIVATE(__sigtimedwait);
LT10_COMPAT_PRIVATE(_sigtimedwait);
LT10_COMPAT_DEFAULT(sigtimedwait);
LT10_COMPAT_PRIVATE(__sigwaitinfo);
LT10_COMPAT_PRIVATE(_sigwaitinfo);
LT10_COMPAT_DEFAULT(sigwaitinfo);
__weak_reference(__sigwait, sigwait);
__weak_reference(__sigtimedwait, sigtimedwait);
__weak_reference(__sigwaitinfo, sigwaitinfo);

3
lib/libkse/thread/thr_single_np.c
View File

@ -35,9 +35,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_single_np);
LT10_COMPAT_DEFAULT(pthread_single_np);
int _pthread_single_np(void);
__weak_reference(_pthread_single_np, pthread_single_np);

5
lib/libkse/thread/thr_sleep.c
View File

@ -40,11 +40,6 @@ extern int __usleep(useconds_t);
unsigned int _sleep(unsigned int seconds);
LT10_COMPAT_PRIVATE(_sleep);
LT10_COMPAT_DEFAULT(sleep);
LT10_COMPAT_PRIVATE(_usleep);
LT10_COMPAT_DEFAULT(usleep);
__weak_reference(_sleep, sleep);
__weak_reference(_usleep, usleep);

15
lib/libkse/thread/thr_spec.c
View File

@ -41,21 +41,6 @@
struct pthread_key _thread_keytable[PTHREAD_KEYS_MAX];
/*
* XXX - This breaks the linker if LT10_COMPAT_DEFAULT doesn't
* also include a weak reference to the default symbol.
*/
LT10_COMPAT_PRIVATE(_thread_keytable);
LT10_COMPAT_PRIVATE(_pthread_key_create);
LT10_COMPAT_DEFAULT(pthread_key_create);
LT10_COMPAT_PRIVATE(_pthread_key_delete);
LT10_COMPAT_DEFAULT(pthread_key_delete);
LT10_COMPAT_PRIVATE(_pthread_getspecific);
LT10_COMPAT_DEFAULT(pthread_getspecific);
LT10_COMPAT_PRIVATE(_pthread_setspecific);
LT10_COMPAT_DEFAULT(pthread_setspecific);
__weak_reference(_pthread_key_create, pthread_key_create);
__weak_reference(_pthread_key_delete, pthread_key_delete);
__weak_reference(_pthread_getspecific, pthread_getspecific);

4
lib/libkse/thread/thr_spinlock.c
View File

@ -65,10 +65,6 @@ static struct spinlock_extra extra[MAX_SPINLOCKS];
static int spinlock_count = 0;
static int initialized = 0;
LT10_COMPAT_PRIVATE(_spinlock);
LT10_COMPAT_PRIVATE(_spinlock_debug);
LT10_COMPAT_PRIVATE(_spinunlock);
/*
* These are for compatability only. Spinlocks of this type
* are deprecated.

5
lib/libkse/thread/thr_suspend_np.c
View File

@ -40,11 +40,6 @@ void _pthread_suspend_all_np(void);
static void suspend_common(struct pthread *thread);
LT10_COMPAT_PRIVATE(_pthread_suspend_np);
LT10_COMPAT_DEFAULT(pthread_suspend_np);
LT10_COMPAT_PRIVATE(_pthread_suspend_all_np);
LT10_COMPAT_DEFAULT(pthread_suspend_all_np);
__weak_reference(_pthread_suspend_np, pthread_suspend_np);
__weak_reference(_pthread_suspend_all_np, pthread_suspend_all_np);

5
lib/libkse/thread/thr_switch_np.c
View File

@ -39,11 +39,6 @@
#include "un-namespace.h"
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_pthread_switch_add_np);
LT10_COMPAT_DEFAULT(pthread_switch_add_np);
LT10_COMPAT_PRIVATE(_pthread_switch_delete_np);
LT10_COMPAT_DEFAULT(pthread_switch_delete_np);
__weak_reference(_pthread_switch_add_np, pthread_switch_add_np);
__weak_reference(_pthread_switch_delete_np, pthread_switch_delete_np);

18
lib/libkse/thread/thr_symbols.c
View File

@ -38,24 +38,6 @@
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_thread_off_tcb);
LT10_COMPAT_PRIVATE(_thread_off_tmbx);
LT10_COMPAT_PRIVATE(_thread_off_next);
LT10_COMPAT_PRIVATE(_thread_off_attr_flags);
LT10_COMPAT_PRIVATE(_thread_off_kse);
LT10_COMPAT_PRIVATE(_thread_off_kse_locklevel);
LT10_COMPAT_PRIVATE(_thread_off_thr_locklevel);
LT10_COMPAT_PRIVATE(_thread_off_linkmap);
LT10_COMPAT_PRIVATE(_thread_off_tlsindex);
LT10_COMPAT_PRIVATE(_thread_size_key);
LT10_COMPAT_PRIVATE(_thread_off_key_allocated);
LT10_COMPAT_PRIVATE(_thread_off_key_destructor);
LT10_COMPAT_PRIVATE(_thread_max_keys);
LT10_COMPAT_PRIVATE(_thread_off_dtv);
LT10_COMPAT_PRIVATE(_thread_off_state);
LT10_COMPAT_PRIVATE(_thread_state_running);
LT10_COMPAT_PRIVATE(_thread_state_zoombie);
/* A collection of symbols needed by debugger */
/* int _libkse_debug */

3
lib/libkse/thread/thr_system.c
View File

@ -39,9 +39,6 @@ int _system(const char *string);
extern int __system(const char *);
LT10_COMPAT_PRIVATE(_system);
LT10_COMPAT_DEFAULT(system);
__weak_reference(_system, system);
int

3
lib/libkse/thread/thr_tcdrain.c
View File

@ -38,9 +38,6 @@
int _tcdrain(int fd);
extern int __tcdrain(int);
LT10_COMPAT_PRIVATE(_tcdrain);
LT10_COMPAT_DEFAULT(tcdrain);
__weak_reference(_tcdrain, tcdrain);
int

3
lib/libkse/thread/thr_vfork.c
View File

@ -5,9 +5,6 @@
#include <unistd.h>
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_vfork);
LT10_COMPAT_DEFAULT(vfork);
int _vfork(void);
__weak_reference(_vfork, vfork);

3
lib/libkse/thread/thr_wait.c
View File

@ -32,9 +32,6 @@
#include <pthread.h>
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_wait);
LT10_COMPAT_DEFAULT(wait);
extern int __wait(int *);
pid_t _wait(int *istat);

3
lib/libkse/thread/thr_wait4.c
View File

@ -38,9 +38,6 @@
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__wait4);
LT10_COMPAT_DEFAULT(wait4);
pid_t __wait4(pid_t pid, int *istat, int options, struct rusage *rusage);
__weak_reference(__wait4, wait4);

3
lib/libkse/thread/thr_waitpid.c
View File

@ -34,9 +34,6 @@
#include <pthread.h>
#include "thr_private.h"
LT10_COMPAT_PRIVATE(_waitpid);
LT10_COMPAT_DEFAULT(waitpid);
extern int __waitpid(pid_t, int *, int);
pid_t _waitpid(pid_t wpid, int *status, int options);

3
lib/libkse/thread/thr_write.c
View File

@ -37,9 +37,6 @@
#include <pthread.h>
#include "thr_private.h"
LT10_COMPAT_PRIVATE(__write);
LT10_COMPAT_DEFAULT(write);
__ssize_t __write(int fd, const void *buf, size_t nbytes);
__weak_reference(__write, write);

Some files were not shown because too many files have changed in this diff Show More