AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-22 04:50:07 +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
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>
* 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>
* 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 ();
attr->detachstate = PTHREAD_CREATE_JOINABLE;
attr->schedpolicy = SCHED_OTHER;
attr->schedparam.sched_priority = 0;
attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
attr->scope = PTHREAD_SCOPE_SYSTEM;
attr->guardsize = ps;
attr->stackaddr = NULL;
attr->stackaddr_set = 0;
attr->stacksize = STACK_SIZE - ps;
attr->__detachstate = PTHREAD_CREATE_JOINABLE;
attr->__schedpolicy = SCHED_OTHER;
attr->__schedparam.sched_priority = 0;
attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
attr->__scope = PTHREAD_SCOPE_SYSTEM;
attr->__guardsize = ps;
attr->__stackaddr = NULL;
attr->__stackaddr_set = 0;
attr->__stacksize = STACK_SIZE - ps;
return 0;
}
#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)
{
attr->detachstate = PTHREAD_CREATE_JOINABLE;
attr->schedpolicy = SCHED_OTHER;
attr->schedparam.sched_priority = 0;
attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
attr->scope = PTHREAD_SCOPE_SYSTEM;
attr->__detachstate = PTHREAD_CREATE_JOINABLE;
attr->__schedpolicy = SCHED_OTHER;
attr->__schedparam.sched_priority = 0;
attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
attr->__scope = PTHREAD_SCOPE_SYSTEM;
return 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 ||
detachstate > PTHREAD_CREATE_DETACHED)
return EINVAL;
attr->detachstate = detachstate;
attr->__detachstate = detachstate;
return 0;
}
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
{
*detachstate = attr->detachstate;
*detachstate = attr->__detachstate;
return 0;
}
int pthread_attr_setschedparam(pthread_attr_t *attr,
const struct sched_param *param)
{
int max_prio = __sched_get_priority_max(attr->schedpolicy);
int min_prio = __sched_get_priority_min(attr->schedpolicy);
int max_prio = __sched_get_priority_max(attr->__schedpolicy);
int min_prio = __sched_get_priority_min(attr->__schedpolicy);
if (param->sched_priority < min_prio || param->sched_priority > max_prio)
return EINVAL;
memcpy (&attr->schedparam, param, sizeof (struct sched_param));
memcpy (&attr->__schedparam, param, sizeof (struct sched_param));
return 0;
}
int pthread_attr_getschedparam(const pthread_attr_t *attr,
struct sched_param *param)
{
memcpy (param, &attr->schedparam, sizeof (struct sched_param));
memcpy (param, &attr->__schedparam, sizeof (struct sched_param));
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)
return EINVAL;
attr->schedpolicy = policy;
attr->__schedpolicy = policy;
return 0;
}
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
{
*policy = attr->schedpolicy;
*policy = attr->__schedpolicy;
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)
return EINVAL;
attr->inheritsched = inherit;
attr->__inheritsched = inherit;
return 0;
}
int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
{
*inherit = attr->inheritsched;
*inherit = attr->__inheritsched;
return 0;
}
@ -124,7 +124,7 @@ int pthread_attr_setscope(pthread_attr_t *attr, int scope)
{
switch (scope) {
case PTHREAD_SCOPE_SYSTEM:
attr->scope = scope;
attr->__scope = scope;
return 0;
case PTHREAD_SCOPE_PROCESS:
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)
{
*scope = attr->scope;
*scope = attr->__scope;
return 0;
}
@ -147,9 +147,9 @@ int __pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
guardsize = roundup (guardsize, ps);
/* 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;
}
@ -157,15 +157,15 @@ weak_alias (__pthread_attr_setguardsize, pthread_attr_setguardsize)
int __pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
{
*guardsize = attr->guardsize;
*guardsize = attr->__guardsize;
return 0;
}
weak_alias (__pthread_attr_getguardsize, pthread_attr_getguardsize)
int __pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
{
attr->stackaddr = stackaddr;
attr->stackaddr_set = 1;
attr->__stackaddr = stackaddr;
attr->__stackaddr_set = 1;
return 0;
}
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
no error value but what is if no stack address was set? We simply
return the value we have in the member. */
*stackaddr = attr->stackaddr;
*stackaddr = attr->__stackaddr;
return 0;
}
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)
return EINVAL;
attr->stacksize = stacksize;
attr->__stacksize = stacksize;
return 0;
}
weak_alias (__pthread_attr_setstacksize, pthread_attr_setstacksize)
int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
{
*stacksize = attr->stacksize;
*stacksize = attr->__stacksize;
return 0;
}
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)
{
pthread_descr self = thread_self();
buffer->routine = routine;
buffer->arg = arg;
buffer->prev = THREAD_GETMEM(self, p_cleanup);
buffer->__routine = routine;
buffer->__arg = arg;
buffer->__prev = THREAD_GETMEM(self, p_cleanup);
THREAD_SETMEM(self, p_cleanup, buffer);
}
@ -87,18 +87,18 @@ void _pthread_cleanup_pop(struct _pthread_cleanup_buffer * buffer,
int execute)
{
pthread_descr self = thread_self();
if (execute) buffer->routine(buffer->arg);
THREAD_SETMEM(self, p_cleanup, buffer->prev);
if (execute) buffer->__routine(buffer->__arg);
THREAD_SETMEM(self, p_cleanup, buffer->__prev);
}
void _pthread_cleanup_push_defer(struct _pthread_cleanup_buffer * buffer,
void (*routine)(void *), void * arg)
{
pthread_descr self = thread_self();
buffer->routine = routine;
buffer->arg = arg;
buffer->canceltype = THREAD_GETMEM(self, p_canceltype);
buffer->prev = THREAD_GETMEM(self, p_cleanup);
buffer->__routine = routine;
buffer->__arg = arg;
buffer->__canceltype = THREAD_GETMEM(self, p_canceltype);
buffer->__prev = THREAD_GETMEM(self, p_cleanup);
THREAD_SETMEM(self, p_canceltype, PTHREAD_CANCEL_DEFERRED);
THREAD_SETMEM(self, p_cleanup, buffer);
}
@ -107,9 +107,9 @@ void _pthread_cleanup_pop_restore(struct _pthread_cleanup_buffer * buffer,
int execute)
{
pthread_descr self = thread_self();
if (execute) buffer->routine(buffer->arg);
THREAD_SETMEM(self, p_cleanup, buffer->prev);
THREAD_SETMEM(self, p_canceltype, buffer->canceltype);
if (execute) buffer->__routine(buffer->__arg);
THREAD_SETMEM(self, p_cleanup, buffer->__prev);
THREAD_SETMEM(self, p_canceltype, buffer->__canceltype);
if (THREAD_GETMEM(self, p_canceled) &&
THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE &&
THREAD_GETMEM(self, p_canceltype) == PTHREAD_CANCEL_ASYNCHRONOUS)
@ -120,8 +120,8 @@ void __pthread_perform_cleanup(void)
{
pthread_descr self = thread_self();
struct _pthread_cleanup_buffer * c;
for (c = THREAD_GETMEM(self, p_cleanup); c != NULL; c = c->prev)
c->routine(c->arg);
for (c = THREAD_GETMEM(self, p_cleanup); c != NULL; c = c->__prev)
c->__routine(c->__arg);
}
#ifndef PIC

50
linuxthreads/condvar.c
View File

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

30
linuxthreads/manager.c
View File

@ -222,12 +222,12 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
char * guardaddr;
size_t stacksize, guardsize;
if (attr != NULL && attr->stackaddr_set)
if (attr != NULL && attr->__stackaddr_set)
{
/* The user provided a stack. */
new_thread =
(pthread_descr) ((long)(attr->stackaddr) & -sizeof(void *)) - 1;
new_thread_bottom = (char *) attr->stackaddr - attr->stacksize;
(pthread_descr) ((long)(attr->__stackaddr) & -sizeof(void *)) - 1;
new_thread_bottom = (char *) attr->__stackaddr - attr->__stacksize;
guardaddr = NULL;
guardsize = 0;
}
@ -249,9 +249,9 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
the RLIMIT_STACK soft limit prevents stacks from
running into one another. */
if (attr == NULL ||
attr->guardsize == 0 ||
(attr->guardsize == pagesize &&
attr->stacksize == STACK_SIZE - pagesize))
attr->__guardsize == 0 ||
(attr->__guardsize == pagesize &&
attr->__stacksize == STACK_SIZE - pagesize))
{
/* We don't need a guard page. */
guardaddr = NULL;
@ -260,11 +260,11 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
else
{
/* 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)
stacksize = STACK_SIZE - pagesize;
guardaddr = (void *)new_thread - stacksize;
guardsize = attr->guardsize;
guardsize = attr->__guardsize;
if (mmap ((caddr_t) guardaddr, guardsize, 0, MAP_FIXED, -1, 0)
== 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
return value of the __sched_setscheduler call in pthread_start_thread
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;
/* Find a free segment for the thread, and allocate a stack if needed */
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_cancel_jmp = NULL;
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_retval = 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_guardaddr = guardaddr;
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',
PTHREAD_KEY_1STLEVEL_SIZE * sizeof (new_thread->p_specific[0]));
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 */
new_thread->p_start_args.schedpolicy = -1;
if (attr != NULL) {
switch(attr->inheritsched) {
switch(attr->__inheritsched) {
case PTHREAD_EXPLICIT_SCHED:
new_thread->p_start_args.schedpolicy = attr->schedpolicy;
memcpy (&new_thread->p_start_args.schedparam, &attr->schedparam,
new_thread->p_start_args.schedpolicy = attr->__schedpolicy;
memcpy (&new_thread->p_start_args.schedparam, &attr->__schedparam,
sizeof (struct sched_param));
break;
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 */
if (pid == -1) {
/* 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),
INITIAL_STACK_SIZE);

74
linuxthreads/mutex.c
View File

@ -26,18 +26,18 @@
int __pthread_mutex_init(pthread_mutex_t * mutex,
const pthread_mutexattr_t * mutex_attr)
{
__pthread_init_lock(&mutex->m_lock);
mutex->m_kind =
mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->mutexkind;
mutex->m_count = 0;
mutex->m_owner = NULL;
__pthread_init_lock(&mutex->__m_lock);
mutex->__m_kind =
mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->__mutexkind;
mutex->__m_count = 0;
mutex->__m_owner = NULL;
return 0;
}
weak_alias (__pthread_mutex_init, pthread_mutex_init)
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;
}
weak_alias (__pthread_mutex_destroy, pthread_mutex_destroy)
@ -47,26 +47,26 @@ int __pthread_mutex_trylock(pthread_mutex_t * mutex)
pthread_descr self;
int retcode;
switch(mutex->m_kind) {
switch(mutex->__m_kind) {
case PTHREAD_MUTEX_FAST_NP:
retcode = __pthread_trylock(&mutex->m_lock);
retcode = __pthread_trylock(&mutex->__m_lock);
return retcode;
case PTHREAD_MUTEX_RECURSIVE_NP:
self = thread_self();
if (mutex->m_owner == self) {
mutex->m_count++;
if (mutex->__m_owner == self) {
mutex->__m_count++;
return 0;
}
retcode = __pthread_trylock(&mutex->m_lock);
retcode = __pthread_trylock(&mutex->__m_lock);
if (retcode == 0) {
mutex->m_owner = self;
mutex->m_count = 0;
mutex->__m_owner = self;
mutex->__m_count = 0;
}
return retcode;
case PTHREAD_MUTEX_ERRORCHECK_NP:
retcode = __pthread_trylock(&mutex->m_lock);
retcode = __pthread_trylock(&mutex->__m_lock);
if (retcode == 0) {
mutex->m_owner = thread_self();
mutex->__m_owner = thread_self();
}
return retcode;
default:
@ -79,25 +79,25 @@ int __pthread_mutex_lock(pthread_mutex_t * mutex)
{
pthread_descr self;
switch(mutex->m_kind) {
switch(mutex->__m_kind) {
case PTHREAD_MUTEX_FAST_NP:
__pthread_lock(&mutex->m_lock);
__pthread_lock(&mutex->__m_lock);
return 0;
case PTHREAD_MUTEX_RECURSIVE_NP:
self = thread_self();
if (mutex->m_owner == self) {
mutex->m_count++;
if (mutex->__m_owner == self) {
mutex->__m_count++;
return 0;
}
__pthread_lock(&mutex->m_lock);
mutex->m_owner = self;
mutex->m_count = 0;
__pthread_lock(&mutex->__m_lock);
mutex->__m_owner = self;
mutex->__m_count = 0;
return 0;
case PTHREAD_MUTEX_ERRORCHECK_NP:
self = thread_self();
if (mutex->m_owner == self) return EDEADLK;
__pthread_lock(&mutex->m_lock);
mutex->m_owner = self;
if (mutex->__m_owner == self) return EDEADLK;
__pthread_lock(&mutex->__m_lock);
mutex->__m_owner = self;
return 0;
default:
return EINVAL;
@ -107,23 +107,23 @@ weak_alias (__pthread_mutex_lock, pthread_mutex_lock)
int __pthread_mutex_unlock(pthread_mutex_t * mutex)
{
switch (mutex->m_kind) {
switch (mutex->__m_kind) {
case PTHREAD_MUTEX_FAST_NP:
__pthread_unlock(&mutex->m_lock);
__pthread_unlock(&mutex->__m_lock);
return 0;
case PTHREAD_MUTEX_RECURSIVE_NP:
if (mutex->m_count > 0) {
mutex->m_count--;
if (mutex->__m_count > 0) {
mutex->__m_count--;
return 0;
}
mutex->m_owner = NULL;
__pthread_unlock(&mutex->m_lock);
mutex->__m_owner = NULL;
__pthread_unlock(&mutex->__m_lock);
return 0;
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;
mutex->m_owner = NULL;
__pthread_unlock(&mutex->m_lock);
mutex->__m_owner = NULL;
__pthread_unlock(&mutex->__m_lock);
return 0;
default:
return EINVAL;
@ -133,7 +133,7 @@ weak_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
int __pthread_mutexattr_init(pthread_mutexattr_t *attr)
{
attr->mutexkind = PTHREAD_MUTEX_FAST_NP;
attr->__mutexkind = PTHREAD_MUTEX_FAST_NP;
return 0;
}
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_ERRORCHECK_NP)
return EINVAL;
attr->mutexkind = kind;
attr->__mutexkind = kind;
return 0;
}
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)
{
*kind = attr->mutexkind;
*kind = attr->__mutexkind;
return 0;
}
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 ();
memcpy (&new_attr, attr, (size_t) &(((pthread_attr_t*)NULL)->guardsize));
new_attr.guardsize = ps;
new_attr.stackaddr_set = 0;
new_attr.stackaddr = NULL;
new_attr.stacksize = STACK_SIZE - ps;
memcpy (&new_attr, attr,
(size_t) &(((pthread_attr_t*)NULL)->__guardsize));
new_attr.__guardsize = ps;
new_attr.__stackaddr_set = 0;
new_attr.__stackaddr = NULL;
new_attr.__stacksize = STACK_SIZE - ps;
attr = &new_attr;
}
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);
c != NULL && _JMPBUF_UNWINDS(target, c);
c = c->prev)
c->routine(c->arg);
c = c->__prev)
c->__routine(c->__arg);
THREAD_SETMEM(self, p_cleanup, c);
if (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,
const pthread_rwlockattr_t *attr)
{
__pthread_init_lock(&rwlock->rw_lock);
rwlock->rw_readers = 0;
rwlock->rw_writer = NULL;
rwlock->rw_read_waiting = NULL;
rwlock->rw_write_waiting = NULL;
__pthread_init_lock(&rwlock->__rw_lock);
rwlock->__rw_readers = 0;
rwlock->__rw_writer = NULL;
rwlock->__rw_read_waiting = NULL;
rwlock->__rw_write_waiting = NULL;
if (attr == NULL)
{
rwlock->rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
rwlock->rw_pshared = PTHREAD_PROCESS_PRIVATE;
rwlock->__rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
rwlock->__rw_pshared = PTHREAD_PROCESS_PRIVATE;
}
else
{
rwlock->rw_kind = attr->lockkind;
rwlock->rw_pshared = attr->pshared;
rwlock->__rw_kind = attr->__lockkind;
rwlock->__rw_pshared = attr->__pshared;
}
return 0;
@ -57,10 +57,10 @@ pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
int readers;
_pthread_descr writer;
__pthread_lock (&rwlock->rw_lock);
readers = rwlock->rw_readers;
writer = rwlock->rw_writer;
__pthread_unlock (&rwlock->rw_lock);
__pthread_lock (&rwlock->__rw_lock);
readers = rwlock->__rw_readers;
writer = rwlock->__rw_writer;
__pthread_unlock (&rwlock->__rw_lock);
if (readers > 0 || writer != NULL)
return EBUSY;
@ -76,22 +76,22 @@ pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
while (1)
{
__pthread_lock (&rwlock->rw_lock);
if (rwlock->rw_writer == NULL
|| (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->rw_readers != 0))
__pthread_lock (&rwlock->__rw_lock);
if (rwlock->__rw_writer == NULL
|| (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->__rw_readers != 0))
/* We can add a reader lock. */
break;
/* Suspend ourselves, then try again */
self = thread_self ();
enqueue (&rwlock->rw_read_waiting, self);
__pthread_unlock (&rwlock->rw_lock);
enqueue (&rwlock->__rw_read_waiting, self);
__pthread_unlock (&rwlock->__rw_lock);
suspend (self); /* This is not a cancellation point */
}
++rwlock->rw_readers;
__pthread_unlock (&rwlock->rw_lock);
++rwlock->__rw_readers;
__pthread_unlock (&rwlock->__rw_lock);
return 0;
}
@ -102,15 +102,15 @@ pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
{
int result = EBUSY;
__pthread_lock (&rwlock->rw_lock);
if (rwlock->rw_writer == NULL
|| (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->rw_readers != 0))
__pthread_lock (&rwlock->__rw_lock);
if (rwlock->__rw_writer == NULL
|| (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->__rw_readers != 0))
{
++rwlock->rw_readers;
++rwlock->__rw_readers;
result = 0;
}
__pthread_unlock (&rwlock->rw_lock);
__pthread_unlock (&rwlock->__rw_lock);
return result;
}
@ -123,17 +123,17 @@ pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
while(1)
{
__pthread_lock (&rwlock->rw_lock);
if (rwlock->rw_readers == 0 && rwlock->rw_writer == NULL)
__pthread_lock (&rwlock->__rw_lock);
if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
{
rwlock->rw_writer = self;
__pthread_unlock (&rwlock->rw_lock);
rwlock->__rw_writer = self;
__pthread_unlock (&rwlock->__rw_lock);
return 0;
}
/* Suspend ourselves, then try again */
enqueue (&rwlock->rw_write_waiting, self);
__pthread_unlock (&rwlock->rw_lock);
enqueue (&rwlock->__rw_write_waiting, self);
__pthread_unlock (&rwlock->__rw_lock);
suspend (self); /* This is not a cancellation point */
}
}
@ -144,13 +144,13 @@ pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
{
int result = EBUSY;
__pthread_lock (&rwlock->rw_lock);
if (rwlock->rw_readers == 0 && rwlock->rw_writer == NULL)
__pthread_lock (&rwlock->__rw_lock);
if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
{
rwlock->rw_writer = thread_self ();
rwlock->__rw_writer = thread_self ();
result = 0;
}
__pthread_unlock (&rwlock->rw_lock);
__pthread_unlock (&rwlock->__rw_lock);
return result;
}
@ -162,51 +162,51 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
pthread_descr torestart;
pthread_descr th;
__pthread_lock (&rwlock->rw_lock);
if (rwlock->rw_writer != NULL)
__pthread_lock (&rwlock->__rw_lock);
if (rwlock->__rw_writer != NULL)
{
/* 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;
}
rwlock->rw_writer = NULL;
rwlock->__rw_writer = NULL;
if (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
|| (th = dequeue (&rwlock->rw_write_waiting)) == NULL)
if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
|| (th = dequeue (&rwlock->__rw_write_waiting)) == NULL)
{
/* Restart all waiting readers. */
torestart = rwlock->rw_read_waiting;
rwlock->rw_read_waiting = NULL;
__pthread_unlock (&rwlock->rw_lock);
torestart = rwlock->__rw_read_waiting;
rwlock->__rw_read_waiting = NULL;
__pthread_unlock (&rwlock->__rw_lock);
while ((th = dequeue (&torestart)) != NULL)
restart (th);
}
else
{
/* Restart one waiting writer. */
__pthread_unlock (&rwlock->rw_lock);
__pthread_unlock (&rwlock->__rw_lock);
restart (th);
}
}
else
{
/* 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;
}
--rwlock->rw_readers;
if (rwlock->rw_readers == 0)
--rwlock->__rw_readers;
if (rwlock->__rw_readers == 0)
/* Restart one waiting writer, if any. */
th = dequeue (&rwlock->rw_write_waiting);
th = dequeue (&rwlock->__rw_write_waiting);
else
th = NULL;
__pthread_unlock (&rwlock->rw_lock);
__pthread_unlock (&rwlock->__rw_lock);
if (th != NULL)
restart (th);
}
@ -219,8 +219,8 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
int
pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
{
attr->lockkind = 0;
attr->pshared = 0;
attr->__lockkind = 0;
attr->__pshared = 0;
return 0;
}
@ -236,7 +236,7 @@ pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
int
pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
{
*pshared = attr->pshared;
*pshared = attr->__pshared;
return 0;
}
@ -247,7 +247,7 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
return EINVAL;
attr->pshared = pshared;
attr->__pshared = pshared;
return 0;
}
@ -256,7 +256,7 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
int
pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *attr, int *pref)
{
*pref = attr->lockkind;
*pref = attr->__lockkind;
return 0;
}
@ -269,7 +269,7 @@ pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *attr, int pref)
&& pref != PTHREAD_RWLOCK_DEFAULT_NP)
return EINVAL;
attr->lockkind = pref;
attr->__lockkind = pref;
return 0;
}

