AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-25 22:40:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update.

Browse Source 
* sysdeps/unix/sysv/linux/powerpc/pread.c: Do not use the i386 version.
	Instead call the system call wrapper function using an 64bit argument.
	* sysdeps/unix/sysv/linux/powerpc/pread64.c: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/pwrite.c: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/pwrite64.c: Likewise.
This commit is contained in:
Ulrich Drepper 1998-10-27 14:19:07 +00:00
parent 91cc83ff97
commit c70ca1fa69
18 changed files with 501 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -3,6 +3,12 @@
* sysdeps/unix/sysv/linux/powerpc/syscalls.list: Tidy up, correct * sysdeps/unix/sysv/linux/powerpc/syscalls.list: Tidy up, correct
llseek. llseek.
* sysdeps/unix/sysv/linux/powerpc/pread.c: Do not use the i386 version.
Instead call the system call wrapper function using an 64bit argument.
* sysdeps/unix/sysv/linux/powerpc/pread64.c: Likewise.
* sysdeps/unix/sysv/linux/powerpc/pwrite.c: Likewise.
* sysdeps/unix/sysv/linux/powerpc/pwrite64.c: Likewise.
1998-10-27 Ulrich Drepper <drepper@cygnus.com> 1998-10-27 Ulrich Drepper <drepper@cygnus.com>
* signal/signal.h: Don't include <time.h> for timespec, add * signal/signal.h: Don't include <time.h> for timespec, add

23
linuxthreads/ChangeLog
View File

@ -1,3 +1,26 @@
1998-10-27 13:46 Ulrich Drepper <drepper@cygnus.com>
* sysdeps/pthread/pthread.h (struct _pthread_cleanup_buffer): Prepend
__ to field names of the struct.
* sysdeps/pthread/bits/pthreadtypes.h (struct _pthread_fastlock):
Likewise.
(pthread_attr_t): Likewise.
(pthread_cond_t): Likewise.
(pthread_condattr_t): Likewise.
(pthread_mutex_t): Likewise.
(pthread_mutexattr_t): Likewise.
(pthread_rwlock_t): Likewise.
(pthread_rwlockattr_t): Likewise.
* attr.c: Adjust for pthread.h and pthreadtypes.h change.
* cancel.c: Likewise.
* condvar.c: Likewise.
* manager.c: Likewise.
* mutex.c: Likewise.
* pthread.c: Likewise.
* ptlongjmp.c: Likewise.
* rwlock.c: Likewise.
* spinlock.c: Likewise.
1998-10-09 Ulrich Drepper <drepper@cygnus.com> 1998-10-09 Ulrich Drepper <drepper@cygnus.com>
* sysdeps/i386/pt-machine.h (get_eflags, set_eflags): Mark these * sysdeps/i386/pt-machine.h (get_eflags, set_eflags): Mark these

68
linuxthreads/attr.c
View File

@ -25,15 +25,15 @@ int __pthread_attr_init_2_1(pthread_attr_t *attr)
{ {
size_t ps = __getpagesize (); size_t ps = __getpagesize ();
attr->detachstate = PTHREAD_CREATE_JOINABLE; attr->__detachstate = PTHREAD_CREATE_JOINABLE;
attr->schedpolicy = SCHED_OTHER; attr->__schedpolicy = SCHED_OTHER;
attr->schedparam.sched_priority = 0; attr->__schedparam.sched_priority = 0;
attr->inheritsched = PTHREAD_EXPLICIT_SCHED; attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
attr->scope = PTHREAD_SCOPE_SYSTEM; attr->__scope = PTHREAD_SCOPE_SYSTEM;
attr->guardsize = ps; attr->__guardsize = ps;
attr->stackaddr = NULL; attr->__stackaddr = NULL;
attr->stackaddr_set = 0; attr->__stackaddr_set = 0;
attr->stacksize = STACK_SIZE - ps; attr->__stacksize = STACK_SIZE - ps;
return 0; return 0;
} }
#if defined HAVE_ELF && defined PIC && defined DO_VERSIONING #if defined HAVE_ELF && defined PIC && defined DO_VERSIONING
@ -41,11 +41,11 @@ default_symbol_version (__pthread_attr_init_2_1, pthread_attr_init, GLIBC_2.1);
int __pthread_attr_init_2_0(pthread_attr_t *attr) int __pthread_attr_init_2_0(pthread_attr_t *attr)
{ {
attr->detachstate = PTHREAD_CREATE_JOINABLE; attr->__detachstate = PTHREAD_CREATE_JOINABLE;
attr->schedpolicy = SCHED_OTHER; attr->__schedpolicy = SCHED_OTHER;
attr->schedparam.sched_priority = 0; attr->__schedparam.sched_priority = 0;
attr->inheritsched = PTHREAD_EXPLICIT_SCHED; attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
attr->scope = PTHREAD_SCOPE_SYSTEM; attr->__scope = PTHREAD_SCOPE_SYSTEM;
return 0; return 0;
} }
symbol_version (__pthread_attr_init_2_0, pthread_attr_init, GLIBC_2.0); symbol_version (__pthread_attr_init_2_0, pthread_attr_init, GLIBC_2.0);
@ -63,32 +63,32 @@ int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
if (detachstate < PTHREAD_CREATE_JOINABLE || if (detachstate < PTHREAD_CREATE_JOINABLE ||
detachstate > PTHREAD_CREATE_DETACHED) detachstate > PTHREAD_CREATE_DETACHED)
return EINVAL; return EINVAL;
attr->detachstate = detachstate; attr->__detachstate = detachstate;
return 0; return 0;
} }
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
{ {
*detachstate = attr->detachstate; *detachstate = attr->__detachstate;
return 0; return 0;
} }
int pthread_attr_setschedparam(pthread_attr_t *attr, int pthread_attr_setschedparam(pthread_attr_t *attr,
const struct sched_param *param) const struct sched_param *param)
{ {
int max_prio = __sched_get_priority_max(attr->schedpolicy); int max_prio = __sched_get_priority_max(attr->__schedpolicy);
int min_prio = __sched_get_priority_min(attr->schedpolicy); int min_prio = __sched_get_priority_min(attr->__schedpolicy);
if (param->sched_priority < min_prio || param->sched_priority > max_prio) if (param->sched_priority < min_prio || param->sched_priority > max_prio)
return EINVAL; return EINVAL;
memcpy (&attr->schedparam, param, sizeof (struct sched_param)); memcpy (&attr->__schedparam, param, sizeof (struct sched_param));
return 0; return 0;
} }
int pthread_attr_getschedparam(const pthread_attr_t *attr, int pthread_attr_getschedparam(const pthread_attr_t *attr,
struct sched_param *param) struct sched_param *param)
{ {
memcpy (param, &attr->schedparam, sizeof (struct sched_param)); memcpy (param, &attr->__schedparam, sizeof (struct sched_param));
return 0; return 0;
} }
@ -96,13 +96,13 @@ int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
{ {
if (policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR) if (policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR)
return EINVAL; return EINVAL;
attr->schedpolicy = policy; attr->__schedpolicy = policy;
return 0; return 0;
} }
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy) int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
{ {
*policy = attr->schedpolicy; *policy = attr->__schedpolicy;
return 0; return 0;
} }
@ -110,13 +110,13 @@ int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
{ {
if (inherit != PTHREAD_INHERIT_SCHED && inherit != PTHREAD_EXPLICIT_SCHED) if (inherit != PTHREAD_INHERIT_SCHED && inherit != PTHREAD_EXPLICIT_SCHED)
return EINVAL; return EINVAL;
attr->inheritsched = inherit; attr->__inheritsched = inherit;
return 0; return 0;
} }
int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit) int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
{ {
*inherit = attr->inheritsched; *inherit = attr->__inheritsched;
return 0; return 0;
} }
@ -124,7 +124,7 @@ int pthread_attr_setscope(pthread_attr_t *attr, int scope)
{ {
switch (scope) { switch (scope) {
case PTHREAD_SCOPE_SYSTEM: case PTHREAD_SCOPE_SYSTEM:
attr->scope = scope; attr->__scope = scope;
return 0; return 0;
case PTHREAD_SCOPE_PROCESS: case PTHREAD_SCOPE_PROCESS:
return ENOTSUP; return ENOTSUP;
@ -135,7 +135,7 @@ int pthread_attr_setscope(pthread_attr_t *attr, int scope)
int pthread_attr_getscope(const pthread_attr_t *attr, int *scope) int pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
{ {
*scope = attr->scope; *scope = attr->__scope;
return 0; return 0;
} }
@ -147,9 +147,9 @@ int __pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
guardsize = roundup (guardsize, ps); guardsize = roundup (guardsize, ps);
/* The guard size must not be larger than the stack itself */ /* The guard size must not be larger than the stack itself */
if (guardsize >= attr->stacksize) return EINVAL; if (guardsize >= attr->__stacksize) return EINVAL;
attr->guardsize = guardsize; attr->__guardsize = guardsize;
return 0; return 0;
} }
@ -157,15 +157,15 @@ weak_alias (__pthread_attr_setguardsize, pthread_attr_setguardsize)
int __pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize) int __pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
{ {
*guardsize = attr->guardsize; *guardsize = attr->__guardsize;
return 0; return 0;
} }
weak_alias (__pthread_attr_getguardsize, pthread_attr_getguardsize) weak_alias (__pthread_attr_getguardsize, pthread_attr_getguardsize)
int __pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr) int __pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
{ {
attr->stackaddr = stackaddr; attr->__stackaddr = stackaddr;
attr->stackaddr_set = 1; attr->__stackaddr_set = 1;
return 0; return 0;
} }
weak_alias (__pthread_attr_setstackaddr, pthread_attr_setstackaddr) weak_alias (__pthread_attr_setstackaddr, pthread_attr_setstackaddr)
@ -175,7 +175,7 @@ int __pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
/* XXX This function has a stupid definition. The standard specifies /* XXX This function has a stupid definition. The standard specifies
no error value but what is if no stack address was set? We simply no error value but what is if no stack address was set? We simply
return the value we have in the member. */ return the value we have in the member. */
*stackaddr = attr->stackaddr; *stackaddr = attr->__stackaddr;
return 0; return 0;
} }
weak_alias (__pthread_attr_getstackaddr, pthread_attr_getstackaddr) weak_alias (__pthread_attr_getstackaddr, pthread_attr_getstackaddr)
@ -186,14 +186,14 @@ int __pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
if (stacksize < PTHREAD_STACK_MIN) if (stacksize < PTHREAD_STACK_MIN)
return EINVAL; return EINVAL;
attr->stacksize = stacksize; attr->__stacksize = stacksize;
return 0; return 0;
} }
weak_alias (__pthread_attr_setstacksize, pthread_attr_setstacksize) weak_alias (__pthread_attr_setstacksize, pthread_attr_setstacksize)
int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize) int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
{ {
*stacksize = attr->stacksize; *stacksize = attr->__stacksize;
return 0; return 0;
} }
weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize) weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize)

