Changeset f6d2c81 in mainline

Timestamp:

2007-05-30T19:50:24Z (18 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

c31e536

Parents:

51ec40f

Message:

Fix two memory leaks.

In kernel, kernel_uarg structure needs to be deallocated when a thread
with userspace context is destroyed.

In userspace, the return value of the SYS_THREAD_CREATE must be checked
for error conditions and in case of error, uarg and stack must be freed
up.

Files:

• kernel/generic/src/proc/task.c (modified) (2 diffs)
• kernel/generic/src/proc/thread.c (modified) (5 diffs)
• uspace/libc/generic/thread.c (modified) (3 diffs)

kernel/generic/src/proc/task.c

@@ -108 +108 @@
                 t = NULL;
                 link_t *cur;
-                for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head; cur = cur->next) {
-                        btree_node_t *node = list_get_instance(cur, btree_node_t, leaf_link);
+                for (cur = tasks_btree.leaf_head.next;
+                    cur != &tasks_btree.leaf_head; cur = cur->next) {
+                        btree_node_t *node;
+                        
+                        node = list_get_instance(cur, btree_node_t, leaf_link);
                         
                         unsigned int i;
@@ -222 +225 @@
  * @return Task of the running program or NULL on error.
  */
-task_t * task_run_program(void *program_addr, char *name)
+task_t *task_run_program(void *program_addr, char *name)
 {
         as_t *as;

kernel/generic/src/proc/thread.c

@@ -300 +300 @@
                 task_destroy(t->task);
         
+        /*
+         * If the thread had a userspace context, free up its kernel_uarg
+         * structure.
+         */
+        if (t->flags & THREAD_FLAG_USPACE) {
+                ASSERT(t->thread_arg);
+                free(t->thread_arg);
+        }
+
         slab_free(thread_slab, t);
 }
@@ -313 +322 @@
  * @param name      Symbolic name.
  * @param uncounted Thread's accounting doesn't affect accumulated task
- *       accounting.
+ *                  accounting.
  *
  * @return New thread's structure on success, NULL on failure.
@@ -319 +328 @@
  */
 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
-        int flags, char *name, bool uncounted)
+    int flags, char *name, bool uncounted)
 {
         thread_t *t;
@@ -638 +647 @@
  *
  */
-unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, thread_id_t *uspace_thread_id)
+unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
+    thread_id_t *uspace_thread_id)
 {
         thread_t *t;
@@ -661 +671 @@
                 thread_ready(t);
                 if (uspace_thread_id != NULL)
-                        return (unative_t) copy_to_uspace(uspace_thread_id, &t->tid,
-                            sizeof(t->tid));
+                        return (unative_t) copy_to_uspace(uspace_thread_id,
+                            &t->tid, sizeof(t->tid));
                 else
                         return 0;

uspace/libc/generic/thread.c

@@ -78 +78 @@
          * Zero out the thread local uninitialized data.
          */
-        memset(data + (&_tbss_start - &_tdata_start), 0, &_tbss_end -
-                &_tbss_start);
+        memset(data + (&_tbss_start - &_tdata_start), 0,
+            &_tbss_end - &_tbss_start);
 
         return tcb;
@@ -129 +129 @@
  * @return Zero on success or a code from @ref errno.h on failure.
  */
-int thread_create(void (* function)(void *), void *arg, char *name, thread_id_t *tid)
+int thread_create(void (* function)(void *), void *arg, char *name,
+    thread_id_t *tid)
 {
         char *stack;
         uspace_arg_t *uarg;
+        int rc;
 
         stack = (char *) malloc(getpagesize() * THREAD_INITIAL_STACK_PAGES_NO);
@@ -150 +152 @@
         uarg->uspace_uarg = uarg;
         
-        return __SYSCALL3(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name, (sysarg_t) tid);
+        rc = __SYSCALL3(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
+            (sysarg_t) tid);
+        
+        if (!rc) {
+                /*
+                 * Failed to create a new thread.
+                 * Free up the allocated structures.
+                 */
+                free(uarg);
+                free(stack);
+        }
+
+        return rc;
 }