23
linuxthreads/spinlock.c
View File

@ -42,7 +42,7 @@ void __pthread_lock(struct _pthread_fastlock * lock)
pthread_descr self = NULL;
do {
oldstatus = lock->status;
oldstatus = lock->__status;
if (oldstatus == 0) {
newstatus = 1;
} else {
@ -51,8 +51,8 @@ void __pthread_lock(struct _pthread_fastlock * lock)
}
if (self != NULL)
THREAD_SETMEM(self, p_nextwaiting, (pthread_descr) oldstatus);
} while(! compare_and_swap(&lock->status, oldstatus, newstatus,
&lock->spinlock));
} while(! compare_and_swap(&lock->__status, oldstatus, newstatus,
&lock->__spinlock));
if (oldstatus != 0) suspend(self);
}
@ -61,9 +61,9 @@ int __pthread_trylock(struct _pthread_fastlock * lock)
long oldstatus;
do {
oldstatus = lock->status;
oldstatus = lock->__status;
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;
}
@ -74,14 +74,15 @@ void __pthread_unlock(struct _pthread_fastlock * lock)
int maxprio;
again:
oldstatus = lock->status;
oldstatus = lock->__status;
if (oldstatus == 1) {
/* 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;
}
/* Find thread in waiting queue with maximal priority */
ptr = (pthread_descr *) &lock->status;
ptr = (pthread_descr *) &lock->__status;
thr = (pthread_descr) oldstatus;
maxprio = 0;
maxptr = ptr;
@ -94,13 +95,13 @@ again:
thr = *ptr;
}
/* 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
to guard against concurrent lock operation */
thr = (pthread_descr) oldstatus;
if (! compare_and_swap(&lock->status,
if (! compare_and_swap(&lock->__status,
oldstatus, (long)(thr->p_nextwaiting),
&lock->spinlock))
&lock->__spinlock))
goto again;
} else {
/* 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)
{
lock->status = 0;
lock->spinlock = 0;
lock->__status = 0;
lock->__spinlock = 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). */
struct _pthread_fastlock
{
long int status; /* "Free" or "taken" or head of waiting list */
int spinlock; /* For compare-and-swap emulation */
long int __status; /* "Free" or "taken" or head of waiting list */
int __spinlock; /* For compare-and-swap emulation */
};
/* Thread descriptors */
@ -36,30 +36,30 @@ typedef struct _pthread_descr_struct *_pthread_descr;
/* Attributes for threads. */
typedef struct
{
int detachstate;
int schedpolicy;
struct __sched_param schedparam;
int inheritsched;
int scope;
size_t guardsize;
int stackaddr_set;
void *stackaddr;
size_t stacksize;
int __detachstate;
int __schedpolicy;
struct __sched_param __schedparam;
int __inheritsched;
int __scope;
size_t __guardsize;
int __stackaddr_set;
void *__stackaddr;
size_t __stacksize;
} pthread_attr_t;
/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
typedef struct
{
struct _pthread_fastlock c_lock; /* Protect against concurrent access */
_pthread_descr c_waiting; /* Threads waiting on this condition */
struct _pthread_fastlock __c_lock; /* Protect against concurrent access */
_pthread_descr __c_waiting; /* Threads waiting on this condition */
} pthread_cond_t;
/* Attribute for conditionally variables. */
typedef struct
{
int dummy;
int __dummy;
} pthread_condattr_t;
/* Keys for thread-specific data */
@ -71,18 +71,18 @@ typedef unsigned int pthread_key_t;
with earlier releases of LinuxThreads.) */
typedef struct
{
int m_reserved; /* Reserved for future use */
int m_count; /* Depth of recursive locking */
_pthread_descr m_owner; /* Owner thread (if recursive or errcheck) */
int m_kind; /* Mutex kind: fast, recursive or errcheck */
struct _pthread_fastlock m_lock; /* Underlying fast lock */
int __m_reserved; /* Reserved for future use */
int __m_count; /* Depth of recursive locking */
_pthread_descr __m_owner; /* Owner thread (if recursive or errcheck) */
int __m_kind; /* Mutex kind: fast, recursive or errcheck */
struct _pthread_fastlock __m_lock; /* Underlying fast lock */
} pthread_mutex_t;
/* Attribute for mutex. */
typedef struct
{
int mutexkind;
int __mutexkind;
} pthread_mutexattr_t;
@ -94,21 +94,21 @@ typedef int pthread_once_t;
/* Read-write locks. */
typedef struct
{
struct _pthread_fastlock rw_lock; /* Lock to guarantee mutual exclusion */
int rw_readers; /* Number of readers */
_pthread_descr rw_writer; /* Identity of writer, or NULL if none */
_pthread_descr rw_read_waiting; /* Threads waiting for reading */
_pthread_descr rw_write_waiting; /* Threads waiting for writing */
int rw_kind; /* Reader/Writer preference selection */
int rw_pshared; /* Shared between processes or not */
struct _pthread_fastlock __rw_lock; /* Lock to guarantee mutual exclusion */
int __rw_readers; /* Number of readers */
_pthread_descr __rw_writer; /* Identity of writer, or NULL if none */
_pthread_descr __rw_read_waiting; /* Threads waiting for reading */
_pthread_descr __rw_write_waiting; /* Threads waiting for writing */
int __rw_kind; /* Reader/Writer preference selection */
int __rw_pshared; /* Shared between processes or not */
} pthread_rwlock_t;
/* Attribute for read-write locks. */
typedef struct
{
int lockkind;
int pshared;
int __lockkind;
int __pshared;
} pthread_rwlockattr_t;
#endif

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

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