28
linuxthreads/cancel.c
View File

@ -77,9 +77,9 @@ void _pthread_cleanup_push(struct _pthread_cleanup_buffer * buffer,
void (*routine)(void *), void * arg) void (*routine)(void *), void * arg)
{ {
pthread_descr self = thread_self(); pthread_descr self = thread_self();
buffer->routine = routine; buffer->__routine = routine;
buffer->arg = arg; buffer->__arg = arg;
buffer->prev = THREAD_GETMEM(self, p_cleanup); buffer->__prev = THREAD_GETMEM(self, p_cleanup);
THREAD_SETMEM(self, p_cleanup, buffer); THREAD_SETMEM(self, p_cleanup, buffer);
} }
@ -87,18 +87,18 @@ void _pthread_cleanup_pop(struct _pthread_cleanup_buffer * buffer,
int execute) int execute)
{ {
pthread_descr self = thread_self(); pthread_descr self = thread_self();
if (execute) buffer->routine(buffer->arg); if (execute) buffer->__routine(buffer->__arg);
THREAD_SETMEM(self, p_cleanup, buffer->prev); THREAD_SETMEM(self, p_cleanup, buffer->__prev);
} }
void _pthread_cleanup_push_defer(struct _pthread_cleanup_buffer * buffer, void _pthread_cleanup_push_defer(struct _pthread_cleanup_buffer * buffer,
void (*routine)(void *), void * arg) void (*routine)(void *), void * arg)
{ {
pthread_descr self = thread_self(); pthread_descr self = thread_self();
buffer->routine = routine; buffer->__routine = routine;
buffer->arg = arg; buffer->__arg = arg;
buffer->canceltype = THREAD_GETMEM(self, p_canceltype); buffer->__canceltype = THREAD_GETMEM(self, p_canceltype);
buffer->prev = THREAD_GETMEM(self, p_cleanup); buffer->__prev = THREAD_GETMEM(self, p_cleanup);
THREAD_SETMEM(self, p_canceltype, PTHREAD_CANCEL_DEFERRED); THREAD_SETMEM(self, p_canceltype, PTHREAD_CANCEL_DEFERRED);
THREAD_SETMEM(self, p_cleanup, buffer); THREAD_SETMEM(self, p_cleanup, buffer);
} }
@ -107,9 +107,9 @@ void _pthread_cleanup_pop_restore(struct _pthread_cleanup_buffer * buffer,
int execute) int execute)
{ {
pthread_descr self = thread_self(); pthread_descr self = thread_self();
if (execute) buffer->routine(buffer->arg); if (execute) buffer->__routine(buffer->__arg);
THREAD_SETMEM(self, p_cleanup, buffer->prev); THREAD_SETMEM(self, p_cleanup, buffer->__prev);
THREAD_SETMEM(self, p_canceltype, buffer->canceltype); THREAD_SETMEM(self, p_canceltype, buffer->__canceltype);
if (THREAD_GETMEM(self, p_canceled) && if (THREAD_GETMEM(self, p_canceled) &&
THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE &&
THREAD_GETMEM(self, p_canceltype) == PTHREAD_CANCEL_ASYNCHRONOUS) THREAD_GETMEM(self, p_canceltype) == PTHREAD_CANCEL_ASYNCHRONOUS)
@ -120,8 +120,8 @@ void __pthread_perform_cleanup(void)
{ {
pthread_descr self = thread_self(); pthread_descr self = thread_self();
struct _pthread_cleanup_buffer * c; struct _pthread_cleanup_buffer * c;
for (c = THREAD_GETMEM(self, p_cleanup); c != NULL; c = c->prev) for (c = THREAD_GETMEM(self, p_cleanup); c != NULL; c = c->__prev)
c->routine(c->arg); c->__routine(c->__arg);
} }
#ifndef PIC #ifndef PIC

50
linuxthreads/condvar.c
View File

@ -28,14 +28,14 @@
int pthread_cond_init(pthread_cond_t *cond, int pthread_cond_init(pthread_cond_t *cond,
const pthread_condattr_t *cond_attr) const pthread_condattr_t *cond_attr)
{ {
__pthread_init_lock(&cond->c_lock); __pthread_init_lock(&cond->__c_lock);
cond->c_waiting = NULL; cond->__c_waiting = NULL;
return 0; return 0;
} }
int pthread_cond_destroy(pthread_cond_t *cond) int pthread_cond_destroy(pthread_cond_t *cond)
{ {
if (cond->c_waiting != NULL) return EBUSY; if (cond->__c_waiting != NULL) return EBUSY;
return 0; return 0;
} }
@ -43,9 +43,9 @@ int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{ {
volatile pthread_descr self = thread_self(); volatile pthread_descr self = thread_self();
__pthread_lock(&cond->c_lock); __pthread_lock(&cond->__c_lock);
enqueue(&cond->c_waiting, self); enqueue(&cond->__c_waiting, self);
__pthread_unlock(&cond->c_lock); __pthread_unlock(&cond->__c_lock);
pthread_mutex_unlock(mutex); pthread_mutex_unlock(mutex);
suspend_with_cancellation(self); suspend_with_cancellation(self);
pthread_mutex_lock(mutex); pthread_mutex_lock(mutex);
@ -53,9 +53,9 @@ int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
if (THREAD_GETMEM(self, p_canceled) if (THREAD_GETMEM(self, p_canceled)
&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) { && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
/* Remove ourselves from the waiting queue if we're still on it */ /* Remove ourselves from the waiting queue if we're still on it */
__pthread_lock(&cond->c_lock); __pthread_lock(&cond->__c_lock);
remove_from_queue(&cond->c_waiting, self); remove_from_queue(&cond->__c_waiting, self);
__pthread_unlock(&cond->c_lock); __pthread_unlock(&cond->__c_lock);
pthread_exit(PTHREAD_CANCELED); pthread_exit(PTHREAD_CANCELED);
} }
return 0; return 0;
@ -72,9 +72,9 @@ pthread_cond_timedwait_relative(pthread_cond_t *cond,
sigjmp_buf jmpbuf; sigjmp_buf jmpbuf;
/* Wait on the condition */ /* Wait on the condition */
__pthread_lock(&cond->c_lock); __pthread_lock(&cond->__c_lock);
enqueue(&cond->c_waiting, self); enqueue(&cond->__c_waiting, self);
__pthread_unlock(&cond->c_lock); __pthread_unlock(&cond->__c_lock);
pthread_mutex_unlock(mutex); pthread_mutex_unlock(mutex);
/* Set up a longjmp handler for the restart and cancel signals */ /* Set up a longjmp handler for the restart and cancel signals */
if (sigsetjmp(jmpbuf, 1) == 0) { if (sigsetjmp(jmpbuf, 1) == 0) {
@ -107,17 +107,17 @@ pthread_cond_timedwait_relative(pthread_cond_t *cond,
/* This is a cancellation point */ /* This is a cancellation point */
if (THREAD_GETMEM(self, p_canceled) if (THREAD_GETMEM(self, p_canceled)
&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) { && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
__pthread_lock(&cond->c_lock); __pthread_lock(&cond->__c_lock);
remove_from_queue(&cond->c_waiting, self); remove_from_queue(&cond->__c_waiting, self);
__pthread_unlock(&cond->c_lock); __pthread_unlock(&cond->__c_lock);
pthread_mutex_lock(mutex); pthread_mutex_lock(mutex);
pthread_exit(PTHREAD_CANCELED); pthread_exit(PTHREAD_CANCELED);
} }
/* If not signaled: also remove ourselves and return an error code */ /* If not signaled: also remove ourselves and return an error code */
if (THREAD_GETMEM(self, p_signal) == 0) { if (THREAD_GETMEM(self, p_signal) == 0) {
__pthread_lock(&cond->c_lock); __pthread_lock(&cond->__c_lock);
remove_from_queue(&cond->c_waiting, self); remove_from_queue(&cond->__c_waiting, self);
__pthread_unlock(&cond->c_lock); __pthread_unlock(&cond->__c_lock);
pthread_mutex_lock(mutex); pthread_mutex_lock(mutex);
return retsleep == 0 ? ETIMEDOUT : EINTR; return retsleep == 0 ? ETIMEDOUT : EINTR;
} }
@ -147,9 +147,9 @@ int pthread_cond_signal(pthread_cond_t *cond)
{ {
pthread_descr th; pthread_descr th;
__pthread_lock(&cond->c_lock); __pthread_lock(&cond->__c_lock);
th = dequeue(&cond->c_waiting); th = dequeue(&cond->__c_waiting);
__pthread_unlock(&cond->c_lock); __pthread_unlock(&cond->__c_lock);
if (th != NULL) restart(th); if (th != NULL) restart(th);
return 0; return 0;
} }
@ -158,11 +158,11 @@ int pthread_cond_broadcast(pthread_cond_t *cond)
{ {
pthread_descr tosignal, th; pthread_descr tosignal, th;
__pthread_lock(&cond->c_lock); __pthread_lock(&cond->__c_lock);
/* Copy the current state of the waiting queue and empty it */ /* Copy the current state of the waiting queue and empty it */
tosignal = cond->c_waiting; tosignal = cond->__c_waiting;
cond->c_waiting = NULL; cond->__c_waiting = NULL;
__pthread_unlock(&cond->c_lock); __pthread_unlock(&cond->__c_lock);
/* Now signal each process in the queue */ /* Now signal each process in the queue */
while ((th = dequeue(&tosignal)) != NULL) restart(th); while ((th = dequeue(&tosignal)) != NULL) restart(th);
return 0; return 0;

30
linuxthreads/manager.c
View File

@ -222,12 +222,12 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
char * guardaddr; char * guardaddr;
size_t stacksize, guardsize; size_t stacksize, guardsize;
if (attr != NULL && attr->stackaddr_set) if (attr != NULL && attr->__stackaddr_set)
{ {
/* The user provided a stack. */ /* The user provided a stack. */
new_thread = new_thread =
(pthread_descr) ((long)(attr->stackaddr) & -sizeof(void *)) - 1; (pthread_descr) ((long)(attr->__stackaddr) & -sizeof(void *)) - 1;
new_thread_bottom = (char *) attr->stackaddr - attr->stacksize; new_thread_bottom = (char *) attr->__stackaddr - attr->__stacksize;
guardaddr = NULL; guardaddr = NULL;
guardsize = 0; guardsize = 0;
} }
@ -249,9 +249,9 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
the RLIMIT_STACK soft limit prevents stacks from the RLIMIT_STACK soft limit prevents stacks from
running into one another. */ running into one another. */
if (attr == NULL || if (attr == NULL ||
attr->guardsize == 0 || attr->__guardsize == 0 ||
(attr->guardsize == pagesize && (attr->__guardsize == pagesize &&
attr->stacksize == STACK_SIZE - pagesize)) attr->__stacksize == STACK_SIZE - pagesize))
{ {
/* We don't need a guard page. */ /* We don't need a guard page. */
guardaddr = NULL; guardaddr = NULL;
@ -260,11 +260,11 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
else else
{ {
/* Put a bad page at the bottom of the stack */ /* Put a bad page at the bottom of the stack */
stacksize = roundup(attr->stacksize, pagesize); stacksize = roundup(attr->__stacksize, pagesize);
if (stacksize >= STACK_SIZE - pagesize) if (stacksize >= STACK_SIZE - pagesize)
stacksize = STACK_SIZE - pagesize; stacksize = STACK_SIZE - pagesize;
guardaddr = (void *)new_thread - stacksize; guardaddr = (void *)new_thread - stacksize;
guardsize = attr->guardsize; guardsize = attr->__guardsize;
if (mmap ((caddr_t) guardaddr, guardsize, 0, MAP_FIXED, -1, 0) if (mmap ((caddr_t) guardaddr, guardsize, 0, MAP_FIXED, -1, 0)
== MAP_FAILED) == MAP_FAILED)
{ {
@ -298,7 +298,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
we can do this. Normally this should be done by examining the we can do this. Normally this should be done by examining the
return value of the __sched_setscheduler call in pthread_start_thread return value of the __sched_setscheduler call in pthread_start_thread
but this is hard to implement. FIXME */ but this is hard to implement. FIXME */
if (attr != NULL && attr->schedpolicy != SCHED_OTHER && geteuid () != 0) if (attr != NULL && attr->__schedpolicy != SCHED_OTHER && geteuid () != 0)
return EPERM; return EPERM;
/* Find a free segment for the thread, and allocate a stack if needed */ /* Find a free segment for the thread, and allocate a stack if needed */
for (sseg = 2; ; sseg++) for (sseg = 2; ; sseg++)
@ -324,7 +324,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
new_thread->p_signal_jmp = NULL; new_thread->p_signal_jmp = NULL;
new_thread->p_cancel_jmp = NULL; new_thread->p_cancel_jmp = NULL;
new_thread->p_terminated = 0; new_thread->p_terminated = 0;
new_thread->p_detached = attr == NULL ? 0 : attr->detachstate; new_thread->p_detached = attr == NULL ? 0 : attr->__detachstate;
new_thread->p_exited = 0; new_thread->p_exited = 0;
new_thread->p_retval = NULL; new_thread->p_retval = NULL;
new_thread->p_joining = NULL; new_thread->p_joining = NULL;
@ -340,7 +340,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
new_thread->p_sigwaiting = 0; new_thread->p_sigwaiting = 0;
new_thread->p_guardaddr = guardaddr; new_thread->p_guardaddr = guardaddr;
new_thread->p_guardsize = guardsize; new_thread->p_guardsize = guardsize;
new_thread->p_userstack = attr != NULL && attr->stackaddr_set; new_thread->p_userstack = attr != NULL && attr->__stackaddr_set;
memset (new_thread->p_specific, '\0', memset (new_thread->p_specific, '\0',
PTHREAD_KEY_1STLEVEL_SIZE * sizeof (new_thread->p_specific[0])); PTHREAD_KEY_1STLEVEL_SIZE * sizeof (new_thread->p_specific[0]));
new_thread->p_self = new_thread; new_thread->p_self = new_thread;
@ -352,10 +352,10 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
/* Determine scheduling parameters for the thread */ /* Determine scheduling parameters for the thread */
new_thread->p_start_args.schedpolicy = -1; new_thread->p_start_args.schedpolicy = -1;
if (attr != NULL) { if (attr != NULL) {
switch(attr->inheritsched) { switch(attr->__inheritsched) {
case PTHREAD_EXPLICIT_SCHED: case PTHREAD_EXPLICIT_SCHED:
new_thread->p_start_args.schedpolicy = attr->schedpolicy; new_thread->p_start_args.schedpolicy = attr->__schedpolicy;
memcpy (&new_thread->p_start_args.schedparam, &attr->schedparam, memcpy (&new_thread->p_start_args.schedparam, &attr->__schedparam,
sizeof (struct sched_param)); sizeof (struct sched_param));
break; break;
case PTHREAD_INHERIT_SCHED: case PTHREAD_INHERIT_SCHED:
@ -382,7 +382,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
/* Check if cloning succeeded */ /* Check if cloning succeeded */
if (pid == -1) { if (pid == -1) {
/* Free the stack if we allocated it */ /* Free the stack if we allocated it */
if (attr == NULL || !attr->stackaddr_set) if (attr == NULL || !attr->__stackaddr_set)
{ {
munmap((caddr_t)((char *)(new_thread+1) - INITIAL_STACK_SIZE), munmap((caddr_t)((char *)(new_thread+1) - INITIAL_STACK_SIZE),
INITIAL_STACK_SIZE); INITIAL_STACK_SIZE);

74
linuxthreads/mutex.c
View File

@ -26,18 +26,18 @@
int __pthread_mutex_init(pthread_mutex_t * mutex, int __pthread_mutex_init(pthread_mutex_t * mutex,
const pthread_mutexattr_t * mutex_attr) const pthread_mutexattr_t * mutex_attr)
{ {
__pthread_init_lock(&mutex->m_lock); __pthread_init_lock(&mutex->__m_lock);
mutex->m_kind = mutex->__m_kind =
mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->mutexkind; mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->__mutexkind;
mutex->m_count = 0; mutex->__m_count = 0;
mutex->m_owner = NULL; mutex->__m_owner = NULL;
return 0; return 0;
} }
weak_alias (__pthread_mutex_init, pthread_mutex_init) weak_alias (__pthread_mutex_init, pthread_mutex_init)
int __pthread_mutex_destroy(pthread_mutex_t * mutex) int __pthread_mutex_destroy(pthread_mutex_t * mutex)
{ {
if (mutex->m_lock.status != 0) return EBUSY; if (mutex->__m_lock.__status != 0) return EBUSY;
return 0; return 0;
} }
weak_alias (__pthread_mutex_destroy, pthread_mutex_destroy) weak_alias (__pthread_mutex_destroy, pthread_mutex_destroy)
@ -47,26 +47,26 @@ int __pthread_mutex_trylock(pthread_mutex_t * mutex)
pthread_descr self; pthread_descr self;
int retcode; int retcode;
switch(mutex->m_kind) { switch(mutex->__m_kind) {
case PTHREAD_MUTEX_FAST_NP: case PTHREAD_MUTEX_FAST_NP:
retcode = __pthread_trylock(&mutex->m_lock); retcode = __pthread_trylock(&mutex->__m_lock);
return retcode; return retcode;
case PTHREAD_MUTEX_RECURSIVE_NP: case PTHREAD_MUTEX_RECURSIVE_NP:
self = thread_self(); self = thread_self();
if (mutex->m_owner == self) { if (mutex->__m_owner == self) {
mutex->m_count++; mutex->__m_count++;
return 0; return 0;
} }
retcode = __pthread_trylock(&mutex->m_lock); retcode = __pthread_trylock(&mutex->__m_lock);
if (retcode == 0) { if (retcode == 0) {
mutex->m_owner = self; mutex->__m_owner = self;
mutex->m_count = 0; mutex->__m_count = 0;
} }
return retcode; return retcode;
case PTHREAD_MUTEX_ERRORCHECK_NP: case PTHREAD_MUTEX_ERRORCHECK_NP:
retcode = __pthread_trylock(&mutex->m_lock); retcode = __pthread_trylock(&mutex->__m_lock);
if (retcode == 0) { if (retcode == 0) {
mutex->m_owner = thread_self(); mutex->__m_owner = thread_self();
} }
return retcode; return retcode;
default: default:
@ -79,25 +79,25 @@ int __pthread_mutex_lock(pthread_mutex_t * mutex)
{ {
pthread_descr self; pthread_descr self;
switch(mutex->m_kind) { switch(mutex->__m_kind) {
case PTHREAD_MUTEX_FAST_NP: case PTHREAD_MUTEX_FAST_NP:
__pthread_lock(&mutex->m_lock); __pthread_lock(&mutex->__m_lock);
return 0; return 0;
case PTHREAD_MUTEX_RECURSIVE_NP: case PTHREAD_MUTEX_RECURSIVE_NP:
self = thread_self(); self = thread_self();
if (mutex->m_owner == self) { if (mutex->__m_owner == self) {
mutex->m_count++; mutex->__m_count++;
return 0; return 0;
} }
__pthread_lock(&mutex->m_lock); __pthread_lock(&mutex->__m_lock);
mutex->m_owner = self; mutex->__m_owner = self;
mutex->m_count = 0; mutex->__m_count = 0;
return 0; return 0;
case PTHREAD_MUTEX_ERRORCHECK_NP: case PTHREAD_MUTEX_ERRORCHECK_NP:
self = thread_self(); self = thread_self();
if (mutex->m_owner == self) return EDEADLK; if (mutex->__m_owner == self) return EDEADLK;
__pthread_lock(&mutex->m_lock); __pthread_lock(&mutex->__m_lock);
mutex->m_owner = self; mutex->__m_owner = self;
return 0; return 0;
default: default:
return EINVAL; return EINVAL;
@ -107,23 +107,23 @@ weak_alias (__pthread_mutex_lock, pthread_mutex_lock)
int __pthread_mutex_unlock(pthread_mutex_t * mutex) int __pthread_mutex_unlock(pthread_mutex_t * mutex)
{ {
switch (mutex->m_kind) { switch (mutex->__m_kind) {
case PTHREAD_MUTEX_FAST_NP: case PTHREAD_MUTEX_FAST_NP:
__pthread_unlock(&mutex->m_lock); __pthread_unlock(&mutex->__m_lock);
return 0; return 0;
case PTHREAD_MUTEX_RECURSIVE_NP: case PTHREAD_MUTEX_RECURSIVE_NP:
if (mutex->m_count > 0) { if (mutex->__m_count > 0) {
mutex->m_count--; mutex->__m_count--;
return 0; return 0;
} }
mutex->m_owner = NULL; mutex->__m_owner = NULL;
__pthread_unlock(&mutex->m_lock); __pthread_unlock(&mutex->__m_lock);
return 0; return 0;
case PTHREAD_MUTEX_ERRORCHECK_NP: case PTHREAD_MUTEX_ERRORCHECK_NP:
if (mutex->m_owner != thread_self() || mutex->m_lock.status == 0) if (mutex->__m_owner != thread_self() || mutex->__m_lock.__status == 0)
return EPERM; return EPERM;
mutex->m_owner = NULL; mutex->__m_owner = NULL;
__pthread_unlock(&mutex->m_lock); __pthread_unlock(&mutex->__m_lock);
return 0; return 0;
default: default:
return EINVAL; return EINVAL;
@ -133,7 +133,7 @@ weak_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
int __pthread_mutexattr_init(pthread_mutexattr_t *attr) int __pthread_mutexattr_init(pthread_mutexattr_t *attr)
{ {
attr->mutexkind = PTHREAD_MUTEX_FAST_NP; attr->__mutexkind = PTHREAD_MUTEX_FAST_NP;
return 0; return 0;
} }
weak_alias (__pthread_mutexattr_init, pthread_mutexattr_init) weak_alias (__pthread_mutexattr_init, pthread_mutexattr_init)
@ -150,7 +150,7 @@ int __pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind)
&& kind != PTHREAD_MUTEX_RECURSIVE_NP && kind != PTHREAD_MUTEX_RECURSIVE_NP
&& kind != PTHREAD_MUTEX_ERRORCHECK_NP) && kind != PTHREAD_MUTEX_ERRORCHECK_NP)
return EINVAL; return EINVAL;
attr->mutexkind = kind; attr->__mutexkind = kind;
return 0; return 0;
} }
weak_alias (__pthread_mutexattr_settype, pthread_mutexattr_settype) weak_alias (__pthread_mutexattr_settype, pthread_mutexattr_settype)
@ -159,7 +159,7 @@ weak_alias (__pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np)
int __pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind) int __pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind)
{ {
*kind = attr->mutexkind; *kind = attr->__mutexkind;
return 0; return 0;
} }
weak_alias (__pthread_mutexattr_gettype, pthread_mutexattr_gettype) weak_alias (__pthread_mutexattr_gettype, pthread_mutexattr_gettype)

11
linuxthreads/pthread.c
View File

@ -340,11 +340,12 @@ int __pthread_create_2_0(pthread_t *thread, const pthread_attr_t *attr,
{ {
size_t ps = __getpagesize (); size_t ps = __getpagesize ();
memcpy (&new_attr, attr, (size_t) &(((pthread_attr_t*)NULL)->guardsize)); memcpy (&new_attr, attr,
new_attr.guardsize = ps; (size_t) &(((pthread_attr_t*)NULL)->__guardsize));
new_attr.stackaddr_set = 0; new_attr.__guardsize = ps;
new_attr.stackaddr = NULL; new_attr.__stackaddr_set = 0;
new_attr.stacksize = STACK_SIZE - ps; new_attr.__stackaddr = NULL;
new_attr.__stacksize = STACK_SIZE - ps;
attr = &new_attr; attr = &new_attr;
} }
return __pthread_create_2_1 (thread, attr, start_routine, arg); return __pthread_create_2_1 (thread, attr, start_routine, arg);

4
linuxthreads/ptlongjmp.c
View File

@ -34,8 +34,8 @@ static void pthread_cleanup_upto(__jmp_buf target)
for (c = THREAD_GETMEM(self, p_cleanup); for (c = THREAD_GETMEM(self, p_cleanup);
c != NULL && _JMPBUF_UNWINDS(target, c); c != NULL && _JMPBUF_UNWINDS(target, c);
c = c->prev) c = c->__prev)
c->routine(c->arg); c->__routine(c->__arg);
THREAD_SETMEM(self, p_cleanup, c); THREAD_SETMEM(self, p_cleanup, c);
if (THREAD_GETMEM(self, p_in_sighandler) if (THREAD_GETMEM(self, p_in_sighandler)
&& _JMPBUF_UNWINDS(target, THREAD_GETMEM(self, p_in_sighandler))) && _JMPBUF_UNWINDS(target, THREAD_GETMEM(self, p_in_sighandler)))

120
linuxthreads/rwlock.c
View File

@ -30,21 +30,21 @@ int
pthread_rwlock_init (pthread_rwlock_t *rwlock, pthread_rwlock_init (pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr) const pthread_rwlockattr_t *attr)
{ {
__pthread_init_lock(&rwlock->rw_lock); __pthread_init_lock(&rwlock->__rw_lock);
rwlock->rw_readers = 0; rwlock->__rw_readers = 0;
rwlock->rw_writer = NULL; rwlock->__rw_writer = NULL;
rwlock->rw_read_waiting = NULL; rwlock->__rw_read_waiting = NULL;
rwlock->rw_write_waiting = NULL; rwlock->__rw_write_waiting = NULL;
if (attr == NULL) if (attr == NULL)
{ {
rwlock->rw_kind = PTHREAD_RWLOCK_DEFAULT_NP; rwlock->__rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
rwlock->rw_pshared = PTHREAD_PROCESS_PRIVATE; rwlock->__rw_pshared = PTHREAD_PROCESS_PRIVATE;
} }
else else
{ {
rwlock->rw_kind = attr->lockkind; rwlock->__rw_kind = attr->__lockkind;
rwlock->rw_pshared = attr->pshared; rwlock->__rw_pshared = attr->__pshared;
} }
return 0; return 0;
@ -57,10 +57,10 @@ pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
int readers; int readers;
_pthread_descr writer; _pthread_descr writer;
__pthread_lock (&rwlock->rw_lock); __pthread_lock (&rwlock->__rw_lock);
readers = rwlock->rw_readers; readers = rwlock->__rw_readers;
writer = rwlock->rw_writer; writer = rwlock->__rw_writer;
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
if (readers > 0 || writer != NULL) if (readers > 0 || writer != NULL)
return EBUSY; return EBUSY;
@ -76,22 +76,22 @@ pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
while (1) while (1)
{ {
__pthread_lock (&rwlock->rw_lock); __pthread_lock (&rwlock->__rw_lock);
if (rwlock->rw_writer == NULL if (rwlock->__rw_writer == NULL
|| (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP || (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->rw_readers != 0)) && rwlock->__rw_readers != 0))
/* We can add a reader lock. */ /* We can add a reader lock. */
break; break;
/* Suspend ourselves, then try again */ /* Suspend ourselves, then try again */
self = thread_self (); self = thread_self ();
enqueue (&rwlock->rw_read_waiting, self); enqueue (&rwlock->__rw_read_waiting, self);
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
suspend (self); /* This is not a cancellation point */ suspend (self); /* This is not a cancellation point */
} }
++rwlock->rw_readers; ++rwlock->__rw_readers;
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
return 0; return 0;
} }
@ -102,15 +102,15 @@ pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
{ {
int result = EBUSY; int result = EBUSY;
__pthread_lock (&rwlock->rw_lock); __pthread_lock (&rwlock->__rw_lock);
if (rwlock->rw_writer == NULL if (rwlock->__rw_writer == NULL
|| (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP || (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->rw_readers != 0)) && rwlock->__rw_readers != 0))
{ {
++rwlock->rw_readers; ++rwlock->__rw_readers;
result = 0; result = 0;
} }
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
return result; return result;
} }
@ -123,17 +123,17 @@ pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
while(1) while(1)
{ {
__pthread_lock (&rwlock->rw_lock); __pthread_lock (&rwlock->__rw_lock);
if (rwlock->rw_readers == 0 && rwlock->rw_writer == NULL) if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
{ {
rwlock->rw_writer = self; rwlock->__rw_writer = self;
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
return 0; return 0;
} }
/* Suspend ourselves, then try again */ /* Suspend ourselves, then try again */
enqueue (&rwlock->rw_write_waiting, self); enqueue (&rwlock->__rw_write_waiting, self);
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
suspend (self); /* This is not a cancellation point */ suspend (self); /* This is not a cancellation point */
} }
} }
@ -144,13 +144,13 @@ pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
{ {
int result = EBUSY; int result = EBUSY;
__pthread_lock (&rwlock->rw_lock); __pthread_lock (&rwlock->__rw_lock);
if (rwlock->rw_readers == 0 && rwlock->rw_writer == NULL) if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
{ {
rwlock->rw_writer = thread_self (); rwlock->__rw_writer = thread_self ();
result = 0; result = 0;
} }
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
return result; return result;
} }
@ -162,51 +162,51 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
pthread_descr torestart; pthread_descr torestart;
pthread_descr th; pthread_descr th;
__pthread_lock (&rwlock->rw_lock); __pthread_lock (&rwlock->__rw_lock);
if (rwlock->rw_writer != NULL) if (rwlock->__rw_writer != NULL)
{ {
/* Unlocking a write lock. */ /* Unlocking a write lock. */
if (rwlock->rw_writer != thread_self ()) if (rwlock->__rw_writer != thread_self ())
{ {
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
return EPERM; return EPERM;
} }
rwlock->rw_writer = NULL; rwlock->__rw_writer = NULL;
if (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
|| (th = dequeue (&rwlock->rw_write_waiting)) == NULL) || (th = dequeue (&rwlock->__rw_write_waiting)) == NULL)
{ {
/* Restart all waiting readers. */ /* Restart all waiting readers. */
torestart = rwlock->rw_read_waiting; torestart = rwlock->__rw_read_waiting;
rwlock->rw_read_waiting = NULL; rwlock->__rw_read_waiting = NULL;
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
while ((th = dequeue (&torestart)) != NULL) while ((th = dequeue (&torestart)) != NULL)
restart (th); restart (th);
} }
else else
{ {
/* Restart one waiting writer. */ /* Restart one waiting writer. */
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
restart (th); restart (th);
} }
} }
else else
{ {
/* Unlocking a read lock. */ /* Unlocking a read lock. */
if (rwlock->rw_readers == 0) if (rwlock->__rw_readers == 0)
{ {
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
return EPERM; return EPERM;
} }
--rwlock->rw_readers; --rwlock->__rw_readers;
if (rwlock->rw_readers == 0) if (rwlock->__rw_readers == 0)
/* Restart one waiting writer, if any. */ /* Restart one waiting writer, if any. */
th = dequeue (&rwlock->rw_write_waiting); th = dequeue (&rwlock->__rw_write_waiting);
else else
th = NULL; th = NULL;
__pthread_unlock (&rwlock->rw_lock); __pthread_unlock (&rwlock->__rw_lock);
if (th != NULL) if (th != NULL)
restart (th); restart (th);
} }
@ -219,8 +219,8 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
int int
pthread_rwlockattr_init (pthread_rwlockattr_t *attr) pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
{ {
attr->lockkind = 0; attr->__lockkind = 0;
attr->pshared = 0; attr->__pshared = 0;
return 0; return 0;
} }
@ -236,7 +236,7 @@ pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
int int
pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared) pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
{ {
*pshared = attr->pshared; *pshared = attr->__pshared;
return 0; return 0;
} }
@ -247,7 +247,7 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED) if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
return EINVAL; return EINVAL;
attr->pshared = pshared; attr->__pshared = pshared;
return 0; return 0;
} }
@ -256,7 +256,7 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
int int
pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *attr, int *pref) pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *attr, int *pref)
{ {
*pref = attr->lockkind; *pref = attr->__lockkind;
return 0; return 0;
} }
@ -269,7 +269,7 @@ pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *attr, int pref)
&& pref != PTHREAD_RWLOCK_DEFAULT_NP) && pref != PTHREAD_RWLOCK_DEFAULT_NP)
return EINVAL; return EINVAL;
attr->lockkind = pref; attr->__lockkind = pref;
return 0; return 0;
} }

23
linuxthreads/spinlock.c
View File

@ -42,7 +42,7 @@ void __pthread_lock(struct _pthread_fastlock * lock)
pthread_descr self = NULL; pthread_descr self = NULL;
do { do {
oldstatus = lock->status; oldstatus = lock->__status;
if (oldstatus == 0) { if (oldstatus == 0) {
newstatus = 1; newstatus = 1;
} else { } else {
@ -51,8 +51,8 @@ void __pthread_lock(struct _pthread_fastlock * lock)
} }
if (self != NULL) if (self != NULL)
THREAD_SETMEM(self, p_nextwaiting, (pthread_descr) oldstatus); THREAD_SETMEM(self, p_nextwaiting, (pthread_descr) oldstatus);
} while(! compare_and_swap(&lock->status, oldstatus, newstatus, } while(! compare_and_swap(&lock->__status, oldstatus, newstatus,
&lock->spinlock)); &lock->__spinlock));
if (oldstatus != 0) suspend(self); if (oldstatus != 0) suspend(self);
} }
@ -61,9 +61,9 @@ int __pthread_trylock(struct _pthread_fastlock * lock)
long oldstatus; long oldstatus;
do { do {
oldstatus = lock->status; oldstatus = lock->__status;
if (oldstatus != 0) return EBUSY; if (oldstatus != 0) return EBUSY;
} while(! compare_and_swap(&lock->status, 0, 1, &lock->spinlock)); } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));
return 0; return 0;
} }
@ -74,14 +74,15 @@ void __pthread_unlock(struct _pthread_fastlock * lock)
int maxprio; int maxprio;
again: again:
oldstatus = lock->status; oldstatus = lock->__status;
if (oldstatus == 1) { if (oldstatus == 1) {
/* No threads are waiting for this lock */ /* No threads are waiting for this lock */
if (! compare_and_swap(&lock->status, 1, 0, &lock->spinlock)) goto again; if (! compare_and_swap(&lock->__status, 1, 0, &lock->__spinlock))
goto again;
return; return;
} }
/* Find thread in waiting queue with maximal priority */ /* Find thread in waiting queue with maximal priority */
ptr = (pthread_descr *) &lock->status; ptr = (pthread_descr *) &lock->__status;
thr = (pthread_descr) oldstatus; thr = (pthread_descr) oldstatus;
maxprio = 0; maxprio = 0;
maxptr = ptr; maxptr = ptr;
@ -94,13 +95,13 @@ again:
thr = *ptr; thr = *ptr;
} }
/* Remove max prio thread from waiting list. */ /* Remove max prio thread from waiting list. */
if (maxptr == (pthread_descr *) &lock->status) { if (maxptr == (pthread_descr *) &lock->__status) {
/* If max prio thread is at head, remove it with compare-and-swap /* If max prio thread is at head, remove it with compare-and-swap
to guard against concurrent lock operation */ to guard against concurrent lock operation */
thr = (pthread_descr) oldstatus; thr = (pthread_descr) oldstatus;
if (! compare_and_swap(&lock->status, if (! compare_and_swap(&lock->__status,
oldstatus, (long)(thr->p_nextwaiting), oldstatus, (long)(thr->p_nextwaiting),
&lock->spinlock)) &lock->__spinlock))
goto again; goto again;
} else { } else {
/* No risk of concurrent access, remove max prio thread normally */ /* No risk of concurrent access, remove max prio thread normally */

4
linuxthreads/spinlock.h
View File

@ -20,8 +20,8 @@ extern void __pthread_unlock(struct _pthread_fastlock * lock);
static inline void __pthread_init_lock(struct _pthread_fastlock * lock) static inline void __pthread_init_lock(struct _pthread_fastlock * lock)
{ {
lock->status = 0; lock->__status = 0;
lock->spinlock = 0; lock->__spinlock = 0;
} }
#define LOCK_INITIALIZER {0, 0} #define LOCK_INITIALIZER {0, 0}

58
linuxthreads/sysdeps/pthread/bits/pthreadtypes.h
View File

@ -25,8 +25,8 @@
/* Fast locks (not abstract because mutexes and conditions aren't abstract). */ /* Fast locks (not abstract because mutexes and conditions aren't abstract). */
struct _pthread_fastlock struct _pthread_fastlock
{ {
long int status; /* "Free" or "taken" or head of waiting list */ long int __status; /* "Free" or "taken" or head of waiting list */
int spinlock; /* For compare-and-swap emulation */ int __spinlock; /* For compare-and-swap emulation */
}; };
/* Thread descriptors */ /* Thread descriptors */
@ -36,30 +36,30 @@ typedef struct _pthread_descr_struct *_pthread_descr;
/* Attributes for threads. */ /* Attributes for threads. */
typedef struct typedef struct
{ {
int detachstate; int __detachstate;
int schedpolicy; int __schedpolicy;
struct __sched_param schedparam; struct __sched_param __schedparam;
int inheritsched; int __inheritsched;
int scope; int __scope;
size_t guardsize; size_t __guardsize;
int stackaddr_set; int __stackaddr_set;
void *stackaddr; void *__stackaddr;
size_t stacksize; size_t __stacksize;
} pthread_attr_t; } pthread_attr_t;
/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */ /* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
typedef struct typedef struct
{ {
struct _pthread_fastlock c_lock; /* Protect against concurrent access */ struct _pthread_fastlock __c_lock; /* Protect against concurrent access */
_pthread_descr c_waiting; /* Threads waiting on this condition */ _pthread_descr __c_waiting; /* Threads waiting on this condition */
} pthread_cond_t; } pthread_cond_t;
/* Attribute for conditionally variables. */ /* Attribute for conditionally variables. */
typedef struct typedef struct
{ {
int dummy; int __dummy;
} pthread_condattr_t; } pthread_condattr_t;
/* Keys for thread-specific data */ /* Keys for thread-specific data */
@ -71,18 +71,18 @@ typedef unsigned int pthread_key_t;
with earlier releases of LinuxThreads.) */ with earlier releases of LinuxThreads.) */
typedef struct typedef struct
{ {
int m_reserved; /* Reserved for future use */ int __m_reserved; /* Reserved for future use */
int m_count; /* Depth of recursive locking */ int __m_count; /* Depth of recursive locking */
_pthread_descr m_owner; /* Owner thread (if recursive or errcheck) */ _pthread_descr __m_owner; /* Owner thread (if recursive or errcheck) */
int m_kind; /* Mutex kind: fast, recursive or errcheck */ int __m_kind; /* Mutex kind: fast, recursive or errcheck */
struct _pthread_fastlock m_lock; /* Underlying fast lock */ struct _pthread_fastlock __m_lock; /* Underlying fast lock */
} pthread_mutex_t; } pthread_mutex_t;
/* Attribute for mutex. */ /* Attribute for mutex. */
typedef struct typedef struct
{ {
int mutexkind; int __mutexkind;
} pthread_mutexattr_t; } pthread_mutexattr_t;
@ -94,21 +94,21 @@ typedef int pthread_once_t;
/* Read-write locks. */ /* Read-write locks. */
typedef struct typedef struct
{ {
struct _pthread_fastlock rw_lock; /* Lock to guarantee mutual exclusion */ struct _pthread_fastlock __rw_lock; /* Lock to guarantee mutual exclusion */
int rw_readers; /* Number of readers */ int __rw_readers; /* Number of readers */
_pthread_descr rw_writer; /* Identity of writer, or NULL if none */ _pthread_descr __rw_writer; /* Identity of writer, or NULL if none */
_pthread_descr rw_read_waiting; /* Threads waiting for reading */ _pthread_descr __rw_read_waiting; /* Threads waiting for reading */
_pthread_descr rw_write_waiting; /* Threads waiting for writing */ _pthread_descr __rw_write_waiting; /* Threads waiting for writing */
int rw_kind; /* Reader/Writer preference selection */ int __rw_kind; /* Reader/Writer preference selection */
int rw_pshared; /* Shared between processes or not */ int __rw_pshared; /* Shared between processes or not */
} pthread_rwlock_t; } pthread_rwlock_t;
/* Attribute for read-write locks. */ /* Attribute for read-write locks. */
typedef struct typedef struct
{ {
int lockkind; int __lockkind;
int pshared; int __pshared;
} pthread_rwlockattr_t; } pthread_rwlockattr_t;
#endif #endif

8
linuxthreads/sysdeps/pthread/pthread.h
View File

@ -107,10 +107,10 @@ enum
struct _pthread_cleanup_buffer struct _pthread_cleanup_buffer
{ {
void (*routine) __PMT ((void *)); /* Function to call. */ void (*__routine) __PMT ((void *)); /* Function to call. */
void *arg; /* Its argument. */ void *__arg; /* Its argument. */
int canceltype; /* Saved cancellation type. */ int __canceltype; /* Saved cancellation type. */
struct _pthread_cleanup_buffer *prev; /* Chaining of cleanup functions. */ struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions. */
}; };
/* Cancellation */ /* Cancellation */

59
sysdeps/unix/sysv/linux/powerpc/pread.c
View File

@ -1 +1,58 @@
#include <sysdeps/unix/sysv/linux/i386/pread.c> /* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <unistd.h>
#include <sysdep.h>
#include <sys/syscall.h>
#ifdef __NR_pread
extern ssize_t __syscall_pread (int fd, void *buf, size_t count,
off64_t offset);
static ssize_t __emulate_pread (int fd, void *buf, size_t count,
off_t offset) internal_function;
ssize_t
__pread (fd, buf, count, offset)
int fd;
void *buf;
size_t count;
off_t offset;
{
ssize_t result;
/* First try the syscall. */
result = __syscall_pread (fd, buf, count, (off64_t) offset);
if (result == -1 && errno == ENOSYS)
/* No system call available. Use the emulation. */
result = __emulate_pread (fd, buf, count, offset);
return result;
}
weak_alias (__pread, pread)
#define __pread(fd, buf, count, offset) \
static internal_function __emulate_pread (fd, buf, count, offset)
#endif
#include <sysdeps/posix/pread.c>

59
sysdeps/unix/sysv/linux/powerpc/pread64.c
View File

@ -1 +1,58 @@
#include <sysdeps/unix/sysv/linux/i386/pread64.c> /* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <unistd.h>
#include <sysdep.h>
#include <sys/syscall.h>
#ifdef __NR_pread
extern ssize_t __syscall_pread (int fd, void *buf, size_t count,
off64_t offset);
static ssize_t __emulate_pread64 (int fd, void *buf, size_t count,
off64_t offset) internal_function;
ssize_t
__pread64 (fd, buf, count, offset)
int fd;
void *buf;
size_t count;
off64_t offset;
{
ssize_t result;
/* First try the syscall. */
result = __syscall_pread (fd, buf, count, offset);
if (result == -1 && errno == ENOSYS)
/* No system call available. Use the emulation. */
result = __emulate_pread64 (fd, buf, count, offset);
return result;
}
weak_alias (__pread64, pread64)
#define __pread64(fd, buf, count, offset) \
static internal_function __emulate_pread64 (fd, buf, count, offset)
#endif
#include <sysdeps/posix/pread64.c>

59
sysdeps/unix/sysv/linux/powerpc/pwrite.c
View File

@ -1 +1,58 @@
#include <sysdeps/unix/sysv/linux/i386/pwrite.c> /* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <unistd.h>
#include <sysdep.h>
#include <sys/syscall.h>
#ifdef __NR_pwrite
extern ssize_t __syscall_pwrite64 (int fd, const void *buf, size_t count,
off64_t offset);
static ssize_t __emulate_pwrite (int fd, const void *buf, size_t count,
off_t offset) internal_function;
ssize_t
__pwrite (fd, buf, count, offset)
int fd;
const void *buf;
size_t count;
off_t offset;
{
ssize_t result;
/* First try the syscall. */
result = __syscall_pwrite (fd, buf, count, (off64_t) offset);
if (result == -1 && errno == ENOSYS)
/* No system call available. Use the emulation. */
result = __emulate_pwrite (fd, buf, count, offset);
return result;
}
weak_alias (__pwrite, pwrite)
#define __pwrite(fd, buf, count, offset) \
static internal_function __emulate_pwrite (fd, buf, count, offset)
#endif
#include <sysdeps/posix/pwrite.c>

59
sysdeps/unix/sysv/linux/powerpc/pwrite64.c
View File

@ -1 +1,58 @@
#include <sysdeps/unix/sysv/linux/i386/pwrite64.c> /* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <unistd.h>
#include <sysdep.h>
#include <sys/syscall.h>
#ifdef __NR_pwrite
extern ssize_t __syscall_pwrite64 (int fd, const void *buf, size_t count,
off64_t offset);
static ssize_t __emulate_pwrite64 (int fd, const void *buf, size_t count,
off64_t offset) internal_function;
ssize_t
__pwrite64 (fd, buf, count, offset)
int fd;
const void *buf;
size_t count;
off64_t offset;
{
ssize_t result;
/* First try the syscall. */
result = __syscall_pwrite (fd, buf, count, offset);
if (result == -1 && errno == ENOSYS)
/* No system call available. Use the emulation. */
result = __emulate_pwrite64 (fd, buf, count, offset);
return result;
}
weak_alias (__pwrite64, pwrite64)
#define __pwrite64(fd, buf, count, offset) \
static internal_function __emulate_pwrite64 (fd, buf, count, offset)
#endif
#include <sysdeps/posix/pwrite64.c>