diff options
Diffstat (limited to 'devel/linuxthreads')
| -rw-r--r-- | devel/linuxthreads/Makefile | 8 | ||||
| -rw-r--r-- | devel/linuxthreads/distinfo | 2 | ||||
| -rw-r--r-- | devel/linuxthreads/files/freebsd-compat.h | 92 | ||||
| -rw-r--r-- | devel/linuxthreads/files/gethostby_r.c | 2 | ||||
| -rw-r--r-- | devel/linuxthreads/files/libc_thread.c | 39 | ||||
| -rw-r--r-- | devel/linuxthreads/files/localtime.c | 1739 | ||||
| -rw-r--r-- | devel/linuxthreads/files/patch-aa | 937 | ||||
| -rw-r--r-- | devel/linuxthreads/files/wraputhread.c | 10 | ||||
| -rw-r--r-- | devel/linuxthreads/pkg-plist | 3 |
9 files changed, 2398 insertions, 434 deletions
diff --git a/devel/linuxthreads/Makefile b/devel/linuxthreads/Makefile index 6a78f68b275e..08616fd35571 100644 --- a/devel/linuxthreads/Makefile +++ b/devel/linuxthreads/Makefile @@ -6,13 +6,15 @@ # PORTNAME= linuxthreads -PORTVERSION= 2.1.3 -PORTREVISION= 2 +PORTVERSION= 2.2.3 +PORTREVISION= 0 CATEGORIES= devel MASTER_SITES= ${MASTER_SITE_GNU} MASTER_SITE_SUBDIR= glibc DISTNAME= glibc-linuxthreads-${PORTVERSION} +NO_FILTER_SHLIBS = true + MAINTAINER= tegge@freebsd.org .include <bsd.port.pre.mk> @@ -27,7 +29,7 @@ BROKEN="Requires FreeBSD 4.0 or newer" threads_files := README.FreeBSD clone.S clone.h freebsd-compat.h getgr_r.c \ gethostby_r.c getnetby_r.c getprotoby_r.c getpw_r.c getservby_r.c \ lclone.c libc_calls.c libc_thread.c sched.c uthread_file.c \ - wraputhread.c + wraputhread.c localtime.c WRKSRC= ${WRKDIR}/${PKGNAME} SRC_BASE= /usr/src diff --git a/devel/linuxthreads/distinfo b/devel/linuxthreads/distinfo index 39090a42f533..9b33ecf88bb9 100644 --- a/devel/linuxthreads/distinfo +++ b/devel/linuxthreads/distinfo @@ -1 +1 @@ -MD5 (glibc-linuxthreads-2.1.3.tar.gz) = 14352cd699b5c751004438d644a6059c +MD5 (glibc-linuxthreads-2.2.3.tar.gz) = 46e9e722fbac89f0a94a8de872d3d39f diff --git a/devel/linuxthreads/files/freebsd-compat.h b/devel/linuxthreads/files/freebsd-compat.h index 6e1c7b89c747..83041c3dfcff 100644 --- a/devel/linuxthreads/files/freebsd-compat.h +++ b/devel/linuxthreads/files/freebsd-compat.h @@ -6,14 +6,57 @@ #include <sys/time.h> +#if __FreeBSD__ >= 5 +#define __libc_accept __sys_accept +#define __libc_close __sys_close +#define __libc_connect __sys_connect +#define __libc_fcntl __sys_fcntl +#define __libc_fork __sys_fork +#define __libc_fsync __sys_fsync +#define __libc_nanosleep __sys_nanosleep +#define __libc_open __sys_open +#define __libc_read __sys_read +#define __libc_waitpid __waitpid +#define __libc_write __sys_write +#define __libc_longjmp __longjmp +#define __libc_siglongjmp __siglongjmp +#define __libc_msync __sys_msync +#define __libc_recvfrom __sys_recvfrom +#define __libc_recvmsg __sys_recvmsg +#define __libc_sendmsg __sys_sendmsg +#define __libc_sendto __sys_sendto +#define __libc_sigaction __sys_sigaction +#define __libc_poll __sys_poll +#define __libc_getpid __sys_getpid +#else +#define __libc_accept _accept #define __libc_close _close +#define __libc_connect _connect +#define __libc_fcntl _fcntl +#define __libc_fork _fork +#define __libc_fsync _fsync #define __libc_nanosleep _nanosleep +#define __libc_open _open #define __libc_read _read -#define __libc_waitpid waitpid +#define __libc_waitpid __waitpid #define __libc_write _write #define __libc_longjmp __longjmp #define __libc_siglongjmp __siglongjmp -#define __libc_fork _fork +#define __libc_msync _msync +#define __libc_recvfrom _recvfrom +#define __libc_recvmsg _recvmsg +#define __libc_sendmsg _sendmsg +#define __libc_sendto _sendto +#define __libc_sigaction _sigaction +#define __libc_poll _poll +#define __libc_getpid _getpid +#endif +#define __libc_wait __wait +#define __libc_system __system +#define __getpid __libc_getpid +#define __poll __libc_poll +#define __libc_tcdrain __tcdrain +#define __libc_pause __pause #define __libc_current_sigrtmin current_sigrtmin #define __libc_current_sigrtmax current_sigrtmax #define __libc_allocate_rtsig allocate_rtsig @@ -25,18 +68,55 @@ #define __sched_getscheduler sched_getscheduler #define __sched_getparam sched_getparam #define __gettimeofday _gettimeofday -#define __poll _poll -#define __getpid _getpid #define __jmp_buf jmp_buf -#define __sigaction _sigaction #define _h_errno h_errno #define __ptr_t void * #define __pid_t pid_t +ssize_t __libc_write(int, const void *, size_t); +ssize_t __libc_read(int, void *, size_t); +pid_t __libc_waitpid(pid_t wpid, int *status, int options); +int __libc_poll(struct pollfd *_pfd, unsigned int _nfsd, int _timeout); +pid_t __libc_getpid(void); +pid_t __libc_waitpid(pid_t, int *, int); +int __libc_sigaction(int, const struct sigaction *, struct sigaction *); +int __libc_fcntl(int, int, ...); +int __libc_fsync(int); +int __libc_msync(void *, size_t, int); +int __libc_open(const char *, int, ...); +int __libc_pause(void); +ssize_t __libc_pwrite(int, const void *, size_t, off_t); +ssize_t __libc_pread(int, void *, size_t, off_t); +int __libc_tcdrain(int); +pid_t __libc_wait(int *); +int __libc_system(const char *); +int __libc_accept(int s, struct sockaddr *addr, socklen_t *addrlen); +int __libc_connect(int, const struct sockaddr *, socklen_t); +ssize_t __libc_recvfrom(int, void *, size_t, int, struct sockaddr *, + socklen_t *); +ssize_t __libc_recvmsg(int, struct msghdr *, int); +ssize_t __libc_sendmsg(int, const struct msghdr *, int); +ssize_t __libc_sendto(int, const void *, + size_t, int, const struct sockaddr *, socklen_t); + #ifndef __P # define __P(args) args #endif +#ifndef __THROW +#define __THROW +#endif + +#ifndef __restrict +#define __restrict +#endif + +#define SHLIB_COMPAT(lib, old, new) 0 + +#define versioned_symbol(libname, realname, aliasname, libver) __strong_reference(realname,aliasname) + +#define link_warning(symbol, warning) __warn_references(symbol, warning); + #ifndef __PMT # define __PMT(args) args #endif @@ -49,7 +129,7 @@ #define ENOTSUP EOPNOTSUPP -#define __builtin_expect(x,y) (x) == (y) +#define __builtin_expect(x,y) (x) #define internal_function diff --git a/devel/linuxthreads/files/gethostby_r.c b/devel/linuxthreads/files/gethostby_r.c index 11ee9cd7ff18..c5c88355ffc1 100644 --- a/devel/linuxthreads/files/gethostby_r.c +++ b/devel/linuxthreads/files/gethostby_r.c @@ -105,6 +105,7 @@ convert (struct hostent *host, struct hostent *result, return 0; } +#if __FreeBSD__ < 5 struct hostent * gethostbyaddr_r (const char *addr, int length, int type, struct hostent *result, char *buffer, int buflen, @@ -124,6 +125,7 @@ gethostbyaddr_r (const char *addr, int length, int type, pthread_mutex_unlock (&gethostby_mutex); return result; } +#endif struct hostent * gethostbyname_r (const char *name, diff --git a/devel/linuxthreads/files/libc_thread.c b/devel/linuxthreads/files/libc_thread.c index 0978796d952c..b58de1990a91 100644 --- a/devel/linuxthreads/files/libc_thread.c +++ b/devel/linuxthreads/files/libc_thread.c @@ -68,38 +68,6 @@ extern int __isthreaded; int _posix_priority_scheduling; #endif -#if defined(NEWLIBC) -/* The following are needed if we're going to get thread safe behavior - * in the time functions in lib/libc/stdtime/localtime.c - */ -#if defined(COMPILING_UTHREADS) -static struct pthread_mutex _lcl_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER; -static struct pthread_mutex _gmt_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER; -static struct pthread_mutex _localtime_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER; -static struct pthread_mutex _gmtime_mutexd = PTHREAD_MUTEX_STATIC_INITIALIZER; -static pthread_mutex_t _lcl_mutex = &_lcl_mutexd; -static pthread_mutex_t _gmt_mutex = &_gmt_mutexd; -static pthread_mutex_t _localtime_mutex = &_localtime_mutexd; -static pthread_mutex_t _gmtime_mutex = &_gmtime_mutexd; -#endif -#if defined(LINUXTHREADS) -static pthread_mutex_t _lcl_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _gmt_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _localtime_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _gmtime_mutex = PTHREAD_MUTEX_INITIALIZER; -#else -/* Customize this based on your mutex declarations */ -static pthread_mutex_t _lcl_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _gmt_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _localtime_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _gmtime_mutex = PTHREAD_MUTEX_INITIALIZER; -#endif -extern pthread_mutex_t *lcl_mutex; -extern pthread_mutex_t *gmt_mutex; -extern pthread_mutex_t *localtime_mutex; -extern pthread_mutex_t *gmtime_mutex; -#endif - void *lock_create (void *context); void rlock_acquire (void *lock); void wlock_acquire (void *lock); @@ -127,13 +95,6 @@ static void _pthread_initialize(void) /* This turns on thread safe behaviour in libc when we link with it */ __isthreaded = 1; -#if defined(NEWLIBC) - /* Set up pointers for lib/libc/stdtime/localtime.c */ - lcl_mutex = &_lcl_mutex; - gmt_mutex = &_gmt_mutex; - localtime_mutex = &_localtime_mutex; - gmtime_mutex = &_gmtime_mutex; -#endif } void _spinlock (int * spinlock) diff --git a/devel/linuxthreads/files/localtime.c b/devel/linuxthreads/files/localtime.c new file mode 100644 index 000000000000..81fb3740dfbb --- /dev/null +++ b/devel/linuxthreads/files/localtime.c @@ -0,0 +1,1739 @@ +/* +** This file is in the public domain, so clarified as of +** June 5, 1996 by Arthur David Olson (arthur_david_olson@nih.gov). +** +** $FreeBSD: /tmp/pcvs/ports/devel/linuxthreads/files/localtime.c,v 1.1 2001-06-14 01:34:18 tegge Exp $ +*/ + +#ifndef lint +#ifndef NOID +static char elsieid[] __attribute__ ((unused)) = "@(#)localtime.c 7.57"; +#endif /* !defined NOID */ +#endif /* !defined lint */ + +/* +** Leap second handling from Bradley White (bww@k.gp.cs.cmu.edu). +** POSIX-style TZ environment variable handling from Guy Harris +** (guy@auspex.com). +*/ + +/*LINTLIBRARY*/ + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <pthread.h> +#include "private.h" + +#include "tzfile.h" + +#define __isthreaded 1 +#define _MUTEX_LOCK(x) if (__isthreaded) pthread_mutex_lock(x) +#define _MUTEX_UNLOCK(x) if (__isthreaded) pthread_mutex_unlock(x) + +/* +** SunOS 4.1.1 headers lack O_BINARY. +*/ + +#ifdef O_BINARY +#define OPEN_MODE (O_RDONLY | O_BINARY) +#endif /* defined O_BINARY */ +#ifndef O_BINARY +#define OPEN_MODE O_RDONLY +#endif /* !defined O_BINARY */ + +#ifndef WILDABBR +/* +** Someone might make incorrect use of a time zone abbreviation: +** 1. They might reference tzname[0] before calling tzset (explicitly +** or implicitly). +** 2. They might reference tzname[1] before calling tzset (explicitly +** or implicitly). +** 3. They might reference tzname[1] after setting to a time zone +** in which Daylight Saving Time is never observed. +** 4. They might reference tzname[0] after setting to a time zone +** in which Standard Time is never observed. +** 5. They might reference tm.TM_ZONE after calling offtime. +** What's best to do in the above cases is open to debate; +** for now, we just set things up so that in any of the five cases +** WILDABBR is used. Another possibility: initialize tzname[0] to the +** string "tzname[0] used before set", and similarly for the other cases. +** And another: initialize tzname[0] to "ERA", with an explanation in the +** manual page of what this "time zone abbreviation" means (doing this so +** that tzname[0] has the "normal" length of three characters). +*/ +#define WILDABBR " " +#endif /* !defined WILDABBR */ + +static char wildabbr[] = "WILDABBR"; + +static const char gmt[] = "GMT"; + +struct ttinfo { /* time type information */ + long tt_gmtoff; /* GMT offset in seconds */ + int tt_isdst; /* used to set tm_isdst */ + int tt_abbrind; /* abbreviation list index */ + int tt_ttisstd; /* TRUE if transition is std time */ + int tt_ttisgmt; /* TRUE if transition is GMT */ +}; + +struct lsinfo { /* leap second information */ + time_t ls_trans; /* transition time */ + long ls_corr; /* correction to apply */ +}; + +#define BIGGEST(a, b) (((a) > (b)) ? (a) : (b)) + +#ifdef TZNAME_MAX +#define MY_TZNAME_MAX TZNAME_MAX +#endif /* defined TZNAME_MAX */ +#ifndef TZNAME_MAX +#define MY_TZNAME_MAX 255 +#endif /* !defined TZNAME_MAX */ + +struct state { + int leapcnt; + int timecnt; + int typecnt; + int charcnt; + time_t ats[TZ_MAX_TIMES]; + unsigned char types[TZ_MAX_TIMES]; + struct ttinfo ttis[TZ_MAX_TYPES]; + char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt), + (2 * (MY_TZNAME_MAX + 1)))]; + struct lsinfo lsis[TZ_MAX_LEAPS]; +}; + +struct rule { + int r_type; /* type of rule--see below */ + int r_day; /* day number of rule */ + int r_week; /* week number of rule */ + int r_mon; /* month number of rule */ + long r_time; /* transition time of rule */ +}; + +#define JULIAN_DAY 0 /* Jn - Julian day */ +#define DAY_OF_YEAR 1 /* n - day of year */ +#define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */ + +/* +** Prototypes for static functions. +*/ + +static long detzcode P((const char * codep)); +static const char * getzname P((const char * strp)); +static const char * getnum P((const char * strp, int * nump, int min, + int max)); +static const char * getsecs P((const char * strp, long * secsp)); +static const char * getoffset P((const char * strp, long * offsetp)); +static const char * getrule P((const char * strp, struct rule * rulep)); +static void gmtload P((struct state * sp)); +static void gmtsub P((const time_t * timep, long offset, + struct tm * tmp)); +static void localsub P((const time_t * timep, long offset, + struct tm * tmp)); +static int increment_overflow P((int * number, int delta)); +static int normalize_overflow P((int * tensptr, int * unitsptr, + int base)); +static void settzname P((void)); +static time_t time1 P((struct tm * tmp, + void(*funcp) P((const time_t *, + long, struct tm *)), + long offset)); +static time_t time2 P((struct tm *tmp, + void(*funcp) P((const time_t *, + long, struct tm*)), + long offset, int * okayp)); +static void timesub P((const time_t * timep, long offset, + const struct state * sp, struct tm * tmp)); +static int tmcomp P((const struct tm * atmp, + const struct tm * btmp)); +static time_t transtime P((time_t janfirst, int year, + const struct rule * rulep, long offset)); +static int tzload P((const char * name, struct state * sp)); +static int tzparse P((const char * name, struct state * sp, + int lastditch)); + +#ifdef ALL_STATE +static struct state * lclptr; +static struct state * gmtptr; +#endif /* defined ALL_STATE */ + +#ifndef ALL_STATE +static struct state lclmem; +static struct state gmtmem; +#define lclptr (&lclmem) +#define gmtptr (&gmtmem) +#endif /* State Farm */ + +#ifndef TZ_STRLEN_MAX +#define TZ_STRLEN_MAX 255 +#endif /* !defined TZ_STRLEN_MAX */ + +static char lcl_TZname[TZ_STRLEN_MAX + 1]; +static int lcl_is_set; +static int gmt_is_set; +static pthread_mutex_t lcl_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t gmt_mutex = PTHREAD_MUTEX_INITIALIZER; + +char * tzname[2] = { + wildabbr, + wildabbr +}; + +/* +** Section 4.12.3 of X3.159-1989 requires that +** Except for the strftime function, these functions [asctime, +** ctime, gmtime, localtime] return values in one of two static +** objects: a broken-down time structure and an array of char. +** Thanks to Paul Eggert (eggert@twinsun.com) for noting this. +*/ + +static struct tm tm; + +#ifdef USG_COMPAT +time_t timezone = 0; +int daylight = 0; +#endif /* defined USG_COMPAT */ + +#ifdef ALTZONE +time_t altzone = 0; +#endif /* defined ALTZONE */ + +static long +detzcode(codep) +const char * const codep; +{ + register long result; + register int i; + + result = (codep[0] & 0x80) ? ~0L : 0L; + for (i = 0; i < 4; ++i) + result = (result << 8) | (codep[i] & 0xff); + return result; +} + +static void +settzname P((void)) +{ + register struct state * sp = lclptr; + register int i; + + tzname[0] = wildabbr; + tzname[1] = wildabbr; +#ifdef USG_COMPAT + daylight = 0; + timezone = 0; +#endif /* defined USG_COMPAT */ +#ifdef ALTZONE + altzone = 0; +#endif /* defined ALTZONE */ +#ifdef ALL_STATE + if (sp == NULL) { + tzname[0] = tzname[1] = gmt; + return; + } +#endif /* defined ALL_STATE */ + for (i = 0; i < sp->typecnt; ++i) { + register const struct ttinfo * const ttisp = &sp->ttis[i]; + + tzname[ttisp->tt_isdst] = + &sp->chars[ttisp->tt_abbrind]; +#ifdef USG_COMPAT + if (ttisp->tt_isdst) + daylight = 1; + if (i == 0 || !ttisp->tt_isdst) + timezone = -(ttisp->tt_gmtoff); +#endif /* defined USG_COMPAT */ +#ifdef ALTZONE + if (i == 0 || ttisp->tt_isdst) + altzone = -(ttisp->tt_gmtoff); +#endif /* defined ALTZONE */ + } + /* + ** And to get the latest zone names into tzname. . . + */ + for (i = 0; i < sp->timecnt; ++i) { + register const struct ttinfo * const ttisp = + &sp->ttis[ + sp->types[i]]; + + tzname[ttisp->tt_isdst] = + &sp->chars[ttisp->tt_abbrind]; + } +} + +static int +tzload(name, sp) +register const char * name; +register struct state * const sp; +{ + register const char * p; + register int i; + register int fid; + + /* XXX The following is from OpenBSD, and I'm not sure it is correct */ + if (name != NULL && issetugid() != 0) + if ((name[0] == ':' && name[1] == '/') || + name[0] == '/' || strchr(name, '.')) + name = NULL; + if (name == NULL && (name = TZDEFAULT) == NULL) + return -1; + { + register int doaccess; + struct stat stab; + /* + ** Section 4.9.1 of the C standard says that + ** "FILENAME_MAX expands to an integral constant expression + ** that is the size needed for an array of char large enough + ** to hold the longest file name string that the implementation + ** guarantees can be opened." + */ + char fullname[FILENAME_MAX + 1]; + + if (name[0] == ':') + ++name; + doaccess = name[0] == '/'; + if (!doaccess) { + if ((p = TZDIR) == NULL) + return -1; + if ((strlen(p) + 1 + strlen(name) + 1) >= sizeof fullname) + return -1; + (void) strcpy(fullname, p); + (void) strcat(fullname, "/"); + (void) strcat(fullname, name); + /* + ** Set doaccess if '.' (as in "../") shows up in name. + */ + if (strchr(name, '.') != NULL) + doaccess = TRUE; + name = fullname; + } + if (doaccess && access(name, R_OK) != 0) + return -1; + if ((fid = open(name, OPEN_MODE)) == -1) + return -1; + if ((fstat(fid, &stab) < 0) || !S_ISREG(stab.st_mode)) + return -1; + } + { + struct tzhead * tzhp; + char buf[sizeof *sp + sizeof *tzhp]; + int ttisstdcnt; + int ttisgmtcnt; + + i = read(fid, buf, sizeof buf); + if (close(fid) != 0) + return -1; + p = buf; + p += (sizeof tzhp->tzh_magic) + (sizeof tzhp->tzh_reserved); + ttisstdcnt = (int) detzcode(p); + p += 4; + ttisgmtcnt = (int) detzcode(p); + p += 4; + sp->leapcnt = (int) detzcode(p); + p += 4; + sp->timecnt = (int) detzcode(p); + p += 4; + sp->typecnt = (int) detzcode(p); + p += 4; + sp->charcnt = (int) detzcode(p); + p += 4; + if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS || + sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES || + sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES || + sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS || + (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) || + (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0)) + return -1; + if (i - (p - buf) < sp->timecnt * 4 + /* ats */ + sp->timecnt + /* types */ + sp->typecnt * (4 + 2) + /* ttinfos */ + sp->charcnt + /* chars */ + sp->leapcnt * (4 + 4) + /* lsinfos */ + ttisstdcnt + /* ttisstds */ + ttisgmtcnt) /* ttisgmts */ + return -1; + for (i = 0; i < sp->timecnt; ++i) { + sp->ats[i] = detzcode(p); + p += 4; + } + for (i = 0; i < sp->timecnt; ++i) { + sp->types[i] = (unsigned char) *p++; + if (sp->types[i] >= sp->typecnt) + return -1; + } + for (i = 0; i < sp->typecnt; ++i) { + register struct ttinfo * ttisp; + + ttisp = &sp->ttis[i]; + ttisp->tt_gmtoff = detzcode(p); + p += 4; + ttisp->tt_isdst = (unsigned char) *p++; + if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1) + return -1; + ttisp->tt_abbrind = (unsigned char) *p++; + if (ttisp->tt_abbrind < 0 || + ttisp->tt_abbrind > sp->charcnt) + return -1; + } + for (i = 0; i < sp->charcnt; ++i) + sp->chars[i] = *p++; + sp->chars[i] = '\0'; /* ensure '\0' at end */ + for (i = 0; i < sp->leapcnt; ++i) { + register struct lsinfo * lsisp; + + lsisp = &sp->lsis[i]; + lsisp->ls_trans = detzcode(p); + p += 4; + lsisp->ls_corr = detzcode(p); + p += 4; + } + for (i = 0; i < sp->typecnt; ++i) { + register struct ttinfo * ttisp; + + ttisp = &sp->ttis[i]; + if (ttisstdcnt == 0) + ttisp->tt_ttisstd = FALSE; + else { + ttisp->tt_ttisstd = *p++; + if (ttisp->tt_ttisstd != TRUE && + ttisp->tt_ttisstd != FALSE) + return -1; + } + } + for (i = 0; i < sp->typecnt; ++i) { + register struct ttinfo * ttisp; + + ttisp = &sp->ttis[i]; + if (ttisgmtcnt == 0) + ttisp->tt_ttisgmt = FALSE; + else { + ttisp->tt_ttisgmt = *p++; + if (ttisp->tt_ttisgmt != TRUE && + ttisp->tt_ttisgmt != FALSE) + return -1; + } + } + } + return 0; +} + +static const int mon_lengths[2][MONSPERYEAR] = { + { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, + { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } +}; + +static const int year_lengths[2] = { + DAYSPERNYEAR, DAYSPERLYEAR +}; + +/* +** Given a pointer into a time zone string, scan until a character that is not +** a valid character in a zone name is found. Return a pointer to that +** character. +*/ + +static const char * +getzname(strp) +register const char * strp; +{ + register char c; + + while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' && + c != '+') + ++strp; + return strp; +} + +/* +** Given a pointer into a time zone string, extract a number from that string. +** Check that the number is within a specified range; if it is not, return +** NULL. +** Otherwise, return a pointer to the first character not part of the number. +*/ + +static const char * +getnum(strp, nump, min, max) +register const char * strp; +int * const nump; +const int min; +const int max; +{ + register char c; + register int num; + + if (strp == NULL || !is_digit(c = *strp)) + return NULL; + num = 0; + do { + num = num * 10 + (c - '0'); + if (num > max) + return NULL; /* illegal value */ + c = *++strp; + } while (is_digit(c)); + if (num < min) + return NULL; /* illegal value */ + *nump = num; + return strp; +} + +/* +** Given a pointer into a time zone string, extract a number of seconds, +** in hh[:mm[:ss]] form, from the string. +** If any error occurs, return NULL. +** Otherwise, return a pointer to the first character not part of the number +** of seconds. +*/ + +static const char * +getsecs(strp, secsp) +register const char * strp; +long * const secsp; +{ + int num; + + /* + ** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like + ** "M10.4.6/26", which does not conform to Posix, + ** but which specifies the equivalent of + ** ``02:00 on the first Sunday on or after 23 Oct''. + */ + strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1); + if (strp == NULL) + return NULL; + *secsp = num * (long) SECSPERHOUR; + if (*strp == ':') { + ++strp; + strp = getnum(strp, &num, 0, MINSPERHOUR - 1); + if (strp == NULL) + return NULL; + *secsp += num * SECSPERMIN; + if (*strp == ':') { + ++strp; + /* `SECSPERMIN' allows for leap seconds. */ + strp = getnum(strp, &num, 0, SECSPERMIN); + if (strp == NULL) + return NULL; + *secsp += num; + } + } + return strp; +} + +/* +** Given a pointer into a time zone string, extract an offset, in +** [+-]hh[:mm[:ss]] form, from the string. +** If any error occurs, return NULL. +** Otherwise, return a pointer to the first character not part of the time. +*/ + +static const char * +getoffset(strp, offsetp) +register const char * strp; +long * const offsetp; +{ + register int neg = 0; + + if (*strp == '-') { + neg = 1; + ++strp; + } else if (*strp == '+') + ++strp; + strp = getsecs(strp, offsetp); + if (strp == NULL) + return NULL; /* illegal time */ + if (neg) + *offsetp = -*offsetp; + return strp; +} + +/* +** Given a pointer into a time zone string, extract a rule in the form +** date[/time]. See POSIX section 8 for the format of "date" and "time". +** If a valid rule is not found, return NULL. +** Otherwise, return a pointer to the first character not part of the rule. +*/ + +static const char * +getrule(strp, rulep) +const char * strp; +register struct rule * const rulep; +{ + if (*strp == 'J') { + /* + ** Julian day. + */ + rulep->r_type = JULIAN_DAY; + ++strp; + strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR); + } else if (*strp == 'M') { + /* + ** Month, week, day. + */ + rulep->r_type = MONTH_NTH_DAY_OF_WEEK; + ++strp; + strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR); + if (strp == NULL) + return NULL; + if (*strp++ != '.') + return NULL; + strp = getnum(strp, &rulep->r_week, 1, 5); + if (strp == NULL) + return NULL; + if (*strp++ != '.') + return NULL; + strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1); + } else if (is_digit(*strp)) { + /* + ** Day of year. + */ + rulep->r_type = DAY_OF_YEAR; + strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1); + } else return NULL; /* invalid format */ + if (strp == NULL) + return NULL; + if (*strp == '/') { + /* + ** Time specified. + */ + ++strp; + strp = getsecs(strp, &rulep->r_time); + } else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */ + return strp; +} + +/* +** Given the Epoch-relative time of January 1, 00:00:00 GMT, in a year, the +** year, a rule, and the offset from GMT at the time that rule takes effect, +** calculate the Epoch-relative time that rule takes effect. +*/ + +static time_t +transtime(janfirst, year, rulep, offset) +const time_t janfirst; +const int year; +register const struct rule * const rulep; +const long offset; +{ + register int leapyear; + register time_t value; + register int i; + int d, m1, yy0, yy1, yy2, dow; + + INITIALIZE(value); + leapyear = isleap(year); + switch (rulep->r_type) { + + case JULIAN_DAY: + /* + ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap + ** years. + ** In non-leap years, or if the day number is 59 or less, just + ** add SECSPERDAY times the day number-1 to the time of + ** January 1, midnight, to get the day. + */ + value = janfirst + (rulep->r_day - 1) * SECSPERDAY; + if (leapyear && rulep->r_day >= 60) + value += SECSPERDAY; + break; + + case DAY_OF_YEAR: + /* + ** n - day of year. + ** Just add SECSPERDAY times the day number to the time of + ** January 1, midnight, to get the day. + */ + value = janfirst + rulep->r_day * SECSPERDAY; + break; + + case MONTH_NTH_DAY_OF_WEEK: + /* + ** Mm.n.d - nth "dth day" of month m. + */ + value = janfirst; + for (i = 0; i < rulep->r_mon - 1; ++i) + value += mon_lengths[leapyear][i] * SECSPERDAY; + + /* + ** Use Zeller's Congruence to get day-of-week of first day of + ** month. + */ + m1 = (rulep->r_mon + 9) % 12 + 1; + yy0 = (rulep->r_mon <= 2) ? (year - 1) : year; + yy1 = yy0 / 100; + yy2 = yy0 % 100; + dow = ((26 * m1 - 2) / 10 + + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7; + if (dow < 0) + dow += DAYSPERWEEK; + + /* + ** "dow" is the day-of-week of the first day of the month. Get + ** the day-of-month (zero-origin) of the first "dow" day of the + ** month. + */ + d = rulep->r_day - dow; + if (d < 0) + d += DAYSPERWEEK; + for (i = 1; i < rulep->r_week; ++i) { + if (d + DAYSPERWEEK >= + mon_lengths[leapyear][rulep->r_mon - 1]) + break; + d += DAYSPERWEEK; + } + + /* + ** "d" is the day-of-month (zero-origin) of the day we want. + */ + value += d * SECSPERDAY; + break; + } + + /* + ** "value" is the Epoch-relative time of 00:00:00 GMT on the day in + ** question. To get the Epoch-relative time of the specified local + ** time on that day, add the transition time and the current offset + ** from GMT. + */ + return value + rulep->r_time + offset; +} + +/* +** Given a POSIX section 8-style TZ string, fill in the rule tables as +** appropriate. +*/ + +static int +tzparse(name, sp, lastditch) +const char * name; +register struct state * const sp; +const int lastditch; +{ + const char * stdname; + const char * dstname; + size_t stdlen; + size_t dstlen; + long stdoffset; + long dstoffset; + register time_t * atp; + register unsigned char * typep; + register char * cp; + register int load_result; + + INITIALIZE(dstname); + stdname = name; + if (lastditch) { + stdlen = strlen(name); /* length of standard zone name */ + name += stdlen; + if (stdlen >= sizeof sp->chars) + stdlen = (sizeof sp->chars) - 1; + stdoffset = 0; + } else { + name = getzname(name); + stdlen = name - stdname; + if (stdlen < 3) + return -1; + if (*name == '\0') + return -1; /* was "stdoffset = 0;" */ + else { + name = getoffset(name, &stdoffset); + if (name == NULL) + return -1; + } + } + load_result = tzload(TZDEFRULES, sp); + if (load_result != 0) + sp->leapcnt = 0; /* so, we're off a little */ + if (*name != '\0') { + dstname = name; + name = getzname(name); + dstlen = name - dstname; /* length of DST zone name */ + if (dstlen < 3) + return -1; + if (*name != '\0' && *name != ',' && *name != ';') { + name = getoffset(name, &dstoffset); + if (name == NULL) + return -1; + } else dstoffset = stdoffset - SECSPERHOUR; + if (*name == ',' || *name == ';') { + struct rule start; + struct rule end; + register int year; + register time_t janfirst; + time_t starttime; + time_t endtime; + + ++name; + if ((name = getrule(name, &start)) == NULL) + return -1; + if (*name++ != ',') + return -1; + if ((name = getrule(name, &end)) == NULL) + return -1; + if (*name != '\0') + return -1; + sp->typecnt = 2; /* standard time and DST */ + /* + ** Two transitions per year, from EPOCH_YEAR to 2037. + */ + sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1); + if (sp->timecnt > TZ_MAX_TIMES) + return -1; + sp->ttis[0].tt_gmtoff = -dstoffset; + sp->ttis[0].tt_isdst = 1; + sp->ttis[0].tt_abbrind = stdlen + 1; + sp->ttis[1].tt_gmtoff = -stdoffset; + sp->ttis[1].tt_isdst = 0; + sp->ttis[1].tt_abbrind = 0; + atp = sp->ats; + typep = sp->types; + janfirst = 0; + for (year = EPOCH_YEAR; year <= 2037; ++year) { + starttime = transtime(janfirst, year, &start, + stdoffset); + endtime = transtime(janfirst, year, &end, + dstoffset); + if (starttime > endtime) { + *atp++ = endtime; + *typep++ = 1; /* DST ends */ + *atp++ = starttime; + *typep++ = 0; /* DST begins */ + } else { + *atp++ = starttime; + *typep++ = 0; /* DST begins */ + *atp++ = endtime; + *typep++ = 1; /* DST ends */ + } + janfirst += year_lengths[isleap(year)] * + SECSPERDAY; + } + } else { + register long theirstdoffset; + register long theirdstoffset; + register long theiroffset; + register int isdst; + register int i; + register int j; + + if (*name != '\0') + return -1; + if (load_result != 0) + return -1; + /* + ** Initial values of theirstdoffset and theirdstoffset. + */ + theirstdoffset = 0; + for (i = 0; i < sp->timecnt; ++i) { + j = sp->types[i]; + if (!sp->ttis[j].tt_isdst) { + theirstdoffset = + -sp->ttis[j].tt_gmtoff; + break; + } + } + theirdstoffset = 0; + for (i = 0; i < sp->timecnt; ++i) { + j = sp->types[i]; + if (sp->ttis[j].tt_isdst) { + theirdstoffset = + -sp->ttis[j].tt_gmtoff; + break; + } + } + /* + ** Initially we're assumed to be in standard time. + */ + isdst = FALSE; + theiroffset = theirstdoffset; + /* + ** Now juggle transition times and types + ** tracking offsets as you do. + */ + for (i = 0; i < sp->timecnt; ++i) { + j = sp->types[i]; + sp->types[i] = sp->ttis[j].tt_isdst; + if (sp->ttis[j].tt_ttisgmt) { + /* No adjustment to transition time */ + } else { + /* + ** If summer time is in effect, and the + ** transition time was not specified as + ** standard time, add the summer time + ** offset to the transition time; + ** otherwise, add the standard time + ** offset to the transition time. + */ + /* + ** Transitions from DST to DDST + ** will effectively disappear since + ** POSIX provides for only one DST + ** offset. + */ + if (isdst && !sp->ttis[j].tt_ttisstd) { + sp->ats[i] += dstoffset - + theirdstoffset; + } else { + sp->ats[i] += stdoffset - + theirstdoffset; + } + } + theiroffset = -sp->ttis[j].tt_gmtoff; + if (sp->ttis[j].tt_isdst) + theirdstoffset = theiroffset; + else theirstdoffset = theiroffset; + } + /* + ** Finally, fill in ttis. + ** ttisstd and ttisgmt need not be handled. + */ + sp->ttis[0].tt_gmtoff = -stdoffset; + sp->ttis[0].tt_isdst = FALSE; + sp->ttis[0].tt_abbrind = 0; + sp->ttis[1].tt_gmtoff = -dstoffset; + sp->ttis[1].tt_isdst = TRUE; + sp->ttis[1].tt_abbrind = stdlen + 1; + } + } else { + dstlen = 0; + sp->typecnt = 1; /* only standard time */ + sp->timecnt = 0; + sp->ttis[0].tt_gmtoff = -stdoffset; + sp->ttis[0].tt_isdst = 0; + sp->ttis[0].tt_abbrind = 0; + } + sp->charcnt = stdlen + 1; + if (dstlen != 0) + sp->charcnt += dstlen + 1; + if (sp->charcnt > sizeof sp->chars) + return -1; + cp = sp->chars; + (void) strncpy(cp, stdname, stdlen); + cp += stdlen; + *cp++ = '\0'; + if (dstlen != 0) { + (void) strncpy(cp, dstname, dstlen); + *(cp + dstlen) = '\0'; + } + return 0; +} + +static void +gmtload(sp) +struct state * const sp; +{ + if (tzload(gmt, sp) != 0) + (void) tzparse(gmt, sp, TRUE); +} + +static void +tzsetwall_basic(void) +{ + if (lcl_is_set < 0) + return; + lcl_is_set = -1; + +#ifdef ALL_STATE + if (lclptr == NULL) { + lclptr = (struct state *) malloc(sizeof *lclptr); + if (lclptr == NULL) { + settzname(); /* all we can do */ + return; + } + } +#endif /* defined ALL_STATE */ + if (tzload((char *) NULL, lclptr) != 0) + gmtload(lclptr); + settzname(); +} + +void +tzsetwall P((void)) +{ + _MUTEX_LOCK(&lcl_mutex); + tzsetwall_basic(); + _MUTEX_UNLOCK(&lcl_mutex); +} + +static void +tzset_basic(void) +{ + register const char * name; + + name = getenv("TZ"); + if (name == NULL) { + tzsetwall_basic(); + return; + } + + if (lcl_is_set > 0 && strcmp(lcl_TZname, name) == 0) + return; + lcl_is_set = (strlen(name) < sizeof(lcl_TZname)); + if (lcl_is_set) + (void) strcpy(lcl_TZname, name); + +#ifdef ALL_STATE + if (lclptr == NULL) { + lclptr = (struct state *) malloc(sizeof *lclptr); + if (lclptr == NULL) { + settzname(); /* all we can do */ + return; + } + } +#endif /* defined ALL_STATE */ + if (*name == '\0') { + /* + ** User wants it fast rather than right. + */ + lclptr->leapcnt = 0; /* so, we're off a little */ + lclptr->timecnt = 0; + lclptr->ttis[0].tt_gmtoff = 0; + lclptr->ttis[0].tt_abbrind = 0; + (void) strcpy(lclptr->chars, gmt); + } else if (tzload(name, lclptr) != 0) + if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0) + (void) gmtload(lclptr); + settzname(); +} + +void +tzset P((void)) +{ + _MUTEX_LOCK(&lcl_mutex); + tzset_basic(); + _MUTEX_UNLOCK(&lcl_mutex); +} + +/* +** The easy way to behave "as if no library function calls" localtime +** is to not call it--so we drop its guts into "localsub", which can be +** freely called. (And no, the PANS doesn't require the above behavior-- +** but it *is* desirable.) +** +** The unused offset argument is for the benefit of mktime variants. +*/ + +/*ARGSUSED*/ +static void +localsub(timep, offset, tmp) +const time_t * const timep; +const long offset; +struct tm * const tmp; +{ + register struct state * sp; + register const struct ttinfo * ttisp; + register int i; + const time_t t = *timep; + + sp = lclptr; +#ifdef ALL_STATE + if (sp == NULL) { + gmtsub(timep, offset, tmp); + return; + } +#endif /* defined ALL_STATE */ + if (sp->timecnt == 0 || t < sp->ats[0]) { + i = 0; + while (sp->ttis[i].tt_isdst) + if (++i >= sp->typecnt) { + i = 0; + break; + } + } else { + for (i = 1; i < sp->timecnt; ++i) + if (t < sp->ats[i]) + break; + i = sp->types[i - 1]; + } + ttisp = &sp->ttis[i]; + /* + ** To get (wrong) behavior that's compatible with System V Release 2.0 + ** you'd replace the statement below with + ** t += ttisp->tt_gmtoff; + ** timesub(&t, 0L, sp, tmp); + */ + timesub(&t, ttisp->tt_gmtoff, sp, tmp); + tmp->tm_isdst = ttisp->tt_isdst; + tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind]; +#ifdef TM_ZONE + tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind]; +#endif /* defined TM_ZONE */ +} + +struct tm * +localtime_r(timep, p_tm) +const time_t * const timep; +struct tm *p_tm; +{ + _MUTEX_LOCK(&lcl_mutex); + tzset_basic(); + localsub(timep, 0L, p_tm); + _MUTEX_UNLOCK(&lcl_mutex); + return(p_tm); +} + +struct tm * +localtime(timep) +const time_t * const timep; +{ + static pthread_mutex_t localtime_mutex = PTHREAD_MUTEX_INITIALIZER; + static pthread_key_t localtime_key = -1; + struct tm *p_tm; + + if (__isthreaded != 0) { + pthread_mutex_lock(&localtime_mutex); + if (localtime_key < 0) { + if (pthread_key_create(&localtime_key, free) < 0) { + pthread_mutex_unlock(&localtime_mutex); + return(NULL); + } + } + pthread_mutex_unlock(&localtime_mutex); + p_tm = pthread_getspecific(localtime_key); + if (p_tm == NULL) { + if ((p_tm = (struct tm *)malloc(sizeof(struct tm))) + == NULL) + return(NULL); + pthread_setspecific(localtime_key, p_tm); + } + pthread_mutex_lock(&lcl_mutex); + tzset_basic(); + localsub(timep, 0L, p_tm); + pthread_mutex_unlock(&lcl_mutex); + return(p_tm); + } else { + tzset_basic(); + localsub(timep, 0L, &tm); + return(&tm); + } +} + +/* +** gmtsub is to gmtime as localsub is to localtime. +*/ + +static void +gmtsub(timep, offset, tmp) +const time_t * const timep; +const long offset; +struct tm * const tmp; +{ + _MUTEX_LOCK(&gmt_mutex); + if (!gmt_is_set) { + gmt_is_set = TRUE; +#ifdef ALL_STATE + gmtptr = (struct state *) malloc(sizeof *gmtptr); + if (gmtptr != NULL) +#endif /* defined ALL_STATE */ + gmtload(gmtptr); + } + _MUTEX_UNLOCK(&gmt_mutex); + timesub(timep, offset, gmtptr, tmp); +#ifdef TM_ZONE + /* + ** Could get fancy here and deliver something such as + ** "GMT+xxxx" or "GMT-xxxx" if offset is non-zero, + ** but this is no time for a treasure hunt. + */ + if (offset != 0) + tmp->TM_ZONE = wildabbr; + else { +#ifdef ALL_STATE + if (gmtptr == NULL) + tmp->TM_ZONE = gmt; + else tmp->TM_ZONE = gmtptr->chars; +#endif /* defined ALL_STATE */ +#ifndef ALL_STATE + tmp->TM_ZONE = gmtptr->chars; +#endif /* State Farm */ + } +#endif /* defined TM_ZONE */ +} + +struct tm * +gmtime(timep) +const time_t * const timep; +{ + static pthread_mutex_t gmtime_mutex = PTHREAD_MUTEX_INITIALIZER; + static pthread_key_t gmtime_key = -1; + struct tm *p_tm; + + if (__isthreaded != 0) { + pthread_mutex_lock(&gmtime_mutex); + if (gmtime_key < 0) { + if (pthread_key_create(&gmtime_key, free) < 0) { + pthread_mutex_unlock(&gmtime_mutex); + return(NULL); + } + } + pthread_mutex_unlock(&gmtime_mutex); + /* + * Changed to follow POSIX.1 threads standard, which + * is what BSD currently has. + */ + if ((p_tm = pthread_getspecific(gmtime_key)) == NULL) { + if ((p_tm = (struct tm *)malloc(sizeof(struct tm))) + == NULL) { + return(NULL); + } + pthread_setspecific(gmtime_key, p_tm); + } + gmtsub(timep, 0L, p_tm); + return(p_tm); + } + else { + gmtsub(timep, 0L, &tm); + return(&tm); + } +} + +struct tm * +gmtime_r(const time_t * timep, struct tm * tm) +{ + gmtsub(timep, 0L, tm); + return(tm); +} + +#ifdef STD_INSPIRED + +struct tm * +offtime(timep, offset) +const time_t * const timep; +const long offset; +{ + gmtsub(timep, offset, &tm); + return &tm; +} + +#endif /* defined STD_INSPIRED */ + +static void +timesub(timep, offset, sp, tmp) +const time_t * const timep; +const long offset; +register const struct state * const sp; +register struct tm * const tmp; +{ + register const struct lsinfo * lp; + register long days; + register long rem; + register int y; + register int yleap; + register const int * ip; + register long corr; + register int hit; + register int i; + + corr = 0; + hit = 0; +#ifdef ALL_STATE + i = (sp == NULL) ? 0 : sp->leapcnt; +#endif /* defined ALL_STATE */ +#ifndef ALL_STATE + i = sp->leapcnt; +#endif /* State Farm */ + while (--i >= 0) { + lp = &sp->lsis[i]; + if (*timep >= lp->ls_trans) { + if (*timep == lp->ls_trans) { + hit = ((i == 0 && lp->ls_corr > 0) || + lp->ls_corr > sp->lsis[i - 1].ls_corr); + if (hit) + while (i > 0 && + sp->lsis[i].ls_trans == + sp->lsis[i - 1].ls_trans + 1 && + sp->lsis[i].ls_corr == + sp->lsis[i - 1].ls_corr + 1) { + ++hit; + --i; + } + } + corr = lp->ls_corr; + break; + } + } + days = *timep / SECSPERDAY; + rem = *timep % SECSPERDAY; +#ifdef mc68k + if (*timep == 0x80000000) { + /* + ** A 3B1 muffs the division on the most negative number. + */ + days = -24855; + rem = -11648; + } +#endif /* defined mc68k */ + rem += (offset - corr); + while (rem < 0) { + rem += SECSPERDAY; + --days; + } + while (rem >= SECSPERDAY) { + rem -= SECSPERDAY; + ++days; + } + tmp->tm_hour = (int) (rem / SECSPERHOUR); + rem = rem % SECSPERHOUR; + tmp->tm_min = (int) (rem / SECSPERMIN); + /* + ** A positive leap second requires a special + ** representation. This uses "... ??:59:60" et seq. + */ + tmp->tm_sec = (int) (rem % SECSPERMIN) + hit; + tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK); + if (tmp->tm_wday < 0) + tmp->tm_wday += DAYSPERWEEK; + y = EPOCH_YEAR; +#define LEAPS_THRU_END_OF(y) ((y) / 4 - (y) / 100 + (y) / 400) + while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) { + register int newy; + + newy = y + days / DAYSPERNYEAR; + if (days < 0) + --newy; + days -= (newy - y) * DAYSPERNYEAR + + LEAPS_THRU_END_OF(newy - 1) - + LEAPS_THRU_END_OF(y - 1); + y = newy; + } + tmp->tm_year = y - TM_YEAR_BASE; + tmp->tm_yday = (int) days; + ip = mon_lengths[yleap]; + for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon)) + days = days - (long) ip[tmp->tm_mon]; + tmp->tm_mday = (int) (days + 1); + tmp->tm_isdst = 0; +#ifdef TM_GMTOFF + tmp->TM_GMTOFF = offset; +#endif /* defined TM_GMTOFF */ +} + +char * +ctime(timep) +const time_t * const timep; +{ +/* +** Section 4.12.3.2 of X3.159-1989 requires that +** The ctime funciton converts the calendar time pointed to by timer +** to local time in the form of a string. It is equivalent to +** asctime(localtime(timer)) +*/ + return asctime(localtime(timep)); +} + +char * +ctime_r(timep, buf) +const time_t * const timep; +char *buf; +{ + struct tm tm; + return asctime_r(localtime_r(timep, &tm), buf); +} + +/* +** Adapted from code provided by Robert Elz, who writes: +** The "best" way to do mktime I think is based on an idea of Bob +** Kridle's (so its said...) from a long time ago. +** [kridle@xinet.com as of 1996-01-16.] +** It does a binary search of the time_t space. Since time_t's are +** just 32 bits, its a max of 32 iterations (even at 64 bits it +** would still be very reasonable). +*/ + +#ifndef WRONG +#define WRONG (-1) +#endif /* !defined WRONG */ + +/* +** Simplified normalize logic courtesy Paul Eggert (eggert@twinsun.com). +*/ + +static int +increment_overflow(number, delta) +int * number; +int delta; +{ + int number0; + + number0 = *number; + *number += delta; + return (*number < number0) != (delta < 0); +} + +static int +normalize_overflow(tensptr, unitsptr, base) +int * const tensptr; +int * const unitsptr; +const int base; +{ + register int tensdelta; + + tensdelta = (*unitsptr >= 0) ? + (*unitsptr / base) : + (-1 - (-1 - *unitsptr) / base); + *unitsptr -= tensdelta * base; + return increment_overflow(tensptr, tensdelta); +} + +static int +tmcomp(atmp, btmp) +register const struct tm * const atmp; +register const struct tm * const btmp; +{ + register int result; + + if ((result = (atmp->tm_year - btmp->tm_year)) == 0 && + (result = (atmp->tm_mon - btmp->tm_mon)) == 0 && + (result = (atmp->tm_mday - btmp->tm_mday)) == 0 && + (result = (atmp->tm_hour - btmp->tm_hour)) == 0 && + (result = (atmp->tm_min - btmp->tm_min)) == 0) + result = atmp->tm_sec - btmp->tm_sec; + return result; +} + +static time_t +time2(tmp, funcp, offset, okayp) +struct tm * const tmp; +void (* const funcp) P((const time_t*, long, struct tm*)); +const long offset; +int * const okayp; +{ + register const struct state * sp; + register int dir; + register int bits; + register int i, j ; + register int saved_seconds; + time_t newt; + time_t t; + struct tm yourtm, mytm; + + *okayp = FALSE; + yourtm = *tmp; + if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR)) + return WRONG; + if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY)) + return WRONG; + if (normalize_overflow(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR)) + return WRONG; + /* + ** Turn yourtm.tm_year into an actual year number for now. + ** It is converted back to an offset from TM_YEAR_BASE later. + */ + if (increment_overflow(&yourtm.tm_year, TM_YEAR_BASE)) + return WRONG; + while (yourtm.tm_mday <= 0) { + if (increment_overflow(&yourtm.tm_year, -1)) + return WRONG; + i = yourtm.tm_year + (1 < yourtm.tm_mon); + yourtm.tm_mday += year_lengths[isleap(i)]; + } + while (yourtm.tm_mday > DAYSPERLYEAR) { + i = yourtm.tm_year + (1 < yourtm.tm_mon); + yourtm.tm_mday -= year_lengths[isleap(i)]; + if (increment_overflow(&yourtm.tm_year, 1)) + return WRONG; + } + for ( ; ; ) { + i = mon_lengths[isleap(yourtm.tm_year)][yourtm.tm_mon]; + if (yourtm.tm_mday <= i) + break; + yourtm.tm_mday -= i; + if (++yourtm.tm_mon >= MONSPERYEAR) { + yourtm.tm_mon = 0; + if (increment_overflow(&yourtm.tm_year, 1)) + return WRONG; + } + } + if (increment_overflow(&yourtm.tm_year, -TM_YEAR_BASE)) + return WRONG; + if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN) + saved_seconds = 0; + else if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR) { + /* + ** We can't set tm_sec to 0, because that might push the + ** time below the minimum representable time. + ** Set tm_sec to 59 instead. + ** This assumes that the minimum representable time is + ** not in the same minute that a leap second was deleted from, + ** which is a safer assumption than using 58 would be. + */ + if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN)) + return WRONG; + saved_seconds = yourtm.tm_sec; + yourtm.tm_sec = SECSPERMIN - 1; + } else { + saved_seconds = yourtm.tm_sec; + yourtm.tm_sec = 0; + } + /* + ** Divide the search space in half + ** (this works whether time_t is signed or unsigned). + */ + bits = TYPE_BIT(time_t) - 1; + /* + ** If time_t is signed, then 0 is just above the median, + ** assuming two's complement arithmetic. + ** If time_t is unsigned, then (1 << bits) is just above the median. + */ + t = TYPE_SIGNED(time_t) ? 0 : (((time_t) 1) << bits); + for ( ; ; ) { + (*funcp)(&t, offset, &mytm); + dir = tmcomp(&mytm, &yourtm); + if (dir != 0) { + if (bits-- < 0) + return WRONG; + if (bits < 0) + --t; /* may be needed if new t is minimal */ + else if (dir > 0) + t -= ((time_t) 1) << bits; + else t += ((time_t) 1) << bits; + continue; + } + if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst) + break; + /* + ** Right time, wrong type. + ** Hunt for right time, right type. + ** It's okay to guess wrong since the guess + ** gets checked. + */ + /* + ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's. + */ + sp = (const struct state *) + (((void *) funcp == (void *) localsub) ? + lclptr : gmtptr); +#ifdef ALL_STATE + if (sp == NULL) + return WRONG; +#endif /* defined ALL_STATE */ + for (i = sp->typecnt - 1; i >= 0; --i) { + if (sp->ttis[i].tt_isdst != yourtm.tm_isdst) + continue; + for (j = sp->typecnt - 1; j >= 0; --j) { + if (sp->ttis[j].tt_isdst == yourtm.tm_isdst) + continue; + newt = t + sp->ttis[j].tt_gmtoff - + sp->ttis[i].tt_gmtoff; + (*funcp)(&newt, offset, &mytm); + if (tmcomp(&mytm, &yourtm) != 0) + continue; + if (mytm.tm_isdst != yourtm.tm_isdst) + continue; + /* + ** We have a match. + */ + t = newt; + goto label; + } + } + return WRONG; + } +label: + newt = t + saved_seconds; + if ((newt < t) != (saved_seconds < 0)) + return WRONG; + t = newt; + (*funcp)(&t, offset, tmp); + *okayp = TRUE; + return t; +} + +static time_t +time1(tmp, funcp, offset) +struct tm * const tmp; +void (* const funcp) P((const time_t *, long, struct tm *)); +const long offset; +{ + register time_t t; + register const struct state * sp; + register int samei, otheri; + int okay; + + if (tmp->tm_isdst > 1) + tmp->tm_isdst = 1; + t = time2(tmp, funcp, offset, &okay); +#ifdef PCTS + /* + ** PCTS code courtesy Grant Sullivan (grant@osf.org). + */ + if (okay) + return t; + if (tmp->tm_isdst < 0) + tmp->tm_isdst = 0; /* reset to std and try again */ +#endif /* defined PCTS */ +#ifndef PCTS + if (okay || tmp->tm_isdst < 0) + return t; +#endif /* !defined PCTS */ + /* + ** We're supposed to assume that somebody took a time of one type + ** and did some math on it that yielded a "struct tm" that's bad. + ** We try to divine the type they started from and adjust to the + ** type they need. + */ + /* + ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's. + */ + sp = (const struct state *) (((void *) funcp == (void *) localsub) ? + lclptr : gmtptr); +#ifdef ALL_STATE + if (sp == NULL) + return WRONG; +#endif /* defined ALL_STATE */ + for (samei = sp->typecnt - 1; samei >= 0; --samei) { + if (sp->ttis[samei].tt_isdst != tmp->tm_isdst) + continue; + for (otheri = sp->typecnt - 1; otheri >= 0; --otheri) { + if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst) + continue; + tmp->tm_sec += sp->ttis[otheri].tt_gmtoff - + sp->ttis[samei].tt_gmtoff; + tmp->tm_isdst = !tmp->tm_isdst; + t = time2(tmp, funcp, offset, &okay); + if (okay) + return t; + tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff - + sp->ttis[samei].tt_gmtoff; + tmp->tm_isdst = !tmp->tm_isdst; + } + } + return WRONG; +} + +time_t +mktime(tmp) +struct tm * const tmp; +{ + time_t mktime_return_value; + _MUTEX_LOCK(&lcl_mutex); + tzset_basic(); + mktime_return_value = time1(tmp, localsub, 0L); + _MUTEX_UNLOCK(&lcl_mutex); + return(mktime_return_value); +} + +#ifdef STD_INSPIRED + +time_t +timelocal(tmp) +struct tm * const tmp; +{ + tmp->tm_isdst = -1; /* in case it wasn't initialized */ + return mktime(tmp); +} + +time_t +timegm(tmp) +struct tm * const tmp; +{ + tmp->tm_isdst = 0; + return time1(tmp, gmtsub, 0L); +} + +time_t +timeoff(tmp, offset) +struct tm * const tmp; +const long offset; +{ + tmp->tm_isdst = 0; + return time1(tmp, gmtsub, offset); +} + +#endif /* defined STD_INSPIRED */ + +#ifdef CMUCS + +/* +** The following is supplied for compatibility with +** previous versions of the CMUCS runtime library. +*/ + +long +gtime(tmp) +struct tm * const tmp; +{ + const time_t t = mktime(tmp); + + if (t == WRONG) + return -1; + return t; +} + +#endif /* defined CMUCS */ + +/* +** XXX--is the below the right way to conditionalize?? +*/ + +#ifdef STD_INSPIRED + +/* +** IEEE Std 1003.1-1988 (POSIX) legislates that 536457599 +** shall correspond to "Wed Dec 31 23:59:59 GMT 1986", which +** is not the case if we are accounting for leap seconds. +** So, we provide the following conversion routines for use +** when exchanging timestamps with POSIX conforming systems. +*/ + +static long +leapcorr(timep) +time_t * timep; +{ + register struct state * sp; + register struct lsinfo * lp; + register int i; + + sp = lclptr; + i = sp->leapcnt; + while (--i >= 0) { + lp = &sp->lsis[i]; + if (*timep >= lp->ls_trans) + return lp->ls_corr; + } + return 0; +} + +time_t +time2posix(t) +time_t t; +{ + tzset(); + return t - leapcorr(&t); +} + +time_t +posix2time(t) +time_t t; +{ + time_t x; + time_t y; + + tzset(); + /* + ** For a positive leap second hit, the result + ** is not unique. For a negative leap second + ** hit, the corresponding time doesn't exist, + ** so we return an adjacent second. + */ + x = t + leapcorr(&t); + y = x - leapcorr(&x); + if (y < t) { + do { + x++; + y = x - leapcorr(&x); + } while (y < t); + if (t != y) + return x - 1; + } else if (y > t) { + do { + --x; + y = x - leapcorr(&x); + } while (y > t); + if (t != y) + return x + 1; + } + return x; +} + +#endif /* defined STD_INSPIRED */ diff --git a/devel/linuxthreads/files/patch-aa b/devel/linuxthreads/files/patch-aa index 4096f66324f9..9dd4ac1ad0af 100644 --- a/devel/linuxthreads/files/patch-aa +++ b/devel/linuxthreads/files/patch-aa @@ -1,27 +1,24 @@ -diff -ru ../linuxthreads/Examples/Makefile ./Examples/Makefile ---- ../linuxthreads/Examples/Makefile Wed Mar 11 13:42:23 1998 -+++ ./Examples/Makefile Mon Feb 26 12:36:31 2001 -@@ -1,8 +1,8 @@ +diff -ru ../../work/linuxthreads-2.2.3/Examples/Makefile ./Examples/Makefile +--- ../../work/linuxthreads-2.2.3/Examples/Makefile Wed Mar 11 12:42:23 1998 ++++ ./Examples/Makefile Thu Jun 7 22:59:29 2001 +@@ -1,6 +1,6 @@ CC=gcc -CFLAGS=-g -O -Wall -I.. -D_REENTRANT -LIBPTHREAD=../libpthread.a +CFLAGS=-g -O -Wall -I/usr/local/include/pthread/linuxthreads -D_REENTRANT +LIBPTHREAD=-L/usr/local/lib -llthread -llgcc_r --PROGS=ex1 ex2 ex3 ex4 ex5 proxy -+PROGS=ex1 ex2 ex3 ex4 ex5 + PROGS=ex1 ex2 ex3 ex4 ex5 proxy - all: $(PROGS) - -diff -ru ../linuxthreads/Makefile ./Makefile ---- ../linuxthreads/Makefile Wed Nov 3 01:09:36 1999 -+++ ./Makefile Mon Feb 26 12:36:31 2001 -@@ -1,68 +1,74 @@ --# Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc. +diff -ru ../../work/linuxthreads-2.2.3/Makefile ./Makefile +--- ../../work/linuxthreads-2.2.3/Makefile Wed Apr 25 21:50:59 2001 ++++ ./Makefile Thu Jun 7 23:13:52 2001 +@@ -1,128 +1,76 @@ +-# Copyright (C) 1996,1997,1998,1999,2000,2001 Free Software Foundation, Inc. -# This file is part of the GNU C Library. +LIB=lthread -+SHLIB_MAJOR= 2 -+SHLIB_MINOR= 1 ++SHLIB_MAJOR= 2.2 ++SHLIB_MINOR= 3 + +.if !defined(MACHINE_ARCH) +MACHINE_ARCH != /usr/bin/uname -m @@ -51,6 +48,7 @@ diff -ru ../linuxthreads/Makefile ./Makefile +CFLAGS += -DLIBC_RCS +CFLAGS += -DLINUXTHREADS +CFLAGS += -D__USE_UNIX98 ++CFLAGS += -D__USE_XOPEN2K -D_STACK_GROWS_DOWN -DNEWLIBC -D_THREAD_SAFE + +AINC = -I${LIBSRC_BASE}/libc/${MACHINE_ARCH} -I${.CURDIR}/sysdeps/${MACHINE_ARCH} + @@ -59,7 +57,8 @@ diff -ru ../linuxthreads/Makefile ./Makefile + getnetby_r.c getprotoby_r.c getpw_r.c getservby_r.c join.c lclone.c \ + libc_calls.c libc_thread.c manager.c mutex.c pt-machine.c ptfork.c \ + pthread.c ptlongjmp.c rwlock.c sched.c semaphore.c signals.c \ -+ specific.c spinlock.c uthread_file.c wraputhread.c wrapsyscall.c ++ specific.c spinlock.c uthread_file.c wraputhread.c wrapsyscall.c \ ++ barrier.c localtime.c + +SOBJS += libgcc_r/frame.o libgcc_r/_eh.o + @@ -74,7 +73,7 @@ diff -ru ../linuxthreads/Makefile ./Makefile + ${PREFIX}/include/pthread/linuxthreads/semaphore.h + ${INSTALL} -d -o ${BINOWN} -g ${BINGRP} -m 0755 \ + ${PREFIX}/include/pthread/linuxthreads/bits -+.for hdr in libc-lock.h libc-tsd.h pthreadtypes.h stdio-lock.h ++.for hdr in libc-lock.h libc-tsd.h pthreadtypes.h stdio-lock.h initspin.h + ${INSTALL} -C -o ${BINOWN} -g ${BINGRP} -m 444 \ + ${.CURDIR}/sysdeps/pthread/bits/$(hdr) \ + ${PREFIX}/include/pthread/linuxthreads/bits/$(hdr) @@ -125,43 +124,118 @@ diff -ru ../linuxthreads/Makefile ./Makefile -libpthread-routines := attr cancel condvar join manager mutex ptfork \ - ptlongjmp pthread signals specific errno lockfile \ - semaphore spinlock wrapsyscall rwlock pt-machine \ -- oldsemaphore events +- oldsemaphore events getcpuclockid pspinlock barrier \ +- ptclock_gettime ptclock_settime +- +-nodelete-yes = -Wl,--enable-new-dtags,-z,nodelete +-initfirst-yes = -Wl,--enable-new-dtags,-z,initfirst +-LDFLAGS-pthread.so = $(nodelete-$(have-z-nodelete)) \ +- $(initfirst-$(have-z-initfirst)) - -vpath %.c Examples --tests = ex1 ex2 ex3 ex4 ex5 ex6 +- +-tst-cancel-ARGS = "$(objpfx)" +-CFLAGS-tst-cancel.c = -fno-inline +- +-include ../Makeconfig +- +-ifeq ($(build-shared),yes) +-before-compile := $(objpfx)crti.o +-extra-objs = crti.o +- +-CFLAGS-pt-initfini.s = -g0 -fPIC -fno-inline-functions +-endif +- +-librt-tests = ex10 ex11 +-tests = ex1 ex2 ex3 ex4 ex5 ex6 ex7 ex8 ex9 $(librt-tests) ex12 ex13 joinrace \ +- tststack $(tests-nodelete-$(have-z-nodelete)) ecmutex ex14 ex15 ex16 \ +- ex17 tst-cancel +- +-ifeq (yes,$(build-shared)) +-tests-nodelete-yes = unload +-endif - -include ../Rules - +-extra-B-pthread.so = -B$(common-objpfx)linuxthreads/ +- +-znodelete-yes = -DHAVE_Z_NODELETE -CFLAGS-mutex.c += -D__NO_WEAK_PTHREAD_ALIASES -CFLAGS-specific.c += -D__NO_WEAK_PTHREAD_ALIASES --CFLAGS-pthread.c += -D__NO_WEAK_PTHREAD_ALIASES +-CFLAGS-pthread.c += -D__NO_WEAK_PTHREAD_ALIASES $(znodelete-$(have-z-nodelete)) -CFLAGS-ptfork.c += -D__NO_WEAK_PTHREAD_ALIASES --CFLAGS-cancel.c += -D__NO_WEAK_PTHREAD_ALIASES +-CFLAGS-cancel.c += -D__NO_WEAK_PTHREAD_ALIASES -D_RPC_THREAD_SAFE_ +-CFLAGS-unload.c += -DPREFIX=\"$(objpfx)\" - -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. --$(objpfx)libpthread.so: $(common-objpfx)libc.so +-$(objpfx)libpthread.so: $(common-objpfx)libc.so \ +- $(common-objpfx)libc_nonshared.a - -# Make sure we link with the thread library. -ifeq ($(build-shared),yes) --libpthread = $(objpfx)libpthread.so +-$(addprefix $(objpfx),$(tests)): $(objpfx)libpthread.so +-$(addprefix $(objpfx),$(librt-tests)): $(common-objpfx)rt/librt.so +-$(objpfx)unload: $(common-objpfx)dlfcn/libdl.so -else --libpthread = $(objpfx)libpthread.a +-$(addprefix $(objpfx),$(tests)): $(objpfx)libpthread.a +-$(addprefix $(objpfx),$(librt-tests)): $(common-objpfx)rt/librt.a +-endif +-ifeq ($(build-bounded),yes) +-$(tests:%=$(objpfx)%-bp): $(objpfx)libpthread_b.a +-$(librt-tests:%=$(objpfx)%-bp): $(common-objpfx)rt/librt_b.a -endif - --$(objpfx)ex1: $(libpthread) --$(objpfx)ex2: $(libpthread) --$(objpfx)ex3: $(libpthread) --$(objpfx)ex4: $(libpthread) --$(objpfx)ex5: $(libpthread) --$(objpfx)ex6: $(libpthread) +-ifeq ($(build-shared),yes) +-vpath pt-initfini.c $(full_config_sysdirs) +- +-$(objpfx)pt-initfini.s: pt-initfini.c +- $(compile.c) -S $(CFLAGS-pt-initfini.s) -finhibit-size-directive \ +- $(patsubst -f%,-fno-%,$(exceptions)) -o $@ +- +-# We only have one kind of startup code files. Static binaries and +-# shared libraries are build using the PIC version. +-$(objpfx)crti.S: $(objpfx)pt-initfini.s +- sed -n -e '1,/@HEADER_ENDS/p' \ +- -e '/@_.*_PROLOG_BEGINS/,/@_.*_PROLOG_ENDS/p' \ +- -e '/@TRAILER_BEGINS/,$$p' $< > $@ +- +-$(objpfx)defs.h: $(objpfx)pt-initfini.s +- sed -n -e '/@TESTS_BEGIN/,/@TESTS_END/p' $< | \ +- $(AWK) -f ../csu/defs.awk > $@ +- +-$(objpfx)crti.o: $(objpfx)crti.S $(objpfx)defs.h +- $(compile.S) -g0 $(ASFLAGS-.os) -o $@ +- +-generated += crti.S defs.h pt-initfini.s +-endif +- +-ifeq (yes,$(build-static-nss)) +-otherlibs += $(nssobjdir)/libnss_files.a $(resolvobjdir)/libnss_dns.a \ +- $(resolvobjdir)/libresolv.a +-endif + +.include <bsd.lib.mk> -diff -ru ../linuxthreads/attr.c ./attr.c ---- ../linuxthreads/attr.c Tue Oct 27 14:51:54 1998 -+++ ./attr.c Mon Feb 26 12:36:31 2001 -@@ -27,7 +27,7 @@ +diff -ru ../../work/linuxthreads-2.2.3/attr.c ./attr.c +--- ../../work/linuxthreads-2.2.3/attr.c Tue Mar 27 04:52:55 2001 ++++ ./attr.c Thu Jun 7 22:59:29 2001 +@@ -18,11 +18,14 @@ + #include <string.h> + #include <unistd.h> + #include <sys/param.h> ++#include <sys/time.h> + #include <sys/resource.h> + #include "pthread.h" + #include "internals.h" ++#if 0 + #include <shlib-compat.h> + #include <stackinfo.h> ++#endif + + int __pthread_attr_init_2_1(pthread_attr_t *attr) + { +@@ -30,7 +33,7 @@ attr->__detachstate = PTHREAD_CREATE_JOINABLE; attr->__schedpolicy = SCHED_OTHER; @@ -170,9 +244,32 @@ diff -ru ../linuxthreads/attr.c ./attr.c attr->__inheritsched = PTHREAD_EXPLICIT_SCHED; attr->__scope = PTHREAD_SCOPE_SYSTEM; attr->__guardsize = ps; -diff -ru ../linuxthreads/errno.c ./errno.c ---- ../linuxthreads/errno.c Wed Aug 26 17:57:28 1998 -+++ ./errno.c Mon Feb 26 12:53:17 2001 +diff -ru ../../work/linuxthreads-2.2.3/cancel.c ./cancel.c +--- ../../work/linuxthreads-2.2.3/cancel.c Thu Apr 12 23:10:53 2001 ++++ ./cancel.c Thu Jun 7 22:59:29 2001 +@@ -20,7 +20,6 @@ + #include "internals.h" + #include "spinlock.h" + #include "restart.h" +-#include <stackinfo.h> + + #ifdef _STACK_GROWS_DOWN + # define FRAME_LEFT(frame, other) ((char *) frame >= (char *) other) +@@ -202,9 +201,11 @@ + break; + } + ++#if 0 + /* And the TSD which needs special help. */ + if (THREAD_GETMEM(self, p_libc_specific[_LIBC_TSD_KEY_RPC_VARS]) != NULL) + __rpc_thread_destroy (); ++#endif + } + + #ifndef SHARED +diff -ru ../../work/linuxthreads-2.2.3/errno.c ./errno.c +--- ../../work/linuxthreads-2.2.3/errno.c Sat Dec 4 20:31:49 1999 ++++ ./errno.c Thu Jun 7 22:59:29 2001 @@ -19,13 +19,13 @@ #include "pthread.h" #include "internals.h" @@ -189,20 +286,29 @@ diff -ru ../linuxthreads/errno.c ./errno.c { pthread_descr self = thread_self(); return THREAD_GETMEM (self, p_h_errnop); -diff -ru ../linuxthreads/internals.h ./internals.h ---- ../linuxthreads/internals.h Fri Jan 21 02:40:19 2000 -+++ ./internals.h Mon Feb 26 12:36:31 2001 -@@ -26,8 +26,8 @@ - #include <unistd.h> - #include <sys/types.h> +diff -ru ../../work/linuxthreads-2.2.3/internals.h ./internals.h +--- ../../work/linuxthreads-2.2.3/internals.h Wed Apr 25 21:50:59 2001 ++++ ./internals.h Thu Jun 7 22:59:29 2001 +@@ -20,6 +20,7 @@ + /* Includes */ + + #include <limits.h> ++#include <netinet/in.h> + #include <resolv.h> + #include <setjmp.h> + #include <signal.h> +@@ -31,9 +32,8 @@ + extern int __compare_and_swap (long int *p, long int oldval, long int newval); + #include "pt-machine.h" +#include "freebsd-compat.h" #include "semaphore.h" -#include "../linuxthreads_db/thread_dbP.h" +-#include <hp-timing.h> #ifndef THREAD_GETMEM # define THREAD_GETMEM(descr, member) descr->member -@@ -148,14 +148,19 @@ +@@ -161,13 +161,18 @@ char p_sigwaiting; /* true if a sigwait() is in progress */ struct pthread_start_args p_start_args; /* arguments for thread creation */ void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE]; /* thread-specific data */ @@ -213,20 +319,19 @@ diff -ru ../linuxthreads/internals.h ./internals.h int p_userstack; /* nonzero if the user provided the stack */ void *p_guardaddr; /* address of guard area or NULL */ size_t p_guardsize; /* size of guard area */ - pthread_descr p_self; /* Pointer to this structure */ int p_nr; /* Index of descriptor in __pthread_handles */ -+#if (0) - int p_report_events; /* Nonzero if events must be reported. */ ++#if 0 + int p_report_events; /* Nonzero if events must be reported. */ td_eventbuf_t p_eventbuf; /* Data for event. */ +#endif struct pthread_atomic p_resume_count; /* number of times restart() was called on thread */ char p_woken_by_cancel; /* cancellation performed wakeup */ -@@ -267,11 +272,13 @@ +@@ -293,11 +298,13 @@ extern volatile int __pthread_threads_debug; -+#if (0) ++#if 0 /* Globally enabled events. */ extern volatile td_thr_events_t __pthread_threads_events; @@ -234,56 +339,65 @@ diff -ru ../linuxthreads/internals.h ./internals.h extern volatile pthread_descr __pthread_last_event; +#endif - /* Return the handle corresponding to a thread id */ + /* Flag which tells whether we are executing on SMP kernel. */ + extern int __pthread_smp_kernel; +@@ -510,8 +517,10 @@ + extern int __pthread_spin_init (pthread_spinlock_t *__lock, int __pshared); + extern int __pthread_spin_destroy (pthread_spinlock_t *__lock); + ++#if 0 + extern int __pthread_clock_gettime (hp_timing_t freq, struct timespec *tp); + extern void __pthread_clock_settime (hp_timing_t offset); ++#endif + -diff -ru ../linuxthreads/join.c ./join.c ---- ../linuxthreads/join.c Thu Jan 6 02:45:15 2000 -+++ ./join.c Mon Feb 26 12:36:31 2001 -@@ -39,6 +39,7 @@ + /* Global pointers to old or new suspend functions */ +diff -ru ../../work/linuxthreads-2.2.3/join.c ./join.c +--- ../../work/linuxthreads-2.2.3/join.c Thu Apr 12 21:02:02 2001 ++++ ./join.c Thu Jun 7 22:59:29 2001 +@@ -43,6 +43,7 @@ + /* Store return value */ + __pthread_lock(THREAD_GETMEM(self, p_lock), self); THREAD_SETMEM(self, p_retval, retval); - /* Say that we've terminated */ - THREAD_SETMEM(self, p_terminated, 1); -+#if (0) ++#if 0 /* See whether we have to signal the death. */ if (THREAD_GETMEM(self, p_report_events)) { -@@ -60,6 +61,7 @@ +@@ -64,6 +65,7 @@ __linuxthreads_death_event(); } } +#endif + /* Say that we've terminated */ + THREAD_SETMEM(self, p_terminated, 1); /* See if someone is joining on us */ - joining = THREAD_GETMEM(self, p_joining); - __pthread_unlock(THREAD_GETMEM(self, p_lock)); -diff -ru ../linuxthreads/manager.c ./manager.c ---- ../linuxthreads/manager.c Fri Jan 21 02:40:19 2000 -+++ ./manager.c Mon Feb 26 12:36:31 2001 -@@ -52,8 +52,10 @@ +diff -ru ../../work/linuxthreads-2.2.3/manager.c ./manager.c +--- ../../work/linuxthreads-2.2.3/manager.c Wed Apr 25 21:50:59 2001 ++++ ./manager.c Thu Jun 7 22:59:29 2001 +@@ -54,8 +54,10 @@ (set to 1 by gdb) */ volatile int __pthread_threads_debug; -+#if (0) ++#if 0 /* Globally enabled events. */ volatile td_thr_events_t __pthread_threads_events; +#endif /* Pointer to thread descriptor with last event. */ volatile pthread_descr __pthread_last_event; -@@ -85,10 +87,10 @@ - /* Forward declarations */ +@@ -92,9 +94,9 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr, -- void * (*start_routine)(void *), void *arg, + void * (*start_routine)(void *), void *arg, - sigset_t *mask, int father_pid, -+ void * (*start_routine)(void *), void *arg, -+ sigset_t * mask, int father_pid/*, ++ sigset_t *mask, int father_pid/*, int report_events, - td_thr_events_t *event_maskp); + td_thr_events_t *event_maskp*/); static void pthread_handle_free(pthread_t th_id); - static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode); - static void pthread_reap_children(void); -@@ -149,9 +151,10 @@ + static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode) + __attribute__ ((noreturn)); +@@ -160,9 +162,9 @@ request.req_args.create.fn, request.req_args.create.arg, &request.req_args.create.mask, @@ -291,39 +405,27 @@ diff -ru ../linuxthreads/manager.c ./manager.c + request.req_thread->p_pid/*, request.req_thread->p_report_events, - &request.req_thread->p_eventbuf.eventmask); -+ &request.req_thread->p_eventbuf.eventmask*/); -+ ++ &request.req_thread->p_eventbuf.eventmask*/); restart(request.req_thread); break; case REQ_FREE: -@@ -245,6 +248,7 @@ - return 0; +@@ -277,6 +279,7 @@ + __pthread_do_exit(outcome, CURRENT_STACK_FRAME); } -+#if (0) - static int pthread_start_thread_event(void *arg) - { - pthread_descr self = (pthread_descr) arg; -@@ -263,6 +267,7 @@ ++#if 0 + static int + __attribute__ ((noreturn)) + pthread_start_thread_event(void *arg) +@@ -297,6 +300,7 @@ /* Continue with the real function. */ - return pthread_start_thread (arg); + pthread_start_thread (arg); } +#endif static int pthread_allocate_stack(const pthread_attr_t *attr, pthread_descr default_new_thread, -@@ -295,8 +300,8 @@ - /* Allocate space for stack and thread descriptor at default address */ - new_thread = default_new_thread; - new_thread_bottom = (char *) (new_thread + 1) - stacksize; -- if (mmap((caddr_t)((char *)(new_thread + 1) - INITIAL_STACK_SIZE), -- INITIAL_STACK_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC, -+ if (mmap((caddr_t)((char *)(new_thread + 1) - stacksize), -+ stacksize, PROT_READ | PROT_WRITE | PROT_EXEC, - MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_GROWSDOWN, - -1, 0) == MAP_FAILED) - /* Bad luck, this segment is already mapped. */ -@@ -337,9 +342,9 @@ +@@ -476,9 +480,9 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg, @@ -335,7 +437,7 @@ diff -ru ../linuxthreads/manager.c ./manager.c { size_t sseg; int pid; -@@ -407,6 +412,12 @@ +@@ -549,6 +553,12 @@ } new_thread->p_priority = new_thread->p_start_args.schedparam.sched_priority; @@ -348,42 +450,31 @@ diff -ru ../linuxthreads/manager.c ./manager.c } /* Finish setting up arguments to pthread_start_thread */ new_thread->p_start_args.start_routine = start_routine; -@@ -417,6 +428,7 @@ +@@ -563,6 +573,7 @@ /* Do the cloning. We have to use two different functions depending on whether we are debugging or not. */ - pid = 0; /* Note that the thread never can have PID zero. */ -+#if (0) + pid = 0; /* Note that the thread never can have PID zero. */ ++#if 0 if (report_events) { /* See whether the TD_CREATE event bit is set in any of the -@@ -457,6 +469,7 @@ +@@ -619,6 +630,7 @@ } } } +#endif if (pid == 0) - pid = __clone(pthread_start_thread, (void **) new_thread, - CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | -@@ -468,8 +481,8 @@ - { - if (new_thread->p_guardsize != 0) - munmap(new_thread->p_guardaddr, new_thread->p_guardsize); -- munmap((caddr_t)((char *)(new_thread+1) - INITIAL_STACK_SIZE), -- INITIAL_STACK_SIZE); -+ munmap((caddr_t)((char *)(new_thread+1) - STACK_SIZE), -+ STACK_SIZE); - } - __pthread_handles[sseg].h_descr = NULL; - __pthread_handles[sseg].h_bottom = NULL; -@@ -555,6 +568,7 @@ + { + #ifdef NEED_SEPARATE_REGISTER_STACK +@@ -738,6 +750,7 @@ /* Mark thread as exited, and if detached, free its resources */ __pthread_lock(th->p_lock, NULL); th->p_exited = 1; -+#if (0) ++#if 0 /* If we have to signal this event do it now. */ if (th->p_report_events) { -@@ -574,6 +588,7 @@ +@@ -757,6 +770,7 @@ __linuxthreads_reap_event(); } } @@ -391,7 +482,7 @@ diff -ru ../linuxthreads/manager.c ./manager.c detached = th->p_detached; __pthread_unlock(th->p_lock); if (detached) -@@ -651,10 +666,14 @@ +@@ -834,10 +848,14 @@ /* Process-wide exit() */ @@ -406,10 +497,29 @@ diff -ru ../linuxthreads/manager.c ./manager.c __pthread_exit_code = exitcode; /* Send the CANCEL signal to all running threads, including the main thread, but excluding the thread from which the exit request originated -diff -ru ../linuxthreads/pthread.c ./pthread.c ---- ../linuxthreads/pthread.c Fri Jan 21 02:40:19 2000 -+++ ./pthread.c Mon Feb 26 13:11:57 2001 -@@ -20,6 +20,7 @@ +diff -ru ../../work/linuxthreads-2.2.3/ptfork.c ./ptfork.c +--- ../../work/linuxthreads-2.2.3/ptfork.c Sun Jan 7 04:35:20 2001 ++++ ./ptfork.c Thu Jun 7 22:59:29 2001 +@@ -84,7 +84,6 @@ + + pthread_call_handlers(pthread_atfork_prepare); + __pthread_once_fork_prepare(); +- __flockfilelist(); + + pid = __libc_fork(); + +@@ -97,7 +96,6 @@ + + pthread_mutex_init(&pthread_atfork_lock, NULL); + } else { +- __funlockfilelist(); + __pthread_once_fork_parent(); + pthread_call_handlers(pthread_atfork_parent); + +diff -ru ../../work/linuxthreads-2.2.3/pthread.c ./pthread.c +--- ../../work/linuxthreads-2.2.3/pthread.c Wed Apr 25 21:50:59 2001 ++++ ./pthread.c Thu Jun 7 22:59:29 2001 +@@ -21,11 +21,11 @@ #include <stdlib.h> #include <string.h> #include <unistd.h> @@ -417,7 +527,21 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c #include <fcntl.h> #include <sys/wait.h> #include <sys/resource.h> -@@ -37,7 +38,7 @@ + #include <sys/sysctl.h> +-#include <shlib-compat.h> + #include "pthread.h" + #include "internals.h" + #include "spinlock.h" +@@ -43,7 +43,7 @@ + #endif + + /* These variables are used by the setup code. */ +-extern int _errno; ++extern int _errno __asm__("errno"); + extern int _h_errno; + + /* Descriptor of the initial thread */ +@@ -60,7 +60,7 @@ NULL, /* pthread_descr p_nextlock */ PTHREAD_THREADS_MAX, /* pthread_t p_tid */ 0, /* int p_pid */ @@ -426,27 +550,26 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c &__pthread_handles[0].h_lock, /* struct _pthread_fastlock * p_lock */ 0, /* int p_signal */ NULL, /* sigjmp_buf * p_signal_buf */ -@@ -60,14 +61,19 @@ - 0, /* char p_sigwaiting */ - PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */ +@@ -84,13 +84,18 @@ + PTHREAD_START_ARGS_INITIALIZER(NULL), + /* struct pthread_start_args p_start_args */ {NULL}, /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */ + {NULL, NULL}, /* TAILQ_ENTRY(_pthread_descr_struct) qe */ + {NULL}, /* char timebuf[26] */ + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL}, /* struct tm local_tm */ {NULL}, /* void * p_libc_specific[_LIBC_TSD_KEY_N] */ - 0, /* int p_userstack */ + 1, /* int p_userstack */ NULL, /* void * p_guardaddr */ 0, /* size_t p_guardsize */ - &__pthread_initial_thread, /* pthread_descr p_self */ 0, /* Always index 0 */ -+#if (0) ++#if 0 0, /* int p_report_events */ {{{0, }}, 0, NULL}, /* td_eventbuf_t p_eventbuf */ +#endif - ATOMIC_INITIALIZER, /* struct pthread_atomic p_resume_count */ + __ATOMIC_INITIALIZER, /* struct pthread_atomic p_resume_count */ 0, /* char p_woken_by_cancel */ - NULL, /* struct pthread_extricate_if *p_extricate */ -@@ -87,7 +93,7 @@ + 0, /* char p_condvar_avail */ +@@ -117,7 +122,7 @@ NULL, /* pthread_descr p_nextlock */ 0, /* int p_tid */ 0, /* int p_pid */ @@ -455,9 +578,9 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c &__pthread_handles[1].h_lock, /* struct _pthread_fastlock * p_lock */ 0, /* int p_signal */ NULL, /* sigjmp_buf * p_signal_buf */ -@@ -110,14 +116,19 @@ - 0, /* char p_sigwaiting */ - PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */ +@@ -141,13 +146,18 @@ + PTHREAD_START_ARGS_INITIALIZER(__pthread_manager), + /* struct pthread_start_args p_start_args */ {NULL}, /* void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE] */ + {NULL, NULL}, /* TAILQ_ENTRY(_pthread_descr_struct) qe */ + {NULL}, /* char timebuf[26] */ @@ -466,49 +589,36 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c 0, /* int p_userstack */ NULL, /* void * p_guardaddr */ 0, /* size_t p_guardsize */ - &__pthread_manager_thread, /* pthread_descr p_self */ 1, /* Always index 1 */ -+#if (0) ++#if 0 0, /* int p_report_events */ {{{0, }}, 0, NULL}, /* td_eventbuf_t p_eventbuf */ +#endif - ATOMIC_INITIALIZER, /* struct pthread_atomic p_resume_count */ + __ATOMIC_INITIALIZER, /* struct pthread_atomic p_resume_count */ 0, /* char p_woken_by_cancel */ - NULL, /* struct pthread_extricate_if *p_extricate */ -@@ -153,6 +164,7 @@ + 0, /* char p_condvar_avail */ +@@ -185,6 +195,7 @@ /* For process-wide exit() */ - int __pthread_exit_requested = 0; + int __pthread_exit_requested; +int __pthread_exit_requested_bymainthread = 0; - int __pthread_exit_code = 0; + int __pthread_exit_code; - /* Pointers that select new or old suspend/resume functions -@@ -171,18 +183,20 @@ - p_pid); - - /* These variables are used by the setup code. */ --extern int _errno; -+extern int _errno __asm__("errno"); - extern int _h_errno; + /* Maximum stack size. */ +@@ -216,11 +227,7 @@ /* Forward declarations */ --static void pthread_exit_process(int retcode, void *arg); -+static void pthread_exit_process(void); - #ifndef __i386__ +-static void pthread_onexit_process(int retcode, void *arg); +-#ifndef HAVE_Z_NODELETE +-static void pthread_atexit_process(void *arg, int retcode); +-static void pthread_atexit_retcode(void *arg, int retcode); +-#endif ++static void pthread_onexit_process(void); static void pthread_handle_sigcancel(int sig); static void pthread_handle_sigrestart(int sig); - #else --static void pthread_handle_sigcancel(int sig, struct sigcontext ctx); --static void pthread_handle_sigrestart(int sig, struct sigcontext ctx); -+static void pthread_handle_sigcancel(int sig, int code, -+ struct sigcontext * ctx); -+static void pthread_handle_sigrestart(int sig, int code, -+ struct sigcontext * ctx); - #endif static void pthread_handle_sigdebug(int sig); - -@@ -194,8 +208,8 @@ +@@ -238,8 +245,8 @@ #ifndef __SIGRTMIN static int current_rtmin = -1; static int current_rtmax = -1; @@ -516,10 +626,10 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c -int __pthread_sig_cancel = SIGUSR2; +int __pthread_sig_restart = SIGUSR2; +int __pthread_sig_cancel = SIGUSR1; - int __pthread_sig_debug = 0; + int __pthread_sig_debug; #else static int current_rtmin; -@@ -206,8 +220,8 @@ +@@ -250,8 +257,8 @@ int __pthread_sig_cancel = __SIGRTMIN + 1; int __pthread_sig_debug = __SIGRTMIN + 2; #else @@ -527,59 +637,105 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c -int __pthread_sig_cancel = SIGUSR2; +int __pthread_sig_restart = SIGUSR2; +int __pthread_sig_cancel = SIGUSR1; - int __pthread_sig_debug = 0; + int __pthread_sig_debug; #endif -@@ -345,7 +359,7 @@ - #ifndef __i386__ - sa.sa_handler = pthread_handle_sigrestart; - #else -- sa.sa_handler = (__sighandler_t) pthread_handle_sigrestart; -+ sa.sa_handler = (__sighandler_t *) pthread_handle_sigrestart; - #endif - sigemptyset(&sa.sa_mask); - sa.sa_flags = 0; -@@ -353,7 +367,7 @@ - #ifndef __i386__ - sa.sa_handler = pthread_handle_sigcancel; - #else -- sa.sa_handler = (__sighandler_t) pthread_handle_sigcancel; -+ sa.sa_handler = (__sighandler_t *) pthread_handle_sigcancel; - #endif - sa.sa_flags = 0; - __sigaction(__pthread_sig_cancel, &sa, NULL); -@@ -370,7 +384,7 @@ +@@ -348,26 +355,17 @@ + static int + is_smp_system (void) + { +- static const int sysctl_args[] = { CTL_KERN, KERN_VERSION }; +- char buf[512]; ++ static const int sysctl_args[] = { CTL_HW, HW_NCPU }; ++ int buf; + size_t reslen = sizeof (buf); + +- /* Try reading the number using `sysctl' first. */ +- if (__sysctl ((int *) sysctl_args, +- sizeof (sysctl_args) / sizeof (sysctl_args[0]), +- buf, &reslen, NULL, 0) < 0) +- { +- /* This was not successful. Now try reading the /proc filesystem. */ +- int fd = __open ("/proc/sys/kernel/version", O_RDONLY); +- if (__builtin_expect (fd, 0) == -1 +- || (reslen = __read (fd, buf, sizeof (buf))) <= 0) +- /* This also didn't work. We give up and say it's a UP machine. */ +- buf[0] = '\0'; +- +- __close (fd); +- } +- +- return strstr (buf, "SMP") != NULL; ++ buf = 1; ++ if (sysctl ((int *) sysctl_args, ++ sizeof (sysctl_args) / sizeof (sysctl_args[0]), ++ &buf, &reslen, NULL, 0) < 0) ++ return 0; ++ ++ return buf > 1; + } + + +@@ -448,13 +446,7 @@ /* Register an exit function to kill all other threads. */ /* Do it early so that user-registered atexit functions are called - before pthread_exit_process. */ -- __on_exit(pthread_exit_process, NULL); -+ atexit(pthread_exit_process); + before pthread_*exit_process. */ +-#ifndef HAVE_Z_NODELETE +- if (__builtin_expect (&__dso_handle != NULL, 1)) +- __cxa_atexit ((void (*) (void *)) pthread_atexit_process, NULL, +- __dso_handle); +- else +-#endif +- __on_exit (pthread_onexit_process, NULL); ++ atexit(pthread_onexit_process); + /* How many processors. */ + __pthread_smp_kernel = is_smp_system (); } +@@ -502,12 +494,6 @@ + int pid; + struct pthread_request request; - void __pthread_initialize(void) -@@ -399,6 +413,7 @@ +-#ifndef HAVE_Z_NODELETE +- if (__builtin_expect (&__dso_handle != NULL, 1)) +- __cxa_atexit ((void (*) (void *)) pthread_atexit_retcode, NULL, +- __dso_handle); +-#endif +- + if (__pthread_max_stacksize == 0) + __pthread_init_max_stacksize (); + /* If basic initialization not done yet (e.g. we're called from a +@@ -525,6 +511,7 @@ } /* Start the thread manager */ pid = 0; -+#if (0) - if (__pthread_initial_thread.p_report_events) ++#if 0 + if (__builtin_expect (__pthread_initial_thread.p_report_events, 0)) { /* It's a bit more complicated. We have to report the creation of -@@ -436,10 +451,12 @@ - } +@@ -572,17 +559,20 @@ + __pthread_unlock(__pthread_manager_thread.p_lock); } } +#endif - if (pid == 0) - pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos, -- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, -+ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | -+ __pthread_sig_cancel, - (void *)(long)manager_pipe[0]); - if (pid == -1) { - free(__pthread_manager_thread_bos); -@@ -568,7 +585,7 @@ + if (__builtin_expect (pid, 0) == 0) + { + #ifdef NEED_SEPARATE_REGISTER_STACK + pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_bos, + THREAD_MANAGER_STACK_SIZE, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ __pthread_sig_cancel, + (void *)(long)manager_pipe[0]); + #else + pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ __pthread_sig_cancel, + (void *)(long)manager_pipe[0]); + #endif + } +@@ -715,7 +705,7 @@ __pthread_unlock(&handle->h_lock); return errno; } @@ -588,17 +744,17 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c __pthread_unlock(&handle->h_lock); if (__pthread_manager_request >= 0) __pthread_manager_adjust_prio(th->p_priority); -@@ -597,7 +614,7 @@ +@@ -751,7 +741,7 @@ /* Process-wide exit() request */ --static void pthread_exit_process(int retcode, void *arg) -+static void pthread_exit_process(void) +-static void pthread_onexit_process(int retcode, void *arg) ++static void pthread_onexit_process(void) { - struct pthread_request request; - pthread_descr self = thread_self(); -@@ -605,7 +622,7 @@ - if (__pthread_manager_request >= 0) { + if (__builtin_expect (__pthread_manager_request, 0) >= 0) { + struct pthread_request request; +@@ -759,7 +749,7 @@ + request.req_thread = self; request.req_kind = REQ_PROCESS_EXIT; - request.req_args.exit.code = retcode; @@ -606,36 +762,28 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c __libc_write(__pthread_manager_request, (char *) &request, sizeof(request)); suspend(self); -@@ -625,10 +642,11 @@ - { - pthread_descr self = thread_self(); - #else --static void pthread_handle_sigrestart(int sig, struct sigcontext ctx) -+static void pthread_handle_sigrestart(int sig, int code, -+ struct sigcontext * ctx) - { - pthread_descr self; -- asm volatile ("movw %w0,%%gs" : : "r" (ctx.gs)); -+ asm volatile ("movw %w0,%%gs" : : "r" (ctx->sc_gs)); - self = thread_self(); - #endif - THREAD_SETMEM(self, p_signal, sig); -@@ -647,11 +665,11 @@ - pthread_descr self = thread_self(); - sigjmp_buf * jmpbuf; - #else --static void pthread_handle_sigcancel(int sig, struct sigcontext ctx) -+static void pthread_handle_sigcancel(int sig, int code, struct sigcontext * ctx) - { - pthread_descr self; - sigjmp_buf * jmpbuf; -- asm volatile ("movw %w0,%%gs" : : "r" (ctx.gs)); -+ asm volatile ("movw %w0,%%gs" : : "r" (ctx->sc_gs)); - self = thread_self(); - #endif +@@ -774,19 +764,6 @@ + } + } -@@ -663,6 +681,9 @@ - if (__pthread_exit_requested) { +-#ifndef HAVE_Z_NODELETE +-static int __pthread_atexit_retcode; +- +-static void pthread_atexit_process(void *arg, int retcode) +-{ +- pthread_onexit_process (retcode ?: __pthread_atexit_retcode, arg); +-} +- +-static void pthread_atexit_retcode(void *arg, int retcode) +-{ +- __pthread_atexit_retcode = retcode; +-} +-#endif + + /* The handler for the RESTART signal just records the signal received + in the thread descriptor, and optionally performs a siglongjmp +@@ -818,6 +795,9 @@ + if (__builtin_expect (__pthread_exit_requested, 0)) { /* Main thread should accumulate times for thread manager and its children, so that timings for main thread account for all threads. */ + if (self == __pthread_main_thread && @@ -644,16 +792,16 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c if (self == __pthread_main_thread) waitpid(__pthread_manager_thread.p_pid, NULL, __WCLONE); _exit(__pthread_exit_code); -@@ -731,7 +752,7 @@ +@@ -894,7 +874,7 @@ { struct sigaction sa; /* Terminate all other threads and thread manager */ -- pthread_exit_process(0, NULL); -+ pthread_exit_process(); +- pthread_onexit_process(0, NULL); ++ pthread_onexit_process(); /* Make current thread the main thread in case the calling thread changes its mind, does not exec(), and creates new threads instead. */ __pthread_reset_main_thread(); -@@ -838,3 +859,13 @@ +@@ -1131,3 +1111,17 @@ static const int *const __pthread_require_wrappers = &__pthread_provide_wrappers; #endif @@ -667,26 +815,31 @@ diff -ru ../linuxthreads/pthread.c ./pthread.c + +extern int *__error(void); +static int *(*unusedref3)(void) __attribute__ ((unused)) = __error; -diff -ru ../linuxthreads/ptlongjmp.c ./ptlongjmp.c ---- ../linuxthreads/ptlongjmp.c Tue Oct 27 14:52:00 1998 -+++ ./ptlongjmp.c Mon Feb 26 12:36:31 2001 -@@ -19,13 +19,14 @@ ++ ++static ++struct tm *(*unusedref4)(const time_t *) __attribute__ ((unused)) = localtime; ++ +diff -ru ../../work/linuxthreads-2.2.3/ptlongjmp.c ./ptlongjmp.c +--- ../../work/linuxthreads-2.2.3/ptlongjmp.c Thu Apr 12 21:02:02 2001 ++++ ./ptlongjmp.c Thu Jun 7 22:59:29 2001 +@@ -18,14 +18,15 @@ + #include <setjmp.h> #include "pthread.h" #include "internals.h" +-#include <stackinfo.h> -+#if (0) ++#if 0 /* These functions are not declared anywhere since they shouldn't be used at another place but here. */ extern void __libc_siglongjmp (sigjmp_buf env, int val) __attribute__ ((noreturn)); extern void __libc_longjmp (sigjmp_buf env, int val) __attribute__ ((noreturn)); -- +#endif + static void pthread_cleanup_upto(__jmp_buf target) - { -@@ -44,12 +45,12 @@ +@@ -63,12 +64,12 @@ void siglongjmp(sigjmp_buf env, int val) { @@ -701,20 +854,42 @@ diff -ru ../linuxthreads/ptlongjmp.c ./ptlongjmp.c + pthread_cleanup_upto((void *) env); __libc_longjmp(env, val); } -diff -ru ../linuxthreads/semaphore.h ./semaphore.h ---- ../linuxthreads/semaphore.h Wed Feb 23 08:02:52 2000 -+++ ./semaphore.h Mon Feb 26 12:36:31 2001 +diff -ru ../../work/linuxthreads-2.2.3/restart.h ./restart.h +--- ../../work/linuxthreads-2.2.3/restart.h Mon Apr 17 17:18:55 2000 ++++ ./restart.h Thu Jun 7 22:59:29 2001 +@@ -13,7 +13,6 @@ + /* GNU Library General Public License for more details. */ + + #include <signal.h> +-#include <kernel-features.h> + + /* Primitives for controlling thread execution */ + +diff -ru ../../work/linuxthreads-2.2.3/semaphore.c ./semaphore.c +--- ../../work/linuxthreads-2.2.3/semaphore.c Thu Apr 12 21:02:02 2001 ++++ ./semaphore.c Thu Jun 7 22:59:29 2001 +@@ -21,7 +21,6 @@ + #include "spinlock.h" + #include "restart.h" + #include "queue.h" +-#include <shlib-compat.h> + + int __new_sem_init(sem_t *sem, int pshared, unsigned int value) + { +diff -ru ../../work/linuxthreads-2.2.3/semaphore.h ./semaphore.h +--- ../../work/linuxthreads-2.2.3/semaphore.h Fri Feb 9 18:04:08 2001 ++++ ./semaphore.h Thu Jun 7 22:59:29 2001 @@ -15,7 +15,6 @@ #ifndef _SEMAPHORE_H #define _SEMAPHORE_H 1 -#include <features.h> #include <sys/types.h> - - #ifndef _PTHREAD_DESCR_DEFINED -diff -ru ../linuxthreads/signals.c ./signals.c ---- ../linuxthreads/signals.c Mon Oct 4 21:50:04 1999 -+++ ./signals.c Mon Feb 26 12:36:31 2001 + #ifdef __USE_XOPEN2K + # define __need_timespec +diff -ru ../../work/linuxthreads-2.2.3/signals.c ./signals.c +--- ../../work/linuxthreads-2.2.3/signals.c Tue Apr 17 15:17:16 2001 ++++ ./signals.c Thu Jun 7 22:59:29 2001 @@ -20,7 +20,6 @@ #include "internals.h" #include "spinlock.h" @@ -727,8 +902,8 @@ diff -ru ../linuxthreads/signals.c ./signals.c } /* User-provided signal handlers */ --typedef void (*arch_sighandler_t) __PMT ((int, SIGCONTEXT)); -+typedef void (*arch_sighandler_t) __PMT ((int, int, SIGCONTEXT)); +-typedef void (*arch_sighandler_t) (int, SIGCONTEXT); ++typedef void (*arch_sighandler_t) (int, int, SIGCONTEXT); static union { arch_sighandler_t old; @@ -740,13 +915,13 @@ diff -ru ../linuxthreads/signals.c ./signals.c -static void pthread_sighandler(int signo, SIGCONTEXT ctx) +static void pthread_sighandler(int signo, int code, SIGCONTEXT ctx) { - pthread_descr self = thread_self(); + pthread_descr self; char * in_sighandler; -@@ -93,14 +92,14 @@ +@@ -94,14 +93,14 @@ in_sighandler = THREAD_GETMEM(self, p_in_sighandler); if (in_sighandler == NULL) THREAD_SETMEM(self, p_in_sighandler, CURRENT_STACK_FRAME); -- sighandler[signo].old(signo, SIGCONTEXT_EXTRA_ARGS ctx); +- CALL_SIGHANDLER(sighandler[signo].old, signo, ctx); + sighandler[signo].old(signo, code, ctx); if (in_sighandler == NULL) THREAD_SETMEM(self, p_in_sighandler, NULL); @@ -758,9 +933,9 @@ diff -ru ../linuxthreads/signals.c ./signals.c +static void pthread_sighandler_rt(int signo, siginfo_t *si, + ucontext_t *uc) { - pthread_descr self = thread_self(); + pthread_descr self; char * in_sighandler; -@@ -140,9 +139,9 @@ +@@ -145,9 +144,9 @@ && sig > 0 && sig < NSIG) { if (act->sa_flags & SA_SIGINFO) @@ -772,7 +947,7 @@ diff -ru ../linuxthreads/signals.c ./signals.c } newactp = &newact; } -@@ -153,7 +152,7 @@ +@@ -158,7 +157,7 @@ if (sig > 0 && sig < NSIG) { if (oact != NULL) @@ -781,18 +956,21 @@ diff -ru ../linuxthreads/signals.c ./signals.c if (act) /* For the assignment is does not matter whether it's a normal or real-time signal. */ -diff -ru ../linuxthreads/spinlock.c ./spinlock.c ---- ../linuxthreads/spinlock.c Thu Jan 6 02:47:19 2000 -+++ ./spinlock.c Mon Feb 26 12:36:31 2001 -@@ -137,7 +137,6 @@ - - #if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP +diff -ru ../../work/linuxthreads-2.2.3/spinlock.c ./spinlock.c +--- ../../work/linuxthreads-2.2.3/spinlock.c Tue Mar 27 04:52:56 2001 ++++ ./spinlock.c Thu Jun 7 22:59:29 2001 +@@ -24,10 +24,6 @@ + #include "spinlock.h" + #include "restart.h" +-#if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP -static void __pthread_acquire(int * spinlock); +-#endif +- - int __pthread_compare_and_swap(long * ptr, long oldval, long newval, - int * spinlock) -@@ -174,7 +173,7 @@ + /* The status field of a spinlock is a pointer whose least significant + bit is a locked flag. +@@ -701,7 +697,7 @@ - When nanosleep() returns, we try again, doing MAX_SPIN_COUNT sched_yield(), then sleeping again if needed. */ @@ -801,21 +979,21 @@ diff -ru ../linuxthreads/spinlock.c ./spinlock.c { int cnt = 0; struct timespec tm; -diff -ru ../linuxthreads/spinlock.h ./spinlock.h ---- ../linuxthreads/spinlock.h Thu Jan 6 02:45:15 2000 -+++ ./spinlock.h Mon Feb 26 12:36:31 2001 -@@ -71,6 +71,8 @@ - return 0; +diff -ru ../../work/linuxthreads-2.2.3/spinlock.h ./spinlock.h +--- ../../work/linuxthreads-2.2.3/spinlock.h Fri Feb 9 18:04:08 2001 ++++ ./spinlock.h Thu Jun 7 22:59:29 2001 +@@ -180,6 +180,8 @@ + #endif } +void __pthread_acquire(int * spinlock); + - #define LOCK_INITIALIZER {0, 0} - /* Operations on pthread_atomic, which is defined in internals.h */ -diff -ru ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/bits/pthreadtypes.h ---- ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h Fri Jan 21 02:40:19 2000 -+++ ./sysdeps/pthread/bits/pthreadtypes.h Mon Feb 26 12:36:31 2001 + + static inline long atomic_increment(struct pthread_atomic *pa) +diff -ru ../../work/linuxthreads-2.2.3/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/bits/pthreadtypes.h +--- ../../work/linuxthreads-2.2.3/sysdeps/pthread/bits/pthreadtypes.h Fri Feb 9 18:04:09 2001 ++++ ./sysdeps/pthread/bits/pthreadtypes.h Thu Jun 7 22:59:29 2001 @@ -20,7 +20,6 @@ #define _BITS_PTHREADTYPES_H 1 @@ -824,7 +1002,7 @@ diff -ru ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/b /* Fast locks (not abstract because mutexes and conditions aren't abstract). */ struct _pthread_fastlock -@@ -41,7 +40,7 @@ +@@ -42,7 +41,7 @@ { int __detachstate; int __schedpolicy; @@ -833,30 +1011,24 @@ diff -ru ../linuxthreads/sysdeps/pthread/bits/pthreadtypes.h ./sysdeps/pthread/b int __inheritsched; int __scope; size_t __guardsize; -diff -ru ../linuxthreads/sysdeps/pthread/pthread.h ./sysdeps/pthread/pthread.h ---- ../linuxthreads/sysdeps/pthread/pthread.h Fri Jan 21 02:40:19 2000 -+++ ./sysdeps/pthread/pthread.h Mon Feb 26 12:36:31 2001 -@@ -15,7 +15,6 @@ +diff -ru ../../work/linuxthreads-2.2.3/sysdeps/pthread/pthread.h ./sysdeps/pthread/pthread.h +--- ../../work/linuxthreads-2.2.3/sysdeps/pthread/pthread.h Tue Mar 27 04:52:56 2001 ++++ ./sysdeps/pthread/pthread.h Thu Jun 7 22:59:29 2001 +@@ -15,7 +15,9 @@ #ifndef _PTHREAD_H #define _PTHREAD_H 1 -#include <features.h> ++#ifndef __THROW ++#define __THROW ++#endif #include <sched.h> #include <time.h> -@@ -108,7 +107,7 @@ - - struct _pthread_cleanup_buffer - { -- void (*__routine) __PMT ((void *)); /* Function to call. */ -+ void (*__routine) __P ((void *)); /* Function to call. */ - void *__arg; /* Its argument. */ - int __canceltype; /* Saved cancellation type. */ - struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions. */ -diff -ru ../linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h ./sysdeps/unix/sysv/linux/bits/local_lim.h ---- ../linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h Thu Nov 12 19:03:14 1998 -+++ ./sysdeps/unix/sysv/linux/bits/local_lim.h Mon Feb 26 12:36:31 2001 -@@ -24,7 +24,7 @@ +diff -ru ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/local_lim.h ./sysdeps/unix/sysv/linux/bits/local_lim.h +--- ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/local_lim.h Fri Jun 9 19:17:35 2000 ++++ ./sysdeps/unix/sysv/linux/bits/local_lim.h Thu Jun 7 22:59:29 2001 +@@ -33,7 +33,7 @@ #endif /* The kernel sources contain a file with all the needed information. */ @@ -865,23 +1037,23 @@ diff -ru ../linuxthreads/sysdeps/unix/sysv/linux/bits/local_lim.h ./sysdeps/unix /* Have to remove NR_OPEN? */ #ifdef __undef_NR_OPEN -diff -ru ../linuxthreads/sysdeps/unix/sysv/linux/bits/sigthread.h ./sysdeps/unix/sysv/linux/bits/sigthread.h ---- ../linuxthreads/sysdeps/unix/sysv/linux/bits/sigthread.h Sat Sep 12 23:33:14 1998 -+++ ./sysdeps/unix/sysv/linux/bits/sigthread.h Mon Feb 26 12:36:31 2001 -@@ -28,8 +28,8 @@ - +diff -ru ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/sigthread.h ./sysdeps/unix/sysv/linux/bits/sigthread.h +--- ../../work/linuxthreads-2.2.3/sysdeps/unix/sysv/linux/bits/sigthread.h Thu Aug 31 21:45:04 2000 ++++ ./sysdeps/unix/sysv/linux/bits/sigthread.h Thu Jun 7 22:59:29 2001 +@@ -29,8 +29,8 @@ /* Modify the signal mask for the calling thread. The arguments have the same meaning as for sigprocmask(2). */ --extern int pthread_sigmask __P ((int __how, __const __sigset_t *__newmask, -- __sigset_t *__oldmask)); -+extern int pthread_sigmask __P ((int __how, __const sigset_t *__newmask, -+ sigset_t *__oldmask)); + extern int pthread_sigmask (int __how, +- __const __sigset_t *__restrict __newmask, +- __sigset_t *__restrict __oldmask)__THROW; ++ __const sigset_t *__restrict __newmask, ++ sigset_t *__restrict __oldmask)__THROW; /* Send signal SIGNO to the given thread. */ - extern int pthread_kill __P ((pthread_t __thread, int __signo)); -diff -ru ../linuxthreads/wrapsyscall.c ./wrapsyscall.c ---- ../linuxthreads/wrapsyscall.c Tue Dec 1 20:34:20 1998 -+++ ./wrapsyscall.c Mon Feb 26 12:36:31 2001 + extern int pthread_kill (pthread_t __thread, int __signo) __THROW; +diff -ru ../../work/linuxthreads-2.2.3/wrapsyscall.c ./wrapsyscall.c +--- ../../work/linuxthreads-2.2.3/wrapsyscall.c Wed Apr 25 21:50:59 2001 ++++ ./wrapsyscall.c Thu Jun 7 22:59:29 2001 @@ -29,6 +29,7 @@ #include <sys/resource.h> #include <sys/wait.h> @@ -889,45 +1061,12 @@ diff -ru ../linuxthreads/wrapsyscall.c ./wrapsyscall.c +#include "internals.h" - #ifndef PIC -@@ -39,20 +40,20 @@ - - - #define CANCELABLE_SYSCALL(res_type, name, param_list, params) \ --res_type __libc_##name param_list; \ -+res_type _##name param_list; \ - res_type \ - name param_list \ - { \ - res_type result; \ - int oldtype; \ - pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype); \ -- result = __libc_##name params; \ -+ result = _##name params; \ - pthread_setcanceltype (oldtype, NULL); \ - return result; \ - } - - #define CANCELABLE_SYSCALL_VA(res_type, name, param_list, params, last_arg) \ --res_type __libc_##name param_list; \ -+res_type _##name param_list; \ - res_type \ - name param_list \ - { \ -@@ -61,7 +62,7 @@ - va_list ap; \ - pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype); \ - va_start (ap, last_arg); \ -- result = __libc_##name params; \ -+ result = _##name params; \ - va_end (ap); \ - pthread_setcanceltype (oldtype, NULL); \ - return result; \ -@@ -83,10 +84,12 @@ + #ifndef SHARED +@@ -85,15 +86,19 @@ CANCELABLE_SYSCALL (int, fsync, (int fd), (fd)) -+#if (0) ++#if 0 /* lseek(2). */ CANCELABLE_SYSCALL (off_t, lseek, (int fd, off_t offset, int whence), (fd, offset, whence)) @@ -935,66 +1074,98 @@ diff -ru ../linuxthreads/wrapsyscall.c ./wrapsyscall.c +#endif ++#if 0 + /* lseek64(2). */ + CANCELABLE_SYSCALL (off64_t, lseek64, (int fd, off64_t offset, int whence), + (fd, offset, whence)) ++#endif + + /* msync(2). */ -@@ -107,7 +110,7 @@ +@@ -113,40 +118,50 @@ + strong_alias (open, __open) + + ++#if 0 + /* open64(3). */ + CANCELABLE_SYSCALL_VA (int, open64, (const char *pathname, int flags, ...), + (pathname, flags, va_arg (ap, mode_t)), flags) + strong_alias (open64, __open64) ++#endif /* pause(2). */ --CANCELABLE_SYSCALL (int, pause, (void), ()) -+CANCELABLE_SYSCALL (int, _pause, (void), ()) + CANCELABLE_SYSCALL (int, pause, (void), ()) - /* read(2). */ -@@ -117,20 +120,21 @@ ++#if 0 + /* pread(3). */ + CANCELABLE_SYSCALL (ssize_t, pread, (int fd, void *buf, size_t count, + off_t offset), + (fd, buf, count, offset)) ++#endif - /* system(3). */ --CANCELABLE_SYSCALL (int, system, (const char *line), (line)) -- -+CANCELABLE_SYSCALL (int, _system, (const char *line), (line)) ++#if 0 + /* pread64(3). */ + CANCELABLE_SYSCALL (ssize_t, pread64, (int fd, void *buf, size_t count, + off64_t offset), + (fd, buf, count, offset)) + strong_alias (pread64, __pread64) ++#endif - /* tcdrain(2). */ --CANCELABLE_SYSCALL (int, tcdrain, (int fd), (fd)) -+CANCELABLE_SYSCALL (int, _tcdrain, (int fd), (fd)) ++#if 0 + /* pwrite(3). */ + CANCELABLE_SYSCALL (ssize_t, pwrite, (int fd, const void *buf, size_t n, + off_t offset), + (fd, buf, n, offset)) ++#endif - /* wait(2). */ --CANCELABLE_SYSCALL (__pid_t, wait, (__WAIT_STATUS_DEFN stat_loc), (stat_loc)) -+#if (1) -+CANCELABLE_SYSCALL (__pid_t, _wait, (__WAIT_STATUS_DEFN stat_loc), (stat_loc)) + ++#if 0 + /* pwrite64(3). */ + CANCELABLE_SYSCALL (ssize_t, pwrite64, (int fd, const void *buf, size_t n, + off64_t offset), + (fd, buf, n, offset)) + strong_alias (pwrite64, __pwrite64) +#endif + + + /* read(2). */ +@@ -165,7 +180,9 @@ + + /* wait(2). */ + CANCELABLE_SYSCALL (__pid_t, wait, (__WAIT_STATUS_DEFN stat_loc), (stat_loc)) ++#if 0 strong_alias (wait, __wait) ++#endif /* waitpid(2). */ --CANCELABLE_SYSCALL (__pid_t, waitpid, (__pid_t pid, int *stat_loc, -+CANCELABLE_SYSCALL (__pid_t, _waitpid, (__pid_t pid, int *stat_loc, - int options), - (pid, stat_loc, options)) - -@@ -155,9 +159,11 @@ +@@ -194,9 +211,11 @@ (fd, addr, len)) strong_alias (connect, __connect) -+#if (0) ++#if 0 /* recv(2). */ - CANCELABLE_SYSCALL (int, recv, (int fd, __ptr_t buf, size_t n, int flags), + CANCELABLE_SYSCALL (ssize_t, recv, (int fd, __ptr_t buf, size_t n, int flags), (fd, buf, n, flags)) +#endif /* recvfrom(2). */ - CANCELABLE_SYSCALL (int, recvfrom, (int fd, __ptr_t buf, size_t n, int flags, -@@ -168,11 +174,13 @@ - CANCELABLE_SYSCALL (int, recvmsg, (int fd, struct msghdr *message, int flags), + CANCELABLE_SYSCALL (ssize_t, recvfrom, (int fd, __ptr_t buf, size_t n, int flags, +@@ -207,11 +226,13 @@ + CANCELABLE_SYSCALL (ssize_t, recvmsg, (int fd, struct msghdr *message, int flags), (fd, message, flags)) -+#if (0) ++#if 0 /* send(2). */ - CANCELABLE_SYSCALL (int, send, (int fd, const __ptr_t buf, size_t n, - int flags), + CANCELABLE_SYSCALL (ssize_t, send, (int fd, const __ptr_t buf, size_t n, + int flags), (fd, buf, n, flags)) strong_alias (send, __send) +#endif /* sendmsg(2). */ - CANCELABLE_SYSCALL (int, sendmsg, (int fd, const struct msghdr *message, + CANCELABLE_SYSCALL (ssize_t, sendmsg, (int fd, const struct msghdr *message, diff --git a/devel/linuxthreads/files/wraputhread.c b/devel/linuxthreads/files/wraputhread.c index 7898d49ceb6f..8f1dafd987ae 100644 --- a/devel/linuxthreads/files/wraputhread.c +++ b/devel/linuxthreads/files/wraputhread.c @@ -23,13 +23,21 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $FreeBSD: /tmp/pcvs/ports/devel/linuxthreads/files/wraputhread.c,v 1.1 2001-02-20 00:34:57 tegge Exp $ + * $FreeBSD: /tmp/pcvs/ports/devel/linuxthreads/files/wraputhread.c,v 1.2 2001-06-14 01:34:18 tegge Exp $ */ #include <pthread.h> #include <stdlib.h> #include <sys/errno.h> +void *__pthread_getspecific(pthread_key_t); +int __pthread_setspecific(pthread_key_t, const void *); +int __pthread_key_create(pthread_key_t *, void (*) (void *)); +int __pthread_mutex_destroy(pthread_mutex_t *); +int __pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *); +int __pthread_mutex_lock(pthread_mutex_t *); +int __pthread_mutex_trylock(pthread_mutex_t *); +int __pthread_mutex_unlock(pthread_mutex_t *); void * _pthread_getspecific(pthread_key_t key) diff --git a/devel/linuxthreads/pkg-plist b/devel/linuxthreads/pkg-plist index 8c8cd24c0932..69dab5f05c8c 100644 --- a/devel/linuxthreads/pkg-plist +++ b/devel/linuxthreads/pkg-plist @@ -1,13 +1,14 @@ lib/liblthread.a lib/liblthread_p.a lib/liblthread.so -lib/liblthread.so.2 +lib/liblthread.so.2.2 lib/liblgcc_r.a lib/liblgcc_r_p.a include/pthread/linuxthreads/pthread.h include/pthread/linuxthreads/semaphore.h include/pthread/linuxthreads/pt-machine.h include/pthread/linuxthreads/useldt.h +include/pthread/linuxthreads/bits/initspin.h include/pthread/linuxthreads/bits/libc-lock.h include/pthread/linuxthreads/bits/libc-tsd.h include/pthread/linuxthreads/bits/pthreadtypes.h |