1 
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include <signal.h>
5 #include <sys/types.h>
6 #include <sys/wait.h>
7 #include <sys/prctl.h>
8 #include <ulocks.h>
9 #include <errno.h>
10 
11 #define HDR_SIZE        2680    /* sizeof(ushdr_t) */
12 #define MAXPROC         100     /* max # of threads that can be started */
13 
14 static usptr_t *shared_arena;
15 static ulock_t count_lock;      /* protection for some variables */
16 static ulock_t wait_lock;       /* lock used to wait for other threads */
17 static int waiting_for_threads; /* protected by count_lock */
18 static int nthreads;            /* protected by count_lock */
19 static int exit_status;
20 static int exiting;             /* we're already exiting (for maybe_exit) */
21 static pid_t my_pid;            /* PID of main thread */
22 static struct pidlist {
23     pid_t parent;
24     pid_t child;
25 } pidlist[MAXPROC];     /* PIDs of other threads; protected by count_lock */
26 static int maxpidindex;         /* # of PIDs in pidlist */
27 /*
28  * Initialization.
29  */
PyThread__init_thread(void)30 static void PyThread__init_thread(void)
31 {
32 #ifdef USE_DL
33     long addr, size;
34 #endif /* USE_DL */
35 
36 
37 #ifdef USE_DL
38     if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
39         perror("usconfig - CONF_INITSIZE (check)");
40     if (usconfig(CONF_INITSIZE, size) < 0)
41         perror("usconfig - CONF_INITSIZE (reset)");
42     addr = (long) dl_getrange(size + HDR_SIZE);
43     dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size));
44     errno = 0;
45     if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
46         perror("usconfig - CONF_ATTACHADDR (set)");
47 #endif /* USE_DL */
48     if (usconfig(CONF_INITUSERS, 16) < 0)
49         perror("usconfig - CONF_INITUSERS");
50     my_pid = getpid();          /* so that we know which is the main thread */
51     if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0)
52         perror("usconfig - CONF_ARENATYPE");
53     usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */
54 #ifdef Py_DEBUG
55     if (thread_debug & 4)
56         usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
57     else if (thread_debug & 2)
58         usconfig(CONF_LOCKTYPE, US_DEBUG);
59 #endif /* Py_DEBUG */
60     if ((shared_arena = usinit(tmpnam(0))) == 0)
61         perror("usinit");
62 #ifdef USE_DL
63     if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */
64         perror("usconfig - CONF_ATTACHADDR (reset)");
65 #endif /* USE_DL */
66     if ((count_lock = usnewlock(shared_arena)) == NULL)
67         perror("usnewlock (count_lock)");
68     (void) usinitlock(count_lock);
69     if ((wait_lock = usnewlock(shared_arena)) == NULL)
70         perror("usnewlock (wait_lock)");
71     dprintf(("arena start: %p, arena size: %ld\n",  shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));
72 }
73 
74 /*
75  * Thread support.
76  */
77 
clean_threads(void)78 static void clean_threads(void)
79 {
80     int i, j;
81     pid_t mypid, pid;
82 
83     /* clean up any exited threads */
84     mypid = getpid();
85     i = 0;
86     while (i < maxpidindex) {
87         if (pidlist[i].parent == mypid && (pid = pidlist[i].child) > 0) {
88             pid = waitpid(pid, 0, WNOHANG);
89             if (pid > 0) {
90                 /* a thread has exited */
91                 pidlist[i] = pidlist[--maxpidindex];
92                 /* remove references to children of dead proc */
93                 for (j = 0; j < maxpidindex; j++)
94                     if (pidlist[j].parent == pid)
95                         pidlist[j].child = -1;
96                 continue; /* don't increment i */
97             }
98         }
99         i++;
100     }
101     /* clean up the list */
102     i = 0;
103     while (i < maxpidindex) {
104         if (pidlist[i].child == -1) {
105             pidlist[i] = pidlist[--maxpidindex];
106             continue; /* don't increment i */
107         }
108         i++;
109     }
110 }
111 
PyThread_start_new_thread(void (* func)(void *),void * arg)112 long PyThread_start_new_thread(void (*func)(void *), void *arg)
113 {
114 #ifdef USE_DL
115     long addr, size;
116     static int local_initialized = 0;
117 #endif /* USE_DL */
118     int success = 0;            /* init not needed when SOLARIS_THREADS and */
119                 /* C_THREADS implemented properly */
120 
121     dprintf(("PyThread_start_new_thread called\n"));
122     if (!initialized)
123         PyThread_init_thread();
124     switch (ussetlock(count_lock)) {
125     case 0: return 0;
126     case -1: perror("ussetlock (count_lock)");
127     }
128     if (maxpidindex >= MAXPROC)
129         success = -1;
130     else {
131 #ifdef USE_DL
132         if (!local_initialized) {
133             if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
134                 perror("usconfig - CONF_INITSIZE (check)");
135             if (usconfig(CONF_INITSIZE, size) < 0)
136                 perror("usconfig - CONF_INITSIZE (reset)");
137             addr = (long) dl_getrange(size + HDR_SIZE);
138             dprintf(("trying to use addr %p-%p for sproc\n",
139                      addr, addr+size));
140             errno = 0;
141             if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 &&
142                 errno != 0)
143                 perror("usconfig - CONF_ATTACHADDR (set)");
144         }
145 #endif /* USE_DL */
146         clean_threads();
147         if ((success = sproc(func, PR_SALL, arg)) < 0)
148             perror("sproc");
149 #ifdef USE_DL
150         if (!local_initialized) {
151             if (usconfig(CONF_ATTACHADDR, addr) < 0)
152                 /* reset address */
153                 perror("usconfig - CONF_ATTACHADDR (reset)");
154             local_initialized = 1;
155         }
156 #endif /* USE_DL */
157         if (success >= 0) {
158             nthreads++;
159             pidlist[maxpidindex].parent = getpid();
160             pidlist[maxpidindex++].child = success;
161             dprintf(("pidlist[%d] = %d\n",
162                      maxpidindex-1, success));
163         }
164     }
165     if (usunsetlock(count_lock) < 0)
166         perror("usunsetlock (count_lock)");
167     return success;
168 }
169 
PyThread_get_thread_ident(void)170 long PyThread_get_thread_ident(void)
171 {
172     return getpid();
173 }
174 
PyThread_exit_thread(void)175 void PyThread_exit_thread(void)
176 {
177     dprintf(("PyThread_exit_thread called\n"));
178     if (!initialized)
179         exit(0);
180     if (ussetlock(count_lock) < 0)
181         perror("ussetlock (count_lock)");
182     nthreads--;
183     if (getpid() == my_pid) {
184         /* main thread; wait for other threads to exit */
185         exiting = 1;
186         waiting_for_threads = 1;
187         if (ussetlock(wait_lock) < 0)
188             perror("ussetlock (wait_lock)");
189         for (;;) {
190             if (nthreads < 0) {
191                 dprintf(("really exit (%d)\n", exit_status));
192                 exit(exit_status);
193             }
194             if (usunsetlock(count_lock) < 0)
195                 perror("usunsetlock (count_lock)");
196             dprintf(("waiting for other threads (%d)\n", nthreads));
197             if (ussetlock(wait_lock) < 0)
198                 perror("ussetlock (wait_lock)");
199             if (ussetlock(count_lock) < 0)
200                 perror("ussetlock (count_lock)");
201         }
202     }
203     /* not the main thread */
204     if (waiting_for_threads) {
205         dprintf(("main thread is waiting\n"));
206         if (usunsetlock(wait_lock) < 0)
207             perror("usunsetlock (wait_lock)");
208     }
209     if (usunsetlock(count_lock) < 0)
210         perror("usunsetlock (count_lock)");
211     _exit(0);
212 }
213 
214 /*
215  * Lock support.
216  */
PyThread_allocate_lock(void)217 PyThread_type_lock PyThread_allocate_lock(void)
218 {
219     ulock_t lock;
220 
221     dprintf(("PyThread_allocate_lock called\n"));
222     if (!initialized)
223         PyThread_init_thread();
224 
225     if ((lock = usnewlock(shared_arena)) == NULL)
226         perror("usnewlock");
227     (void) usinitlock(lock);
228     dprintf(("PyThread_allocate_lock() -> %p\n", lock));
229     return (PyThread_type_lock) lock;
230 }
231 
PyThread_free_lock(PyThread_type_lock lock)232 void PyThread_free_lock(PyThread_type_lock lock)
233 {
234     dprintf(("PyThread_free_lock(%p) called\n", lock));
235     usfreelock((ulock_t) lock, shared_arena);
236 }
237 
PyThread_acquire_lock(PyThread_type_lock lock,int waitflag)238 int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
239 {
240     int success;
241 
242     dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
243     errno = 0;                  /* clear it just in case */
244     if (waitflag)
245         success = ussetlock((ulock_t) lock);
246     else
247         success = uscsetlock((ulock_t) lock, 1); /* Try it once */
248     if (success < 0)
249         perror(waitflag ? "ussetlock" : "uscsetlock");
250     dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
251     return success;
252 }
253 
PyThread_release_lock(PyThread_type_lock lock)254 void PyThread_release_lock(PyThread_type_lock lock)
255 {
256     dprintf(("PyThread_release_lock(%p) called\n", lock));
257     if (usunsetlock((ulock_t) lock) < 0)
258         perror("usunsetlock");
259 }
260