| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <signal.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <sys/prctl.h> |
| #include <ulocks.h> |
| #include <errno.h> |
| |
| #define HDR_SIZE 2680 /* sizeof(ushdr_t) */ |
| #define MAXPROC 100 /* max # of threads that can be started */ |
| |
| static usptr_t *shared_arena; |
| static ulock_t count_lock; /* protection for some variables */ |
| static ulock_t wait_lock; /* lock used to wait for other threads */ |
| static int waiting_for_threads; /* protected by count_lock */ |
| static int nthreads; /* protected by count_lock */ |
| static int exit_status; |
| static int exiting; /* we're already exiting (for maybe_exit) */ |
| static pid_t my_pid; /* PID of main thread */ |
| static struct pidlist { |
| pid_t parent; |
| pid_t child; |
| } pidlist[MAXPROC]; /* PIDs of other threads; protected by count_lock */ |
| static int maxpidindex; /* # of PIDs in pidlist */ |
| /* |
| * Initialization. |
| */ |
| static void PyThread__init_thread(void) |
| { |
| #ifdef USE_DL |
| long addr, size; |
| #endif /* USE_DL */ |
| |
| |
| #ifdef USE_DL |
| if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0) |
| perror("usconfig - CONF_INITSIZE (check)"); |
| if (usconfig(CONF_INITSIZE, size) < 0) |
| perror("usconfig - CONF_INITSIZE (reset)"); |
| addr = (long) dl_getrange(size + HDR_SIZE); |
| dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size)); |
| errno = 0; |
| if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0) |
| perror("usconfig - CONF_ATTACHADDR (set)"); |
| #endif /* USE_DL */ |
| if (usconfig(CONF_INITUSERS, 16) < 0) |
| perror("usconfig - CONF_INITUSERS"); |
| my_pid = getpid(); /* so that we know which is the main thread */ |
| if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0) |
| perror("usconfig - CONF_ARENATYPE"); |
| usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */ |
| #ifdef Py_DEBUG |
| if (thread_debug & 4) |
| usconfig(CONF_LOCKTYPE, US_DEBUGPLUS); |
| else if (thread_debug & 2) |
| usconfig(CONF_LOCKTYPE, US_DEBUG); |
| #endif /* Py_DEBUG */ |
| if ((shared_arena = usinit(tmpnam(0))) == 0) |
| perror("usinit"); |
| #ifdef USE_DL |
| if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */ |
| perror("usconfig - CONF_ATTACHADDR (reset)"); |
| #endif /* USE_DL */ |
| if ((count_lock = usnewlock(shared_arena)) == NULL) |
| perror("usnewlock (count_lock)"); |
| (void) usinitlock(count_lock); |
| if ((wait_lock = usnewlock(shared_arena)) == NULL) |
| perror("usnewlock (wait_lock)"); |
| dprintf(("arena start: %p, arena size: %ld\n", shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena))); |
| } |
| |
| /* |
| * Thread support. |
| */ |
| |
| static void clean_threads(void) |
| { |
| int i, j; |
| pid_t mypid, pid; |
| |
| /* clean up any exited threads */ |
| mypid = getpid(); |
| i = 0; |
| while (i < maxpidindex) { |
| if (pidlist[i].parent == mypid && (pid = pidlist[i].child) > 0) { |
| pid = waitpid(pid, 0, WNOHANG); |
| if (pid > 0) { |
| /* a thread has exited */ |
| pidlist[i] = pidlist[--maxpidindex]; |
| /* remove references to children of dead proc */ |
| for (j = 0; j < maxpidindex; j++) |
| if (pidlist[j].parent == pid) |
| pidlist[j].child = -1; |
| continue; /* don't increment i */ |
| } |
| } |
| i++; |
| } |
| /* clean up the list */ |
| i = 0; |
| while (i < maxpidindex) { |
| if (pidlist[i].child == -1) { |
| pidlist[i] = pidlist[--maxpidindex]; |
| continue; /* don't increment i */ |
| } |
| i++; |
| } |
| } |
| |
| long PyThread_start_new_thread(void (*func)(void *), void *arg) |
| { |
| #ifdef USE_DL |
| long addr, size; |
| static int local_initialized = 0; |
| #endif /* USE_DL */ |
| int success = 0; /* init not needed when SOLARIS_THREADS and */ |
| /* C_THREADS implemented properly */ |
| |
| dprintf(("PyThread_start_new_thread called\n")); |
| if (!initialized) |
| PyThread_init_thread(); |
| switch (ussetlock(count_lock)) { |
| case 0: return 0; |
| case -1: perror("ussetlock (count_lock)"); |
| } |
| if (maxpidindex >= MAXPROC) |
| success = -1; |
| else { |
| #ifdef USE_DL |
| if (!local_initialized) { |
| if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0) |
| perror("usconfig - CONF_INITSIZE (check)"); |
| if (usconfig(CONF_INITSIZE, size) < 0) |
| perror("usconfig - CONF_INITSIZE (reset)"); |
| addr = (long) dl_getrange(size + HDR_SIZE); |
| dprintf(("trying to use addr %p-%p for sproc\n", |
| addr, addr+size)); |
| errno = 0; |
| if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && |
| errno != 0) |
| perror("usconfig - CONF_ATTACHADDR (set)"); |
| } |
| #endif /* USE_DL */ |
| clean_threads(); |
| if ((success = sproc(func, PR_SALL, arg)) < 0) |
| perror("sproc"); |
| #ifdef USE_DL |
| if (!local_initialized) { |
| if (usconfig(CONF_ATTACHADDR, addr) < 0) |
| /* reset address */ |
| perror("usconfig - CONF_ATTACHADDR (reset)"); |
| local_initialized = 1; |
| } |
| #endif /* USE_DL */ |
| if (success >= 0) { |
| nthreads++; |
| pidlist[maxpidindex].parent = getpid(); |
| pidlist[maxpidindex++].child = success; |
| dprintf(("pidlist[%d] = %d\n", |
| maxpidindex-1, success)); |
| } |
| } |
| if (usunsetlock(count_lock) < 0) |
| perror("usunsetlock (count_lock)"); |
| return success; |
| } |
| |
| long PyThread_get_thread_ident(void) |
| { |
| return getpid(); |
| } |
| |
| void PyThread_exit_thread(void) |
| { |
| dprintf(("PyThread_exit_thread called\n")); |
| if (!initialized) |
| exit(0); |
| if (ussetlock(count_lock) < 0) |
| perror("ussetlock (count_lock)"); |
| nthreads--; |
| if (getpid() == my_pid) { |
| /* main thread; wait for other threads to exit */ |
| exiting = 1; |
| waiting_for_threads = 1; |
| if (ussetlock(wait_lock) < 0) |
| perror("ussetlock (wait_lock)"); |
| for (;;) { |
| if (nthreads < 0) { |
| dprintf(("really exit (%d)\n", exit_status)); |
| exit(exit_status); |
| } |
| if (usunsetlock(count_lock) < 0) |
| perror("usunsetlock (count_lock)"); |
| dprintf(("waiting for other threads (%d)\n", nthreads)); |
| if (ussetlock(wait_lock) < 0) |
| perror("ussetlock (wait_lock)"); |
| if (ussetlock(count_lock) < 0) |
| perror("ussetlock (count_lock)"); |
| } |
| } |
| /* not the main thread */ |
| if (waiting_for_threads) { |
| dprintf(("main thread is waiting\n")); |
| if (usunsetlock(wait_lock) < 0) |
| perror("usunsetlock (wait_lock)"); |
| } |
| if (usunsetlock(count_lock) < 0) |
| perror("usunsetlock (count_lock)"); |
| _exit(0); |
| } |
| |
| /* |
| * Lock support. |
| */ |
| PyThread_type_lock PyThread_allocate_lock(void) |
| { |
| ulock_t lock; |
| |
| dprintf(("PyThread_allocate_lock called\n")); |
| if (!initialized) |
| PyThread_init_thread(); |
| |
| if ((lock = usnewlock(shared_arena)) == NULL) |
| perror("usnewlock"); |
| (void) usinitlock(lock); |
| dprintf(("PyThread_allocate_lock() -> %p\n", lock)); |
| return (PyThread_type_lock) lock; |
| } |
| |
| void PyThread_free_lock(PyThread_type_lock lock) |
| { |
| dprintf(("PyThread_free_lock(%p) called\n", lock)); |
| usfreelock((ulock_t) lock, shared_arena); |
| } |
| |
| int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag) |
| { |
| int success; |
| |
| dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag)); |
| errno = 0; /* clear it just in case */ |
| if (waitflag) |
| success = ussetlock((ulock_t) lock); |
| else |
| success = uscsetlock((ulock_t) lock, 1); /* Try it once */ |
| if (success < 0) |
| perror(waitflag ? "ussetlock" : "uscsetlock"); |
| dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success)); |
| return success; |
| } |
| |
| void PyThread_release_lock(PyThread_type_lock lock) |
| { |
| dprintf(("PyThread_release_lock(%p) called\n", lock)); |
| if (usunsetlock((ulock_t) lock) < 0) |
| perror("usunsetlock"); |
| } |
