Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- /*
- * sheepthreads.c - Minimal pthreads implementation (libpthreads doesn't
- * like nonstandard stacks)
- *
- * SheepShaver (C) 1997-2005 Christian Bauer and Marc Hellwig
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
- /*
- * NOTES:
- * - pthread_cancel() kills the thread immediately
- * - Semaphores are VERY restricted: the only supported use is to have one
- * thread sem_wait() on the semaphore while other threads sem_post() it
- * (i.e. to use the semaphore as a signal)
- */
- #include <sys/types.h>
- #include <sys/wait.h>
- #include <stdlib.h>
- #include <errno.h>
- #include <unistd.h>
- #include <signal.h>
- #include <pthread.h>
- /* Thread stack size */
- #define STACK_SIZE 65536
- /* From asm_linux.S */
- extern int atomic_add(int *var, int add);
- extern int atomic_and(int *var, int and);
- extern int atomic_or(int *var, int or);
- extern int test_and_set(int *var, int val);
- /* Linux kernel calls */
- extern int __clone(int (*fn)(void *), void *, int, void *);
- /* libc no longer provides struct _pthread_fastlock in pthread.h */
- struct fastlock {
- int status;
- int spinlock;
- };
- typedef struct {
- struct fastlock sem_lock;
- int sem_value;
- int sem_waiting;
- } sem_t;
- #define SEM_VALUE_MAX 64
- /* Wait for "clone" children only (Linux 2.4+ specific) */
- #ifndef __WCLONE
- #define __WCLONE 0
- #endif
- /*
- * Return pthread ID of self
- */
- pthread_t pthread_self(void)
- {
- return getpid();
- }
- /*
- * Test whether two pthread IDs are equal
- */
- int pthread_equal(pthread_t t1, pthread_t t2)
- {
- return t1 == t2;
- }
- /*
- * Send signal to thread
- */
- int pthread_kill(pthread_t thread, int sig)
- {
- if (kill(thread, sig) == -1)
- return errno;
- else
- return 0;
- }
- /*
- * Create pthread
- */
- struct new_thread {
- void *(*fn)(void *);
- void *arg;
- };
- static int start_thread(void *arg)
- {
- struct new_thread *nt = (struct new_thread *)arg;
- nt->fn(nt->arg);
- return 0;
- }
- int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
- {
- struct new_thread *nt;
- void *stack;
- int pid;
- nt = (struct new_thread *)malloc(sizeof(struct new_thread));
- nt->fn = start_routine;
- nt->arg = arg;
- stack = malloc(STACK_SIZE);
- pid = __clone(start_thread, (char *)stack + STACK_SIZE - 16, CLONE_VM | CLONE_FS | CLONE_FILES, nt);
- if (pid == -1) {
- free(stack);
- free(nt);
- return errno;
- } else {
- *thread = pid;
- return 0;
- }
- }
- /*
- * Join pthread
- */
- int pthread_join(pthread_t thread, void **ret)
- {
- do {
- if (waitpid(thread, NULL, __WCLONE) >= 0);
- break;
- } while (errno == EINTR);
- if (ret)
- *ret = NULL;
- return 0;
- }
- /*
- * Cancel thread
- */
- int pthread_cancel(pthread_t thread)
- {
- kill(thread, SIGINT);
- return 0;
- }
- /*
- * Test for cancellation
- */
- void pthread_testcancel(void)
- {
- }
- /*
- * Spinlocks
- */
- /* For multiprocessor systems, we want to ensure all memory accesses
- are completed before we reset a lock. On other systems, we still
- need to make sure that the compiler has flushed everything to memory. */
- #define MEMORY_BARRIER() __asm__ __volatile__ ("sync" : : : "memory")
- static void fastlock_init(struct fastlock *lock)
- {
- lock->status = 0;
- lock->spinlock = 0;
- }
- static int fastlock_try_acquire(struct fastlock *lock)
- {
- int res = EBUSY;
- if (test_and_set(&lock->spinlock, 1) == 0) {
- if (lock->status == 0) {
- lock->status = 1;
- MEMORY_BARRIER();
- res = 0;
- }
- lock->spinlock = 0;
- }
- return res;
- }
- static void fastlock_acquire(struct fastlock *lock)
- {
- MEMORY_BARRIER();
- while (test_and_set(&lock->spinlock, 1))
- usleep(0);
- }
- static void fastlock_release(struct fastlock *lock)
- {
- MEMORY_BARRIER();
- lock->spinlock = 0;
- __asm__ __volatile__ ("" : "=m" (lock->spinlock) : "m" (lock->spinlock));
- }
- /*
- * Initialize mutex
- */
- int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutex_attr)
- {
- fastlock_init((struct fastlock *)mutex);
- return 0;
- }
- /*
- * Destroy mutex
- */
- int pthread_mutex_destroy(pthread_mutex_t *mutex)
- {
- return (((struct fastlock *)mutex)->status != 0) ? EBUSY : 0;
- }
- /*
- * Lock mutex
- */
- int pthread_mutex_lock(pthread_mutex_t *mutex)
- {
- fastlock_acquire((struct fastlock *)mutex);
- return 0;
- }
- /*
- * Try to lock mutex
- */
- int pthread_mutex_trylock(pthread_mutex_t *mutex)
- {
- return fastlock_try_acquire((struct fastlock *)mutex);
- }
- /*
- * Unlock mutex
- */
- int pthread_mutex_unlock(pthread_mutex_t *mutex)
- {
- fastlock_release((struct fastlock *)mutex);
- return 0;
- }
- /*
- * Create mutex attribute
- */
- int pthread_mutexattr_init(pthread_mutexattr_t *attr)
- {
- return 0;
- }
- /*
- * Destroy mutex attribute
- */
- int pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
- {
- return 0;
- }
- /*
- * Init semaphore
- */
- int sem_init(sem_t *sem, int pshared, unsigned int value)
- {
- if (sem == NULL || value > SEM_VALUE_MAX) {
- errno = EINVAL;
- return -1;
- }
- if (pshared) {
- errno = ENOSYS;
- return -1;
- }
- fastlock_init(&sem->sem_lock);
- sem->sem_value = value;
- sem->sem_waiting = 0;
- return 0;
- }
- /*
- * Delete remaphore
- */
- int sem_destroy(sem_t *sem)
- {
- if (sem == NULL) {
- errno = EINVAL;
- return -1;
- }
- if (sem->sem_waiting) {
- errno = EBUSY;
- return -1;
- }
- sem->sem_value = 0;
- sem->sem_waiting = 0;
- return 0;
- }
- /*
- * Wait on semaphore
- */
- int sem_wait(sem_t *sem)
- {
- if (sem == NULL) {
- errno = EINVAL;
- return -1;
- }
- fastlock_acquire(&sem->sem_lock);
- if (sem->sem_value > 0) {
- sem->sem_value--;
- fastlock_release(&sem->sem_lock);
- return 0;
- }
- sem->sem_waiting++;
- while (sem->sem_value == 0) {
- fastlock_release(&sem->sem_lock);
- usleep(0);
- fastlock_acquire(&sem->sem_lock);
- }
- sem->sem_value--;
- fastlock_release(&sem->sem_lock);
- return 0;
- }
- /*
- * Post semaphore
- */
- int sem_post(sem_t *sem)
- {
- if (sem == NULL) {
- errno = EINVAL;
- return -1;
- }
- fastlock_acquire(&sem->sem_lock);
- if (sem->sem_waiting)
- sem->sem_waiting--;
- else {
- if (sem->sem_value >= SEM_VALUE_MAX) {
- errno = ERANGE;
- fastlock_release(&sem->sem_lock);
- return -1;
- }
- }
- sem->sem_value++;
- fastlock_release(&sem->sem_lock);
- return 0;
- }
- /*
- * Simple producer/consumer test program
- */
- #ifdef TEST
- #include <stdio.h>
- static sem_t p_sem, c_sem;
- static int data = 0;
- static void *producer_func(void *arg)
- {
- int i, n = (int)arg;
- for (i = 0; i < n; i++) {
- sem_wait(&p_sem);
- data++;
- sem_post(&c_sem);
- }
- return NULL;
- }
- static void *consumer_func(void *arg)
- {
- int i, n = (int)arg;
- for (i = 0; i < n; i++) {
- sem_wait(&c_sem);
- printf("data: %d\n", data);
- sem_post(&p_sem);
- }
- sleep(1); // for testing pthread_join()
- return NULL;
- }
- int main(void)
- {
- pthread_t producer_thread, consumer_thread;
- static const int N = 5;
- if (sem_init(&c_sem, 0, 0) < 0)
- return 1;
- if (sem_init(&p_sem, 0, 1) < 0)
- return 2;
- if (pthread_create(&producer_thread, NULL, producer_func, (void *)N) != 0)
- return 3;
- if (pthread_create(&consumer_thread, NULL, consumer_func, (void *)N) != 0)
- return 4;
- pthread_join(producer_thread, NULL);
- pthread_join(consumer_thread, NULL);
- sem_destroy(&p_sem);
- sem_destroy(&c_sem);
- if (data != N)
- return 5;
- return 0;
- }
- #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement