blob: 9eb5d12f503a03346ad36fa23499b202edf97ac5 [file] [log] [blame]
Guido van Rossum34679b71993-01-26 13:33:44 +00001
Guido van Rossum1d5735e1994-08-30 08:27:36 +00002/* Thread package.
3 This is intended to be usable independently from Python.
4 The implementation for system foobar is in a file thread_foobar.h
5 which is included by this file dependent on config settings.
6 Stuff shared by all thread_*.h files is collected here. */
7
Martin v. Löwiscdc44512002-01-12 11:05:12 +00008#include "Python.h"
Guido van Rossum1d5735e1994-08-30 08:27:36 +00009
Matthias Klosea2542be2004-08-16 11:35:51 +000010#ifndef _POSIX_THREADS
11/* This means pthreads are not implemented in libc headers, hence the macro
12 not present in unistd.h. But they still can be implemented as an external
13 library (e.g. gnu pth in pthread emulation) */
14# ifdef HAVE_PTHREAD_H
15# include <pthread.h> /* _POSIX_THREADS */
16# endif
17#endif
18
Guido van Rossum2571cc81999-04-07 16:07:23 +000019#ifndef DONT_HAVE_STDIO_H
Guido van Rossum1d5735e1994-08-30 08:27:36 +000020#include <stdio.h>
Guido van Rossum2571cc81999-04-07 16:07:23 +000021#endif
Guido van Rossum1d5735e1994-08-30 08:27:36 +000022
Guido van Rossum1d5735e1994-08-30 08:27:36 +000023#include <stdlib.h>
Guido van Rossum1d5735e1994-08-30 08:27:36 +000024
Guido van Rossum49b56061998-10-01 20:42:43 +000025#include "pythread.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +000026
Guido van Rossum1d5735e1994-08-30 08:27:36 +000027#ifndef _POSIX_THREADS
28
Guido van Rossum539c6622005-09-14 17:49:54 +000029/* Check if we're running on HP-UX and _SC_THREADS is defined. If so, then
Ezio Melotti13925002011-03-16 11:05:33 +020030 enough of the Posix threads package is implemented to support python
Guido van Rossum539c6622005-09-14 17:49:54 +000031 threads.
32
33 This is valid for HP-UX 11.23 running on an ia64 system. If needed, add
34 a check of __ia64 to verify that we're running on a ia64 system instead
35 of a pa-risc system.
36*/
37#ifdef __hpux
38#ifdef _SC_THREADS
39#define _POSIX_THREADS
40#endif
41#endif
42
Sjoerd Mullender66bca321993-12-03 16:54:45 +000043#endif /* _POSIX_THREADS */
Guido van Rossum1984f1e1992-08-04 12:41:02 +000044
Guido van Rossum1984f1e1992-08-04 12:41:02 +000045
Guido van Rossum408027e1996-12-30 16:17:54 +000046#ifdef Py_DEBUG
Guido van Rossum1d5735e1994-08-30 08:27:36 +000047static int thread_debug = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000048#define dprintf(args) (void)((thread_debug & 1) && printf args)
49#define d2printf(args) ((thread_debug & 8) && printf args)
Guido van Rossum1d5735e1994-08-30 08:27:36 +000050#else
51#define dprintf(args)
52#define d2printf(args)
53#endif
54
Guido van Rossum1984f1e1992-08-04 12:41:02 +000055static int initialized;
56
Thomas Wouters8ec68fd2000-07-24 14:39:50 +000057static void PyThread__init_thread(void); /* Forward */
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000058
Thomas Wouters73e5a5b2006-06-08 15:35:45 +000059void
60PyThread_init_thread(void)
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000061{
Guido van Rossum408027e1996-12-30 16:17:54 +000062#ifdef Py_DEBUG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000063 char *p = Py_GETENV("PYTHONTHREADDEBUG");
Sjoerd Mullender66bca321993-12-03 16:54:45 +000064
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000065 if (p) {
66 if (*p)
67 thread_debug = atoi(p);
68 else
69 thread_debug = 1;
70 }
Guido van Rossum408027e1996-12-30 16:17:54 +000071#endif /* Py_DEBUG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000072 if (initialized)
73 return;
74 initialized = 1;
75 dprintf(("PyThread_init_thread called\n"));
76 PyThread__init_thread();
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000077}
78
Thomas Wouters0e3f5912006-08-11 14:57:12 +000079/* Support for runtime thread stack size tuning.
80 A value of 0 means using the platform's default stack size
81 or the size specified by the THREAD_STACK_SIZE macro. */
82static size_t _pythread_stacksize = 0;
83
Sjoerd Mullender66bca321993-12-03 16:54:45 +000084#ifdef _POSIX_THREADS
Victor Stinner754851f2011-04-19 23:58:51 +020085#define PYTHREAD_NAME "pthread"
Guido van Rossum1d5735e1994-08-30 08:27:36 +000086#include "thread_pthread.h"
Sjoerd Mullendere8934121993-01-13 12:08:48 +000087#endif
Guido van Rossumf9f2e821992-08-17 08:59:08 +000088
Guido van Rossumc3f82b61995-01-17 16:29:31 +000089#ifdef NT_THREADS
Victor Stinner754851f2011-04-19 23:58:51 +020090#define PYTHREAD_NAME "nt"
Guido van Rossumc3f82b61995-01-17 16:29:31 +000091#include "thread_nt.h"
92#endif
93
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +000094
Guido van Rossumf9f2e821992-08-17 08:59:08 +000095/*
Guido van Rossum1d5735e1994-08-30 08:27:36 +000096#ifdef FOOBAR_THREADS
97#include "thread_foobar.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +000098#endif
Guido van Rossum1d5735e1994-08-30 08:27:36 +000099*/
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000100
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000101/* return the current thread stack size */
102size_t
103PyThread_get_stacksize(void)
104{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000105 return _pythread_stacksize;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000106}
107
108/* Only platforms defining a THREAD_SET_STACKSIZE() macro
109 in thread_<platform>.h support changing the stack size.
110 Return 0 if stack size is valid,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000111 -1 if stack size value is invalid,
112 -2 if setting stack size is not supported. */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000113int
114PyThread_set_stacksize(size_t size)
115{
116#if defined(THREAD_SET_STACKSIZE)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000117 return THREAD_SET_STACKSIZE(size);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000118#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000119 return -2;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000120#endif
121}
122
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000123#ifndef Py_HAVE_NATIVE_TLS
124/* If the platform has not supplied a platform specific
125 TLS implementation, provide our own.
126
127 This code stolen from "thread_sgi.h", where it was the only
128 implementation of an existing Python TLS API.
129*/
Tim Petersfda787f2004-10-09 22:33:09 +0000130/* ------------------------------------------------------------------------
131Per-thread data ("key") support.
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000132
Tim Petersfda787f2004-10-09 22:33:09 +0000133Use PyThread_create_key() to create a new key. This is typically shared
134across threads.
135
136Use PyThread_set_key_value(thekey, value) to associate void* value with
137thekey in the current thread. Each thread has a distinct mapping of thekey
138to a void* value. Caution: if the current thread already has a mapping
139for thekey, value is ignored.
140
141Use PyThread_get_key_value(thekey) to retrieve the void* value associated
142with thekey in the current thread. This returns NULL if no value is
143associated with thekey in the current thread.
144
145Use PyThread_delete_key_value(thekey) to forget the current thread's associated
146value for thekey. PyThread_delete_key(thekey) forgets the values associated
147with thekey across *all* threads.
148
149While some of these functions have error-return values, none set any
150Python exception.
151
152None of the functions does memory management on behalf of the void* values.
153You need to allocate and deallocate them yourself. If the void* values
154happen to be PyObject*, these functions don't do refcount operations on
155them either.
156
157The GIL does not need to be held when calling these functions; they supply
158their own locking. This isn't true of PyThread_create_key(), though (see
159next paragraph).
160
161There's a hidden assumption that PyThread_create_key() will be called before
162any of the other functions are called. There's also a hidden assumption
163that calls to PyThread_create_key() are serialized externally.
164------------------------------------------------------------------------ */
165
166/* A singly-linked list of struct key objects remembers all the key->value
167 * associations. File static keyhead heads the list. keymutex is used
168 * to enforce exclusion internally.
169 */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000170struct key {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000171 /* Next record in the list, or NULL if this is the last record. */
172 struct key *next;
Tim Petersfda787f2004-10-09 22:33:09 +0000173
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000174 /* The thread id, according to PyThread_get_thread_ident(). */
175 long id;
Tim Petersfda787f2004-10-09 22:33:09 +0000176
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000177 /* The key and its associated value. */
178 int key;
179 void *value;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000180};
181
182static struct key *keyhead = NULL;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000183static PyThread_type_lock keymutex = NULL;
Tim Petersfda787f2004-10-09 22:33:09 +0000184static int nkeys = 0; /* PyThread_create_key() hands out nkeys+1 next */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000185
Tim Petersfda787f2004-10-09 22:33:09 +0000186/* Internal helper.
187 * If the current thread has a mapping for key, the appropriate struct key*
188 * is returned. NB: value is ignored in this case!
189 * If there is no mapping for key in the current thread, then:
190 * If value is NULL, NULL is returned.
191 * Else a mapping of key to value is created for the current thread,
192 * and a pointer to a new struct key* is returned; except that if
193 * malloc() can't find room for a new struct key*, NULL is returned.
194 * So when value==NULL, this acts like a pure lookup routine, and when
195 * value!=NULL, this acts like dict.setdefault(), returning an existing
196 * mapping if one exists, else creating a new mapping.
Tim Peters263091e2004-10-10 01:58:44 +0000197 *
198 * Caution: this used to be too clever, trying to hold keymutex only
199 * around the "p->next = keyhead; keyhead = p" pair. That allowed
200 * another thread to mutate the list, via key deletion, concurrent with
201 * find_key() crawling over the list. Hilarity ensued. For example, when
202 * the for-loop here does "p = p->next", p could end up pointing at a
203 * record that PyThread_delete_key_value() was concurrently free()'ing.
204 * That could lead to anything, from failing to find a key that exists, to
205 * segfaults. Now we lock the whole routine.
Tim Petersfda787f2004-10-09 22:33:09 +0000206 */
Tim Peters19717fa2004-10-09 17:38:29 +0000207static struct key *
Victor Stinner590cebe2013-12-13 11:08:56 +0100208find_key(int set_value, int key, void *value)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000209{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000210 struct key *p, *prev_p;
211 long id = PyThread_get_thread_ident();
Tim Petersfda787f2004-10-09 22:33:09 +0000212
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000213 if (!keymutex)
214 return NULL;
215 PyThread_acquire_lock(keymutex, 1);
216 prev_p = NULL;
217 for (p = keyhead; p != NULL; p = p->next) {
Victor Stinner590cebe2013-12-13 11:08:56 +0100218 if (p->id == id && p->key == key) {
219 if (set_value)
220 p->value = value;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000221 goto Done;
Victor Stinner590cebe2013-12-13 11:08:56 +0100222 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000223 /* Sanity check. These states should never happen but if
224 * they do we must abort. Otherwise we'll end up spinning in
225 * in a tight loop with the lock held. A similar check is done
226 * in pystate.c tstate_delete_common(). */
227 if (p == prev_p)
228 Py_FatalError("tls find_key: small circular list(!)");
229 prev_p = p;
230 if (p->next == keyhead)
231 Py_FatalError("tls find_key: circular list(!)");
232 }
Victor Stinner590cebe2013-12-13 11:08:56 +0100233 if (!set_value && value == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000234 assert(p == NULL);
235 goto Done;
236 }
Victor Stinner1a7425f2013-07-07 16:25:15 +0200237 p = (struct key *)PyMem_RawMalloc(sizeof(struct key));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000238 if (p != NULL) {
239 p->id = id;
240 p->key = key;
241 p->value = value;
242 p->next = keyhead;
243 keyhead = p;
244 }
Tim Peters263091e2004-10-10 01:58:44 +0000245 Done:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000246 PyThread_release_lock(keymutex);
247 return p;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000248}
249
Tim Petersfda787f2004-10-09 22:33:09 +0000250/* Return a new key. This must be called before any other functions in
251 * this family, and callers must arrange to serialize calls to this
252 * function. No violations are detected.
253 */
Tim Peters19717fa2004-10-09 17:38:29 +0000254int
255PyThread_create_key(void)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000256{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000257 /* All parts of this function are wrong if it's called by multiple
258 * threads simultaneously.
259 */
260 if (keymutex == NULL)
261 keymutex = PyThread_allocate_lock();
262 return ++nkeys;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000263}
264
Tim Petersfda787f2004-10-09 22:33:09 +0000265/* Forget the associations for key across *all* threads. */
Tim Peters19717fa2004-10-09 17:38:29 +0000266void
267PyThread_delete_key(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000268{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000269 struct key *p, **q;
Tim Petersfda787f2004-10-09 22:33:09 +0000270
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000271 PyThread_acquire_lock(keymutex, 1);
272 q = &keyhead;
273 while ((p = *q) != NULL) {
274 if (p->key == key) {
275 *q = p->next;
Victor Stinner1a7425f2013-07-07 16:25:15 +0200276 PyMem_RawFree((void *)p);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000277 /* NB This does *not* free p->value! */
278 }
279 else
280 q = &p->next;
281 }
282 PyThread_release_lock(keymutex);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000283}
284
Tim Peters19717fa2004-10-09 17:38:29 +0000285int
286PyThread_set_key_value(int key, void *value)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000287{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000288 struct key *p;
Tim Petersfda787f2004-10-09 22:33:09 +0000289
Victor Stinner590cebe2013-12-13 11:08:56 +0100290 p = find_key(1, key, value);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000291 if (p == NULL)
292 return -1;
293 else
294 return 0;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000295}
296
Tim Petersfda787f2004-10-09 22:33:09 +0000297/* Retrieve the value associated with key in the current thread, or NULL
298 * if the current thread doesn't have an association for key.
299 */
Tim Peters19717fa2004-10-09 17:38:29 +0000300void *
301PyThread_get_key_value(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000302{
Victor Stinner590cebe2013-12-13 11:08:56 +0100303 struct key *p = find_key(0, key, NULL);
Tim Petersfda787f2004-10-09 22:33:09 +0000304
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000305 if (p == NULL)
306 return NULL;
307 else
308 return p->value;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000309}
310
Tim Petersfda787f2004-10-09 22:33:09 +0000311/* Forget the current thread's association for key, if any. */
Tim Peters19717fa2004-10-09 17:38:29 +0000312void
313PyThread_delete_key_value(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000314{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000315 long id = PyThread_get_thread_ident();
316 struct key *p, **q;
Tim Petersfda787f2004-10-09 22:33:09 +0000317
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000318 PyThread_acquire_lock(keymutex, 1);
319 q = &keyhead;
320 while ((p = *q) != NULL) {
321 if (p->key == key && p->id == id) {
322 *q = p->next;
Victor Stinner1a7425f2013-07-07 16:25:15 +0200323 PyMem_RawFree((void *)p);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000324 /* NB This does *not* free p->value! */
325 break;
326 }
327 else
328 q = &p->next;
329 }
330 PyThread_release_lock(keymutex);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000331}
332
Benjamin Petersone68df0f2008-06-13 00:26:50 +0000333/* Forget everything not associated with the current thread id.
334 * This function is called from PyOS_AfterFork(). It is necessary
335 * because other thread ids which were in use at the time of the fork
336 * may be reused for new threads created in the forked process.
337 */
338void
339PyThread_ReInitTLS(void)
340{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000341 long id = PyThread_get_thread_ident();
342 struct key *p, **q;
Benjamin Petersone68df0f2008-06-13 00:26:50 +0000343
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000344 if (!keymutex)
345 return;
Benjamin Petersone68df0f2008-06-13 00:26:50 +0000346
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000347 /* As with interpreter_lock in PyEval_ReInitThreads()
348 we just create a new lock without freeing the old one */
349 keymutex = PyThread_allocate_lock();
350
351 /* Delete all keys which do not match the current thread id */
352 q = &keyhead;
353 while ((p = *q) != NULL) {
354 if (p->id != id) {
355 *q = p->next;
Victor Stinner1a7425f2013-07-07 16:25:15 +0200356 PyMem_RawFree((void *)p);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000357 /* NB This does *not* free p->value! */
358 }
359 else
360 q = &p->next;
361 }
Benjamin Petersone68df0f2008-06-13 00:26:50 +0000362}
363
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000364#endif /* Py_HAVE_NATIVE_TLS */
Victor Stinner754851f2011-04-19 23:58:51 +0200365
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200366PyDoc_STRVAR(threadinfo__doc__,
367"sys.thread_info\n\
368\n\
369A struct sequence holding information about the thread implementation.");
370
371static PyStructSequence_Field threadinfo_fields[] = {
372 {"name", "name of the thread implementation"},
373 {"lock", "name of the lock implementation"},
374 {"version", "name and version of the thread library"},
375 {0}
376};
377
378static PyStructSequence_Desc threadinfo_desc = {
379 "sys.thread_info", /* name */
380 threadinfo__doc__, /* doc */
381 threadinfo_fields, /* fields */
382 3
383};
384
385static PyTypeObject ThreadInfoType;
386
Victor Stinner754851f2011-04-19 23:58:51 +0200387PyObject*
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200388PyThread_GetInfo(void)
Victor Stinner754851f2011-04-19 23:58:51 +0200389{
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200390 PyObject *threadinfo, *value;
391 int pos = 0;
Victor Stinnere07f5222011-04-20 12:23:26 +0200392#if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \
393 && defined(_CS_GNU_LIBPTHREAD_VERSION))
Victor Stinner754851f2011-04-19 23:58:51 +0200394 char buffer[255];
395 int len;
Victor Stinnere07f5222011-04-20 12:23:26 +0200396#endif
Victor Stinner754851f2011-04-19 23:58:51 +0200397
Victor Stinner1c8f0592013-07-22 22:24:54 +0200398 if (ThreadInfoType.tp_name == 0) {
399 if (PyStructSequence_InitType2(&ThreadInfoType, &threadinfo_desc) < 0)
400 return NULL;
401 }
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200402
403 threadinfo = PyStructSequence_New(&ThreadInfoType);
404 if (threadinfo == NULL)
Victor Stinner754851f2011-04-19 23:58:51 +0200405 return NULL;
406
407 value = PyUnicode_FromString(PYTHREAD_NAME);
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200408 if (value == NULL) {
409 Py_DECREF(threadinfo);
410 return NULL;
411 }
412 PyStructSequence_SET_ITEM(threadinfo, pos++, value);
Victor Stinner754851f2011-04-19 23:58:51 +0200413
414#ifdef _POSIX_THREADS
415#ifdef USE_SEMAPHORES
416 value = PyUnicode_FromString("semaphore");
417#else
418 value = PyUnicode_FromString("mutex+cond");
419#endif
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200420 if (value == NULL) {
421 Py_DECREF(threadinfo);
Victor Stinner754851f2011-04-19 23:58:51 +0200422 return NULL;
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200423 }
424#else
425 Py_INCREF(Py_None);
426 value = Py_None;
427#endif
428 PyStructSequence_SET_ITEM(threadinfo, pos++, value);
Victor Stinner754851f2011-04-19 23:58:51 +0200429
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200430#if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \
431 && defined(_CS_GNU_LIBPTHREAD_VERSION))
432 value = NULL;
Victor Stinner754851f2011-04-19 23:58:51 +0200433 len = confstr(_CS_GNU_LIBPTHREAD_VERSION, buffer, sizeof(buffer));
Victor Stinner98ea54c2014-08-15 23:30:40 +0200434 if (1 < len && (size_t)len < sizeof(buffer)) {
Victor Stinner754851f2011-04-19 23:58:51 +0200435 value = PyUnicode_DecodeFSDefaultAndSize(buffer, len-1);
436 if (value == NULL)
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200437 PyErr_Clear();
Victor Stinner754851f2011-04-19 23:58:51 +0200438 }
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200439 if (value == NULL)
Victor Stinner754851f2011-04-19 23:58:51 +0200440#endif
Victor Stinnerd5c355c2011-04-30 14:53:09 +0200441 {
442 Py_INCREF(Py_None);
443 value = Py_None;
444 }
445 PyStructSequence_SET_ITEM(threadinfo, pos++, value);
446 return threadinfo;
Victor Stinner754851f2011-04-19 23:58:51 +0200447}