108 lines
2.4 KiB
C
108 lines
2.4 KiB
C
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <syscall.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
DEFN_SYSCALL3(clone, 30, uintptr_t, uintptr_t, void *);
|
|
DEFN_SYSCALL0(gettid, 41);
|
|
|
|
int clone(uintptr_t,uintptr_t,void*) __attribute__((alias("syscall_clone")));
|
|
int gettid() __attribute__((alias("syscall_gettid")));
|
|
|
|
typedef struct {
|
|
uint32_t id;
|
|
char * stack;
|
|
void * ret_val;
|
|
} pthread_t;
|
|
typedef unsigned int pthread_attr_t;
|
|
|
|
#define PTHREAD_STACK_SIZE 10240
|
|
|
|
int pthread_create(pthread_t * thread, pthread_attr_t * attr, void *(*start_routine)(void *), void * arg) {
|
|
char * stack = malloc(PTHREAD_STACK_SIZE);
|
|
uintptr_t stack_top = (uintptr_t)stack + PTHREAD_STACK_SIZE;
|
|
thread->stack = stack;
|
|
thread->id = clone(stack_top, (uintptr_t)start_routine, arg);
|
|
return 0;
|
|
}
|
|
|
|
void pthread_exit(void * value) {
|
|
/* Perform nice cleanup */
|
|
#if 0
|
|
/* XXX: LOCK */
|
|
free(stack);
|
|
/* XXX: Return value!? */
|
|
#endif
|
|
__asm__ ("jmp 0xFFFFB00F"); /* Force thread exit */
|
|
}
|
|
|
|
#define NUM_THREADS 5
|
|
#define VALUE 0x1000000
|
|
#define CHECKPOINT 0x03FFFFF
|
|
|
|
volatile uint32_t result = 0;
|
|
int8_t use_locks = 0;
|
|
|
|
volatile uint8_t the_lock = 0;
|
|
|
|
void spin_lock(uint8_t volatile * lock) {
|
|
while(__sync_lock_test_and_set(lock, 0x01)) {
|
|
;; /* oh god */
|
|
}
|
|
}
|
|
|
|
void spin_unlock(uint8_t volatile * lock) {
|
|
__sync_lock_release(lock);
|
|
}
|
|
|
|
void *print_pid(void * garbage) {
|
|
int i;
|
|
printf("I am a thread and my pid is %d but my tid is %d and my stack is at %p\n", getpid(), gettid(), &i);
|
|
|
|
for (uint32_t i = 0; i < VALUE; ++i) {
|
|
if (use_locks) {
|
|
spin_lock(&the_lock);
|
|
}
|
|
if (!(result & CHECKPOINT)) {
|
|
printf("[%d] Checkpoint: %x\n", gettid(), result);
|
|
}
|
|
result++;
|
|
if (use_locks) {
|
|
spin_unlock(&the_lock);
|
|
}
|
|
}
|
|
|
|
pthread_exit(garbage);
|
|
}
|
|
|
|
int main(int argc, char * argv[]) {
|
|
if (argc > 1) {
|
|
if (!strcmp(argv[1], "-l")) {
|
|
use_locks = 1;
|
|
}
|
|
}
|
|
pthread_t thread[NUM_THREADS];
|
|
printf("I am the main process and my pid is %d and my tid is also %d\n", getpid(), gettid());
|
|
|
|
printf("Attempting to %s calculate %d!\n",
|
|
(use_locks) ? "(safely)" : "(unsafely)",
|
|
NUM_THREADS * VALUE);
|
|
|
|
for (int i = 0; i < NUM_THREADS; ++i) {
|
|
pthread_create(&thread[i], NULL, print_pid, NULL);
|
|
}
|
|
|
|
for (int i = 0; i < NUM_THREADS; ++i) {
|
|
syscall_wait(thread[i].id);
|
|
}
|
|
|
|
printf("Done. Result of %scomputation was %d %s!!\n",
|
|
(use_locks) ? "" : "(definitely unsafe) ",
|
|
result,
|
|
(result == NUM_THREADS * VALUE) ? "(yay, that's right!)" : "(boo, that's wrong!)");
|
|
|
|
return 0;
|
|
}
|