+1998-10-29 Ulrich Drepper <drepper@cygnus.com>
+
+ * sysdeps/unix/sysv/linux/ttyname_r.c (ttyname_r): Try reading
+ /prof/self/fd/FD first.
+ * sysdeps/unix/sysv/linux/ttyname.c (ttyname): Likewise.
+
+ * stdio-common/_itoa.h (_fitoa_word): New inline function. Write
+ formatted number starting at given position and return pointer to
+ following byte.
+ (_fitoa): Likewise, for long long.
+
1998-10-29 Roland McGrath <roland@baalperazim.frob.com>
* sysdeps/unix/sysv/linux/bits/sem.h,
pthread_handle handle = thread_handle(thread);
int pid;
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, NULL);
if (invalid_handle(handle, thread)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
{
volatile pthread_descr self = thread_self();
- __pthread_lock(&cond->__c_lock);
+ __pthread_lock(&cond->__c_lock, self);
enqueue(&cond->__c_waiting, self);
__pthread_unlock(&cond->__c_lock);
pthread_mutex_unlock(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);
+ __pthread_lock(&cond->__c_lock, self);
remove_from_queue(&cond->__c_waiting, self);
__pthread_unlock(&cond->__c_lock);
pthread_exit(PTHREAD_CANCELED);
sigjmp_buf jmpbuf;
/* Wait on the condition */
- __pthread_lock(&cond->__c_lock);
+ __pthread_lock(&cond->__c_lock, self);
enqueue(&cond->__c_waiting, self);
__pthread_unlock(&cond->__c_lock);
pthread_mutex_unlock(mutex);
/* This is a cancellation point */
if (THREAD_GETMEM(self, p_canceled)
&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
- __pthread_lock(&cond->__c_lock);
+ __pthread_lock(&cond->__c_lock, self);
remove_from_queue(&cond->__c_waiting, self);
__pthread_unlock(&cond->__c_lock);
pthread_mutex_lock(mutex);
}
/* If not signaled: also remove ourselves and return an error code */
if (THREAD_GETMEM(self, p_signal) == 0) {
- __pthread_lock(&cond->__c_lock);
+ __pthread_lock(&cond->__c_lock, self);
remove_from_queue(&cond->__c_waiting, self);
__pthread_unlock(&cond->__c_lock);
pthread_mutex_lock(mutex);
{
pthread_descr th;
- __pthread_lock(&cond->__c_lock);
+ __pthread_lock(&cond->__c_lock, NULL);
th = dequeue(&cond->__c_waiting);
__pthread_unlock(&cond->__c_lock);
if (th != NULL) restart(th);
{
pthread_descr tosignal, th;
- __pthread_lock(&cond->__c_lock);
+ __pthread_lock(&cond->__c_lock, NULL);
/* Copy the current state of the waiting queue and empty it */
tosignal = cond->__c_waiting;
cond->__c_waiting = NULL;
__pthread_perform_cleanup();
__pthread_destroy_specifics();
/* Store return value */
- __pthread_lock(THREAD_GETMEM(self, p_lock));
+ __pthread_lock(THREAD_GETMEM(self, p_lock), self);
THREAD_SETMEM(self, p_retval, retval);
/* Say that we've terminated */
THREAD_SETMEM(self, p_terminated, 1);
pthread_handle handle = thread_handle(thread_id);
pthread_descr th;
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, self);
if (invalid_handle(handle, thread_id)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
th->p_joining = NULL;
pthread_exit(PTHREAD_CANCELED);
}
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, self);
}
/* Get return value */
if (thread_return != NULL) *thread_return = th->p_retval;
pthread_handle handle = thread_handle(thread_id);
pthread_descr th;
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, NULL);
if (invalid_handle(handle, thread_id)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
ASSERT(th->p_exited);
/* Make the handle invalid */
handle = thread_handle(th->p_tid);
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, NULL);
handle->h_descr = NULL;
handle->h_bottom = (char *)(-1L);
__pthread_unlock(&handle->h_lock);
th->p_nextlive->p_prevlive = th->p_prevlive;
th->p_prevlive->p_nextlive = th->p_nextlive;
/* Mark thread as exited, and if detached, free its resources */
- __pthread_lock(th->p_lock);
+ __pthread_lock(th->p_lock, NULL);
th->p_exited = 1;
detached = th->p_detached;
__pthread_unlock(th->p_lock);
pthread_handle handle = thread_handle(th_id);
pthread_descr th;
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, NULL);
if (invalid_handle(handle, th_id)) {
/* pthread_reap_children has deallocated the thread already,
nothing needs to be done */
switch(mutex->__m_kind) {
case PTHREAD_MUTEX_FAST_NP:
- __pthread_lock(&mutex->__m_lock);
+ __pthread_lock(&mutex->__m_lock, NULL);
return 0;
case PTHREAD_MUTEX_RECURSIVE_NP:
self = thread_self();
mutex->__m_count++;
return 0;
}
- __pthread_lock(&mutex->__m_lock);
+ __pthread_lock(&mutex->__m_lock, self);
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);
+ __pthread_lock(&mutex->__m_lock, self);
mutex->__m_owner = self;
return 0;
default:
pthread_handle handle = thread_handle(thread);
pthread_descr th;
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, NULL);
if (invalid_handle(handle, thread)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
pthread_handle handle = thread_handle(thread);
int pid, pol;
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, NULL);
if (invalid_handle(handle, thread)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
int readers;
_pthread_descr writer;
- __pthread_lock (&rwlock->__rw_lock);
+ __pthread_lock (&rwlock->__rw_lock, NULL);
readers = rwlock->__rw_readers;
writer = rwlock->__rw_writer;
__pthread_unlock (&rwlock->__rw_lock);
int
pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
{
- pthread_descr self;
+ pthread_descr self = NULL;
while (1)
{
- __pthread_lock (&rwlock->__rw_lock);
+ __pthread_lock (&rwlock->__rw_lock, self);
if (rwlock->__rw_writer == NULL
|| (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->__rw_readers != 0))
break;
/* Suspend ourselves, then try again */
- self = thread_self ();
+ if (self == NULL)
+ self = thread_self ();
enqueue (&rwlock->__rw_read_waiting, self);
__pthread_unlock (&rwlock->__rw_lock);
suspend (self); /* This is not a cancellation point */
{
int result = EBUSY;
- __pthread_lock (&rwlock->__rw_lock);
+ __pthread_lock (&rwlock->__rw_lock, NULL);
if (rwlock->__rw_writer == NULL
|| (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
&& rwlock->__rw_readers != 0))
while(1)
{
- __pthread_lock (&rwlock->__rw_lock);
+ __pthread_lock (&rwlock->__rw_lock, self);
if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
{
rwlock->__rw_writer = self;
{
int result = EBUSY;
- __pthread_lock (&rwlock->__rw_lock);
+ __pthread_lock (&rwlock->__rw_lock, NULL);
if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
{
rwlock->__rw_writer = thread_self ();
pthread_descr torestart;
pthread_descr th;
- __pthread_lock (&rwlock->__rw_lock);
+ __pthread_lock (&rwlock->__rw_lock, NULL);
if (rwlock->__rw_writer != NULL)
{
/* Unlocking a write lock. */
int sem_wait(sem_t * sem)
{
- volatile pthread_descr self;
+ volatile pthread_descr self = thread_self();
- __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
+ __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock, self);
if (sem->sem_value > 0) {
sem->sem_value--;
__pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
return 0;
}
- self = thread_self();
enqueue(&sem->sem_waiting, self);
/* Wait for sem_post or cancellation */
__pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
if (THREAD_GETMEM(self, p_canceled)
&& THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
/* Remove ourselves from the waiting list if we're still on it */
- __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
+ __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock, self);
remove_from_queue(&sem->sem_waiting, self);
__pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
pthread_exit(PTHREAD_CANCELED);
{
int retval;
- __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
+ __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock, NULL);
if (sem->sem_value == 0) {
errno = EAGAIN;
retval = -1;
struct pthread_request request;
if (THREAD_GETMEM(self, p_in_sighandler) == NULL) {
- __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
+ __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock, self);
if (sem->sem_waiting == NULL) {
if (sem->sem_value >= SEM_VALUE_MAX) {
/* Overflow */
pthread_handle handle = thread_handle(thread);
int pid;
- __pthread_lock(&handle->h_lock);
+ __pthread_lock(&handle->h_lock, NULL);
if (invalid_handle(handle, thread)) {
__pthread_unlock(&handle->h_lock);
return ESRCH;
This is safe because there are no concurrent __pthread_unlock
operations -- only the thread that locked the mutex can unlock it. */
-void __pthread_lock(struct _pthread_fastlock * lock)
+void internal_function __pthread_lock(struct _pthread_fastlock * lock,
+ pthread_descr self)
{
long oldstatus, newstatus;
- pthread_descr self = NULL;
do {
oldstatus = lock->__status;
if (oldstatus == 0) {
newstatus = 1;
} else {
- self = thread_self();
+ if (self == NULL)
+ self = thread_self();
newstatus = (long) self;
}
if (self != NULL)
if (oldstatus != 0) suspend(self);
}
-int __pthread_trylock(struct _pthread_fastlock * lock)
-{
- long oldstatus;
-
- do {
- oldstatus = lock->__status;
- if (oldstatus != 0) return EBUSY;
- } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));
- return 0;
-}
-
-void __pthread_unlock(struct _pthread_fastlock * lock)
+void internal_function __pthread_unlock(struct _pthread_fastlock * lock)
{
long oldstatus;
pthread_descr thr, * ptr, * maxptr;
/* Internal function for converting integers to ASCII.
- Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
return bp;
}
+static inline char * __attribute__ ((unused))
+_fitoa_word (unsigned long value, char *buf, unsigned int base, int upper_case)
+{
+ char tmpbuf[sizeof (value) * 4]; /* Worst case length: base 2. */
+ char *cp = _itoa_word (value, tmpbuf + sizeof (value) * 4, base, upper_case);
+ while (cp < tmpbuf + sizeof (value) * 4)
+ *buf++ = *cp++;
+ return buf;
+}
+
+static inline char * __attribute__ ((unused))
+_fitoa (unsigned long long value, char *buf, unsigned int base, int upper_case)
+{
+ char tmpbuf[sizeof (value) * 4]; /* Worst case length: base 2. */
+ char *cp = _itoa (value, tmpbuf + sizeof (value) * 4, base, upper_case);
+ while (cp < tmpbuf + sizeof (value) * 4)
+ *buf++ = *cp++;
+ return buf;
+}
+
#endif /* itoa.h */
#include <string.h>
#include <stdlib.h>
+#include <stdio-common/_itoa.h>
+
char *__ttyname = NULL;
static char * getttyname __P ((const char *dev, int fd, dev_t mydev,
ttyname (fd)
int fd;
{
+ static char *buf;
+ static size_t buflen = 0;
+ char procname[30];
struct stat st, st1;
int dostat = 0;
char *name;
if (!__isatty (fd))
return NULL;
+ /* We try using the /proc filesystem. */
+ *_fitoa_word (fd, __stpcpy (procname, "/proc/self/fd/"), 10, 0) = '\0';
+
+ if (buflen == 0)
+ {
+ buflen = 4095;
+ buf = (char *) malloc (buflen + 1);
+ if (buf == NULL)
+ {
+ buflen = 0;
+ return NULL;
+ }
+ }
+
+ if (__readlink (procname, buf, buflen) != -1)
+ return buf;
+
if (fstat (fd, &st) < 0)
return NULL;
#include <string.h>
#include <stdlib.h>
+#include <stdio-common/_itoa.h>
+
static int getttyname_r __P ((int fd, char *buf, size_t buflen,
dev_t mydev, ino_t myino, int save,
int *dostat)) internal_function;
char *buf;
size_t buflen;
{
+ char procname[30];
struct stat st, st1;
int dostat = 0;
int save = errno;
return ENOTTY;
}
+ /* We try using the /proc filesystem. */
+ *_fitoa_word (fd, __stpcpy (procname, "/proc/self/fd/"), 10, 0) = '\0';
+
+ ret = __readlink (procname, buf, buflen - 1);
+ if (ret != -1)
+ return 0;
+ if (errno == ENAMETOOLONG)
+ {
+ __set_errno (ERANGE);
+ return ERANGE;
+ }
+
if (fstat (fd, &st) < 0)
return errno;
projects / thirdparty / glibc.git / commitdiff
