Ticket #3883: pthread_attr_getstack_2.patch

src/system/kernel/thread.cpp

@@ -567 +567 @@
                 status = thread->user_stack_area;
                 kill_thread(thread->id);
             }
+            attributes.stack_address = (void *)thread->user_stack_base;
         } else {
             thread->user_stack_base = (addr_t)attributes.stack_address;
             thread->user_stack_size = attributes.stack_size;
@@ -2804 +2805 @@
     threadID = create_thread(attributes, false);
 
     if (threadID >= 0)
+    {
         user_debug_thread_created(threadID);
++       // Copy the attributes back to tell the user which stack_address we are
++       // using.
++       if (user_memcpy(userAttributes, &attributes, sizeof(*userAttributes)) < B_OK)
++           dprintf("_user_spawn_thread: error copying attributes baack to user space\n");
+    }
 
     return threadID;
 }

src/system/libroot/posix/pthread/pthread.c

@@ -22 +22 @@
 static const pthread_attr pthread_attr_default = {
     PTHREAD_CREATE_JOINABLE,
     B_NORMAL_PRIORITY,
+    NULL,
     USER_STACK_SIZE
 };
 
@@ -75 +76 @@
 pthread_create(pthread_t *_thread, const pthread_attr_t *_attr,
         void *(*startRoutine)(void*), void *arg)
 {
-    const pthread_attr *attr = NULL;
     pthread_thread *thread;
     struct thread_creation_attributes attributes;
 
     if (_thread == NULL)
         return B_BAD_VALUE;
 
-    if (_attr == NULL)
-        attr = &pthread_attr_default;
-    else
-        attr = *_attr;
-
     thread = (pthread_thread *)malloc(sizeof(pthread_thread));
     if (thread == NULL)
         return B_WOULD_BLOCK;
 
+    if (_attr == NULL)
+        memcpy(&thread->attr, &pthread_attr_default, sizeof(thread->attr));
+    else
+        memcpy(&thread->attr, *_attr, sizeof(thread->attr));
+
     thread->entry = startRoutine;
     thread->entry_argument = arg;
     thread->exit_value = NULL;
@@ -100 +100 @@
     thread->cleanup_handlers = NULL;
     thread->flags = 0;
 
-    if (attr->detach_state == PTHREAD_CREATE_DETACHED)
+    if (thread->attr.detach_state == PTHREAD_CREATE_DETACHED)
         thread->flags |= THREAD_DETACHED;
 
     if (sPthreadSlot == -1) {
@@ -110 +110 @@
 
     attributes.entry = pthread_thread_entry;
     attributes.name = "pthread func";
-    attributes.priority = attr->sched_priority;
+    attributes.priority = thread->attr.sched_priority;
     attributes.args1 = NULL;
     attributes.args2 = thread;
     attributes.stack_address = NULL;
-    attributes.stack_size = attr->stack_size;
+    attributes.stack_size = thread->attr.stack_size;
 
     thread->id = _kern_spawn_thread(&attributes);
     if (thread->id < 0) {
@@ -123 +123 @@
         return B_WOULD_BLOCK;
     }
 
+    thread->attr.stack_address = attributes.stack_address;
+
     resume_thread(thread->id);
     *_thread = thread;
 

src/system/libroot/posix/pthread/pthread_attr.c

@@ -15 +15 @@
 
 
 int
+pthread_getattr_np(pthread_t _thread, pthread_attr_t *_attr)
+{
+    pthread_thread *thread = (pthread_thread *)_thread;
+    pthread_attr *attr;
+
+    if (thread == NULL || _attr == NULL)
+        return B_BAD_VALUE;
+
+    attr = (pthread_attr *)malloc(sizeof(pthread_attr));
+    if (attr == NULL)
+        return B_NO_MEMORY;
+
+    memcpy(_attr, &thread->attr, sizeof(pthread_attr_t));
+
+    *_attr = attr;
+
+    return B_OK;
+}
+
+int
 pthread_attr_init(pthread_attr_t *_attr)
 {
     pthread_attr *attr;
@@ -28 +48 @@
 
     attr->detach_state = PTHREAD_CREATE_JOINABLE;
     attr->sched_priority = B_NORMAL_PRIORITY;
+    attr->stack_address = NULL;
     attr->stack_size = USER_STACK_SIZE;
 
     *_attr = attr;
@@ -134 +155 @@
 
     return 0;
 }
+
+int
+pthread_attr_getstack(const pthread_attr_t *_attr, void **stackaddr, size_t *stacksize)
+{
+    pthread_attr *attr = (pthread_attr *)_attr;
+
+    if (attr == NULL)
+        return EINVAL;
+
+    *stackaddr = attr->stack_address;
+    *stacksize = attr->stack_size;
+
+    return 0;
+}
+

src/system/libroot/posix/pthread/pthread_private.h

@@ -28 +28 @@
 typedef struct _pthread_attr {
     int32       detach_state;
     int32       sched_priority;
+    void        *stack_address;
     size_t      stack_size;
 } pthread_attr;
 
@@ -60 +61 @@
     bool        cancelled;
     struct pthread_key_data specific[PTHREAD_KEYS_MAX];
     struct __pthread_cleanup_handler *cleanup_handlers;
+    pthread_attr attr;
     // TODO: move pthread keys in here, too
 } pthread_thread;
 

headers/posix/pthread.h

@@ -229 +229 @@
     int *contentionScope);
 extern int pthread_attr_setscope(pthread_attr_t *attr, int contentionScope);
 
+extern int pthread_getattr_np(pthread_t _thread, pthread_attr_t *_attr);
+
+/* [TSA TSS] */
+extern int pthread_attr_getstack(const pthread_attr_t *attr,
+    void **stackaddr, size_t *stacksize);
+
 #if 0   /* Unimplemented attribute functions: */
 
 /* mandatory! */
@@ -257 +263 @@
 extern int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);
 
 /* [TSA TSS] */
-extern int pthread_attr_getstack(const pthread_attr_t *attr,
-    void **stackaddr, size_t *stacksize);
 extern int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);
 
 #endif  /* 0 */