修正lwp的相关object自动释放行为

components/lwp/lwp.h

@@ -86,7 +86,8 @@ struct rt_lwp
     rt_uint32_t signal_in_process;
     lwp_sighandler_t signal_handler[_LWP_NSIG];
 
-    rt_list_t object_list;
+    struct lwp_avl_struct *object_root;
+    struct rt_mutex object_mutex;
     struct rt_user_context user_ctx;
 
     struct rt_wqueue wait_queue; /*for console */
@@ -116,10 +117,6 @@ void lwp_set_thread_area(void *p);
 void* rt_cpu_get_thread_idr(void);
 void rt_cpu_set_thread_idr(void *p);
 
-pid_t lwp_pid_get(void);
-void lwp_pid_put(pid_t pid);
-void lwp_pid_set_lwp(pid_t pid, struct rt_lwp *lwp);
-
 int lwp_tid_get(void);
 void lwp_tid_put(int tid);
 rt_thread_t lwp_tid_get_thread(int tid);

components/lwp/lwp_futex.c

@@ -20,6 +20,7 @@ struct rt_futex
     int *uaddr;
     rt_list_t waiting_thread;
     struct lwp_avl_struct node;
+    struct rt_object *custom_obj;
 };
 
 static struct rt_mutex _futex_lock;
@@ -31,9 +32,10 @@ static int futex_system_init(void)
 }
 INIT_PREV_EXPORT(futex_system_init);
 
-void futex_destory(void *data)
+rt_err_t futex_destory(void *data)
 {
-    rt_base_t level = 0;
+    rt_err_t ret = -1;
+    rt_base_t level;
     struct rt_futex *futex = (struct rt_futex *)data;
 
     if (futex)
@@ -45,9 +47,9 @@ void futex_destory(void *data)
 
         /* release object */
         rt_free(futex);
+        ret = 0;
     }
-
-    return ;
+    return ret;
 }
 
 struct rt_futex* futex_create(int *uaddr, struct rt_lwp *lwp)
@@ -74,6 +76,7 @@ struct rt_futex* futex_create(int *uaddr, struct rt_lwp *lwp)
     futex->uaddr = uaddr;
     futex->node.avl_key = (avl_key_t)uaddr;
     futex->node.data = &lwp->address_search_head;
+    futex->custom_obj = obj;
     rt_list_init(&(futex->waiting_thread));
 
     /* insert into futex head */
@@ -212,6 +215,12 @@ int sys_futex(int *uaddr, int op, int val, const struct timespec *timeout,
             rt_set_errno(ENOMEM);
             return -RT_ENOMEM;
         }
+        if (lwp_user_object_add(lwp, futex->custom_obj) != 0)
+        {
+            rt_custom_object_destroy(futex->custom_obj);
+            rt_set_errno(ENOMEM);
+            return -RT_ENOMEM;
+        }
     }
 
     switch (op)

components/lwp/lwp_pid.c

@@ -40,7 +40,7 @@ static struct rt_lwp *lwp_pid_ary[RT_LWP_MAX_NR];
 static struct rt_lwp **lwp_pid_free_head = RT_NULL;
 static pid_t lwp_pid_ary_alloced = 1; /* 0 is reserved */
 
-pid_t lwp_pid_get(void)
+static pid_t lwp_pid_get(void)
 {
     pid_t ret = 0;
     rt_base_t level = rt_hw_interrupt_disable();
@@ -64,7 +64,7 @@ pid_t lwp_pid_get(void)
     return ret;
 }
 
-void lwp_pid_put(pid_t pid)
+static void lwp_pid_put(pid_t pid)
 {
     struct rt_lwp **p = RT_NULL;
     rt_base_t level = rt_hw_interrupt_disable();
@@ -78,7 +78,7 @@ void lwp_pid_put(pid_t pid)
     rt_hw_interrupt_enable(level);
 }
 
-void lwp_pid_set_lwp(pid_t pid, struct rt_lwp *lwp)
+static void lwp_pid_set_lwp(pid_t pid, struct rt_lwp *lwp)
 {
     if (pid > 0 && pid < RT_LWP_MAX_NR)
     {
@@ -106,97 +106,198 @@ static void __exit_files(struct rt_lwp *lwp)
     }
 }
 
-struct rt_lwp* lwp_new(void)
+void lwp_user_object_lock_init(struct rt_lwp *lwp)
 {
-    pid_t pid;
-    rt_base_t level;
-    struct rt_lwp* lwp = RT_NULL;
+    rt_mutex_init(&lwp->object_mutex, "lwp_obj", RT_IPC_FLAG_PRIO);
+}
 
-    level = rt_hw_interrupt_disable();
+void lwp_user_object_lock_destroy(struct rt_lwp *lwp)
+{
+    rt_mutex_detach(&lwp->object_mutex);
+}
 
-    pid = lwp_pid_get();
-    if (pid == 0)
+void lwp_user_object_lock(struct rt_lwp *lwp)
+{
+    if (lwp)
     {
-        LOG_E("pid slot fulled!\n");
-        goto out;
+        rt_mutex_take(&lwp->object_mutex, RT_WAITING_FOREVER);
     }
-    lwp = (struct rt_lwp *)rt_malloc(sizeof(struct rt_lwp));
-    if (lwp == RT_NULL)
+    else
     {
-        LOG_E("no memory for lwp struct!\n");
-        goto out;
+        RT_ASSERT(0);
     }
-    rt_memset(lwp, 0, sizeof(*lwp));
-    rt_list_init(&lwp->wait_list);
-    lwp->pid = pid;
-    lwp_pid_set_lwp(pid, lwp);
-    rt_list_init(&lwp->t_grp);
-    rt_list_init(&lwp->object_list);
-    lwp->address_search_head = RT_NULL;
-    rt_wqueue_init(&lwp->wait_queue);
+}
 
-    lwp->ref = 1;
-out:
-    rt_hw_interrupt_enable(level);
-    return lwp;
+void lwp_user_object_unlock(struct rt_lwp *lwp)
+{
+    if (lwp)
+    {
+        rt_mutex_release(&lwp->object_mutex);
+    }
+    else
+    {
+        RT_ASSERT(0);
+    }
 }
 
-void lwp_user_obj_free(struct rt_lwp *lwp)
+int lwp_user_object_add(struct rt_lwp *lwp, rt_object_t object)
 {
-    rt_base_t level = 0;
-    struct rt_list_node *list = RT_NULL, *node = RT_NULL;
-    struct rt_object *object = RT_NULL;
+    int ret = -1;
+
+    if (lwp && object)
+    {
+        lwp_user_object_lock(lwp);
+        if (!lwp_avl_find((avl_key_t)object, lwp->object_root))
+        {
+            struct lwp_avl_struct *node;
 
-    list = &(lwp->object_list);
+            node = (struct lwp_avl_struct *)rt_malloc(sizeof(struct lwp_avl_struct));
+            if (node)
+            {
+                rt_base_t level;
+
+                level = rt_hw_interrupt_disable();
+                object->lwp_ref_count++;
+                rt_hw_interrupt_enable(level);
+                node->avl_key = (avl_key_t)object;
+                lwp_avl_insert(node, &lwp->object_root);
+                ret = 0;
+            }
+        }
+        lwp_user_object_unlock(lwp);
+    }
+    return ret;
+}
 
-    level = rt_hw_interrupt_disable();
-    while ((node = list->next) != list)
+static rt_err_t _object_node_delete(struct rt_lwp *lwp, struct lwp_avl_struct *node)
+{
+    rt_err_t ret = -1;
+    rt_object_t object;
+
+    if (!lwp || !node)
+    {
+        return ret;
+    }
+    object = (rt_object_t)node->avl_key;
+    object->lwp_ref_count--;
+    if (object->lwp_ref_count == 0)
     {
-        object = rt_list_entry(node, struct rt_object, lwp_obj_list);
         /* remove from kernel object list */
         switch (object->type)
         {
-        case RT_Object_Class_Thread:
-        {
-            RT_ASSERT(0);
-            break;
-        }
         case RT_Object_Class_Semaphore:
-            rt_sem_delete((rt_sem_t)object);
+            ret = rt_sem_delete((rt_sem_t)object);
             break;
         case RT_Object_Class_Mutex:
-            rt_mutex_delete((rt_mutex_t)object);
+            ret = rt_mutex_delete((rt_mutex_t)object);
             break;
         case RT_Object_Class_Event:
-            rt_event_delete((rt_event_t)object);
+            ret = rt_event_delete((rt_event_t)object);
             break;
         case RT_Object_Class_MailBox:
-            rt_mb_delete((rt_mailbox_t)object);
+            ret = rt_mb_delete((rt_mailbox_t)object);
             break;
         case RT_Object_Class_MessageQueue:
-            rt_mq_delete((rt_mq_t)object);
-            break;
-        case RT_Object_Class_Device:
-            rt_device_close((rt_device_t)object);
+            ret = rt_mq_delete((rt_mq_t)object);
             break;
         case RT_Object_Class_Timer:
-            rt_timer_delete((rt_timer_t)object);
-            break;
-        case RT_Object_Class_Channel:
-            /* remove from object list */
-            rt_list_remove(&object->list);
+            ret = rt_timer_delete((rt_timer_t)object);
             break;
         case RT_Object_Class_Custom:
-            rt_custom_object_destroy(object);
+            ret = rt_custom_object_destroy(object);
             break;
         default:
             LOG_E("input object type(%d) error", object->type);
-            /* remove from object list */
-            rt_list_remove(&object->list);
             break;
         }
     }
+    else
+    {
+        ret = 0;
+    }
+    lwp_avl_remove(node, &lwp->object_root);
+    rt_free(node);
+    return ret;
+}
+
+rt_err_t lwp_user_object_delete(struct rt_lwp *lwp, rt_object_t object)
+{
+    rt_err_t ret = -1;
+
+    if (lwp && object)
+    {
+        struct lwp_avl_struct *node;
+
+        lwp_user_object_lock(lwp);
+        node = lwp_avl_find((avl_key_t)object, lwp->object_root);
+        ret = _object_node_delete(lwp, node);
+        lwp_user_object_unlock(lwp);
+    }
+    return ret;
+}
+
+void lwp_user_object_clear(struct rt_lwp *lwp)
+{
+    struct lwp_avl_struct *node;
+
+    lwp_user_object_lock(lwp);
+    while ((node = lwp_map_find_first(lwp->object_root)) != NULL)
+    {
+        _object_node_delete(lwp, node);
+    }
+    lwp_user_object_unlock(lwp);
+}
+
+static int _object_dup(struct lwp_avl_struct *node, void *arg)
+{
+    rt_object_t object;
+    struct rt_lwp *dst_lwp = (struct rt_lwp *)arg;
+
+    object = (rt_object_t)node->avl_key;
+    lwp_user_object_add(dst_lwp, object);
+    return 0;
+}
+
+void lwp_user_object_dup(struct rt_lwp *dst_lwp, struct rt_lwp *src_lwp)
+{
+    lwp_user_object_lock(src_lwp);
+    lwp_avl_traversal(src_lwp->object_root, _object_dup, dst_lwp);
+    lwp_user_object_unlock(src_lwp);
+}
+
+struct rt_lwp* lwp_new(void)
+{
+    pid_t pid;
+    rt_base_t level;
+    struct rt_lwp* lwp = RT_NULL;
+
+    level = rt_hw_interrupt_disable();
+
+    pid = lwp_pid_get();
+    if (pid == 0)
+    {
+        LOG_E("pid slot fulled!\n");
+        goto out;
+    }
+    lwp = (struct rt_lwp *)rt_malloc(sizeof(struct rt_lwp));
+    if (lwp == RT_NULL)
+    {
+        LOG_E("no memory for lwp struct!\n");
+        goto out;
+    }
+    rt_memset(lwp, 0, sizeof(*lwp));
+    rt_list_init(&lwp->wait_list);
+    lwp->pid = pid;
+    lwp_pid_set_lwp(pid, lwp);
+    rt_list_init(&lwp->t_grp);
+    lwp_user_object_lock_init(lwp);
+    lwp->address_search_head = RT_NULL;
+    rt_wqueue_init(&lwp->wait_queue);
+
+    lwp->ref = 1;
+out:
     rt_hw_interrupt_enable(level);
+    return lwp;
 }
 
 void lwp_free(struct rt_lwp* lwp)
@@ -222,11 +323,13 @@ void lwp_free(struct rt_lwp* lwp)
     {
         /* auto clean fds */
         __exit_files(lwp);
-        lwp_user_obj_free(lwp);
         rt_free(lwp->fdt.fds);
         lwp->fdt.fds = RT_NULL;
     }
 
+    lwp_user_object_clear(lwp);
+    lwp_user_object_lock_destroy(lwp);
+
     /* free data section */
     if (lwp->data_entry != RT_NULL)
     {
@@ -293,13 +396,22 @@ void lwp_free(struct rt_lwp* lwp)
                 thread->error = RT_EOK;
                 thread->msg_ret = (void*)(rt_size_t)lwp->lwp_ret;
                 rt_thread_resume(thread);
+                rt_hw_interrupt_enable(level);
+                return;
+            }
+            else
+            {
+                struct rt_lwp **it = &lwp->parent->first_child;
+
+                while (*it != lwp)
+                {
+                    it = &(*it)->sibling;
+                }
+                *it = lwp->sibling;
             }
         }
-        else
-        {
-            lwp_pid_put(lwp_to_pid(lwp));
-            rt_free(lwp);
-        }
+        lwp_pid_put(lwp_to_pid(lwp));
+        rt_free(lwp);
     }
 
     rt_hw_interrupt_enable(level);

components/lwp/lwp_pid.h

@@ -34,6 +34,15 @@ int lwp_getpid(void);
 pid_t waitpid(pid_t pid, int *status, int options);
 long list_process(void);
 
+void lwp_user_object_lock_init(struct rt_lwp *lwp);
+void lwp_user_object_lock_destroy(struct rt_lwp *lwp);
+void lwp_user_object_lock(struct rt_lwp *lwp);
+void lwp_user_object_unlock(struct rt_lwp *lwp);
+int lwp_user_object_add(struct rt_lwp *lwp, rt_object_t object);
+rt_err_t lwp_user_object_delete(struct rt_lwp *lwp, rt_object_t object);
+void lwp_user_object_clear(struct rt_lwp *lwp);
+void lwp_user_object_dup(struct rt_lwp *dst_lwp, struct rt_lwp *src_lwp);
+
 #ifdef __cplusplus
 }
 #endif

components/lwp/lwp_pmutex.c

@@ -31,8 +31,9 @@ static int pmutex_system_init(void)
 }
 INIT_PREV_EXPORT(pmutex_system_init);
 
-static void pmutex_destory(void *data)
+static rt_err_t pmutex_destory(void *data)
 {
+    rt_err_t ret = -1;
     rt_base_t level = 0;
     struct rt_pmutex *pmutex = (struct rt_pmutex *)data;
 
@@ -47,9 +48,9 @@ static void pmutex_destory(void *data)
 
         /* release object */
         rt_free(pmutex);
+        ret = 0;
     }
-
-    return ;
+    return ret;
 }
 
 static struct rt_pmutex* pmutex_create(void *umutex, struct rt_lwp *lwp)
@@ -79,7 +80,6 @@ static struct rt_pmutex* pmutex_create(void *umutex, struct rt_lwp *lwp)
         rt_free(pmutex);
         return RT_NULL;
     }
-
     pmutex->node.avl_key = (avl_key_t)umutex;
     pmutex->node.data = &lwp->address_search_head;
     pmutex->custom_obj = obj;
@@ -135,6 +135,12 @@ static int _pthread_mutex_init(void *umutex)
             rt_set_errno(ENOMEM);
             return -RT_ENOMEM;
         }
+        if (lwp_user_object_add(lwp, pmutex->custom_obj) != 0)
+        {
+            rt_custom_object_destroy(pmutex->custom_obj);
+            rt_set_errno(ENOMEM);
+            return -RT_ENOMEM;
+        }
     }
     else
     {
@@ -233,7 +239,6 @@ static int _pthread_mutex_destroy(void *umutex)
     struct rt_lwp *lwp = RT_NULL;
     struct rt_pmutex *pmutex = RT_NULL;
     rt_err_t lock_ret = 0;
-    rt_base_t level = 0;
 
     lock_ret = rt_mutex_take_interruptible(&_pmutex_lock, RT_WAITING_FOREVER);
     if (lock_ret != RT_EOK)
@@ -251,10 +256,7 @@ static int _pthread_mutex_destroy(void *umutex)
         return -RT_EINVAL;
     }
 
-    level = rt_hw_interrupt_disable();
-    rt_custom_object_destroy(pmutex->custom_obj);
-    rt_hw_interrupt_enable(level);
-
+    lwp_user_object_delete(lwp, pmutex->custom_obj);
     rt_mutex_release(&_pmutex_lock);
 
     return RT_EOK;

components/lwp/lwp_syscall.c

@@ -973,12 +973,18 @@ int sys_setpriority(int which, id_t who, int prio)
 
 rt_sem_t sys_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag)
 {
-    return rt_sem_create(name, value, flag);
+    rt_sem_t sem = rt_sem_create(name, value, flag);
+    if (lwp_user_object_add(lwp_self(), (rt_object_t)sem) != 0)
+    {
+        rt_sem_delete(sem);
+        sem = NULL;
+    }
+    return sem;
 }
 
 rt_err_t sys_sem_delete(rt_sem_t sem)
 {
-    return rt_sem_delete(sem);
+    return lwp_user_object_delete(lwp_self(), (rt_object_t)sem);
 }
 
 rt_err_t sys_sem_take(rt_sem_t sem, rt_int32_t time)
@@ -993,12 +999,18 @@ rt_err_t sys_sem_release(rt_sem_t sem)
 
 rt_mutex_t sys_mutex_create(const char *name, rt_uint8_t flag)
 {
-    return rt_mutex_create(name, flag);
+    rt_mutex_t mutex = rt_mutex_create(name, flag);
+    if (lwp_user_object_add(lwp_self(), (rt_object_t)mutex) != 0)
+    {
+        rt_mutex_delete(mutex);
+        mutex = NULL;
+    }
+    return mutex;
 }
 
 rt_err_t sys_mutex_delete(rt_mutex_t mutex)
 {
-    return rt_mutex_delete(mutex);
+    return lwp_user_object_delete(lwp_self(), (rt_object_t)mutex);
 }
 
 rt_err_t sys_mutex_take(rt_mutex_t mutex, rt_int32_t time)
@@ -1036,12 +1048,18 @@ int sys_munmap(void *addr, size_t length)
 
 rt_event_t sys_event_create(const char *name, rt_uint8_t flag)
 {
-    return rt_event_create(name, flag);
+    rt_event_t event = rt_event_create(name, flag);
+    if (lwp_user_object_add(lwp_self(), (rt_object_t)event) != 0)
+    {
+        rt_event_delete(event);
+        event = NULL;
+    }
+    return event;
 }
 
 rt_err_t sys_event_delete(rt_event_t event)
 {
-    return rt_event_delete(event);
+    return lwp_user_object_delete(lwp_self(), (rt_object_t)event);
 }
 
 rt_err_t sys_event_send(rt_event_t event, rt_uint32_t set)
@@ -1060,12 +1078,18 @@ rt_err_t sys_event_recv(rt_event_t   event,
 
 rt_mailbox_t sys_mb_create(const char *name, rt_size_t size, rt_uint8_t flag)
 {
-    return rt_mb_create(name, size, flag);
+    rt_mailbox_t mb = rt_mb_create(name, size, flag);
+    if (lwp_user_object_add(lwp_self(), (rt_object_t)mb) != 0)
+    {
+        rt_mb_delete(mb);
+        mb = NULL;
+    }
+    return mb;
 }
 
 rt_err_t sys_mb_delete(rt_mailbox_t mb)
 {
-    return rt_mb_delete(mb);
+    return lwp_user_object_delete(lwp_self(), (rt_object_t)mb);
 }
 
 rt_err_t sys_mb_send(rt_mailbox_t mb, rt_uint32_t value)
@@ -1090,12 +1114,18 @@ rt_mq_t sys_mq_create(const char *name,
                      rt_size_t   max_msgs,
                      rt_uint8_t  flag)
 {
-    return rt_mq_create(name, msg_size, max_msgs, flag);
+    rt_mq_t mq = rt_mq_create(name, msg_size, max_msgs, flag);
+    if (lwp_user_object_add(lwp_self(), (rt_object_t)mq) != 0)
+    {
+        rt_mq_delete(mq);
+        mq = NULL;
+    }
+    return mq;
 }
 
 rt_err_t sys_mq_delete(rt_mq_t mq)
 {
-    return rt_mq_delete(mq);
+    return lwp_user_object_delete(lwp_self(), (rt_object_t)mq);
 }
 
 rt_err_t sys_mq_send(rt_mq_t mq, void *buffer, rt_size_t size)
@@ -1127,12 +1157,18 @@ rt_timer_t sys_timer_create(const char *name,
         rt_tick_t   time,
         rt_uint8_t  flag)
 {
-    return rt_timer_create(name, timer_timeout_callback, (void *)data, time, flag);
+    rt_timer_t timer = rt_timer_create(name, timer_timeout_callback, (void *)data, time, flag);
+    if (lwp_user_object_add(lwp_self(), (rt_object_t)timer) != 0)
+    {
+        rt_timer_delete(timer);
+        timer = NULL;
+    }
+    return timer;
 }
 
 rt_err_t sys_timer_delete(rt_timer_t timer)
 {
-    return rt_timer_delete(timer);
+    return lwp_user_object_delete(lwp_self(), (rt_object_t)timer);
 }
 
 rt_err_t sys_timer_start(rt_timer_t timer)
@@ -1538,6 +1574,9 @@ int _sys_fork(void)
     rt_memcpy(thread->stack_addr, self_thread->stack_addr, self_thread->stack_size);
     lwp_tid_set_thread(tid, thread);
 
+    /* duplicate user objects */
+    lwp_user_object_dup(lwp, self_lwp);
+
     level = rt_hw_interrupt_disable();
     user_stack = lwp_get_user_sp();
     rt_hw_interrupt_enable(level);
@@ -1923,6 +1962,7 @@ int sys_execve(const char *path, char *const argv[], char *const envp[])
     }
     rt_memset(new_lwp, 0, sizeof(struct rt_lwp));
     new_lwp->ref = 1;
+    lwp_user_object_lock_init(new_lwp);
     ret = arch_user_space_init(new_lwp);
     if (ret != 0)
     {
@@ -1958,6 +1998,9 @@ int sys_execve(const char *path, char *const argv[], char *const envp[])
         int last_backslash = 0;
         char *run_name = args_info.argv[0];
 
+        /* clear all user objects */
+        lwp_user_object_clear(lwp);
+
         /* find last \ or / */
         while (1)
         {

include/rtdef.h

@@ -365,7 +365,7 @@ struct rt_object
 #endif
 
 #ifdef RT_USING_LWP
-    rt_list_t  lwp_obj_list;                            /**< list node of kernel object for lwp */
+    int       lwp_ref_count;                            /**< ref count for lwp */
 #endif
 
     rt_list_t  list;                                    /**< list node of kernel object */
@@ -650,7 +650,7 @@ struct rt_thread
 #endif
 
 #ifdef RT_USING_LWP
-    rt_list_t  lwp_obj_list;                            /**< list node of kernel object for lwp */
+    int       lwp_ref_count;                            /**< ref count for lwp */
 #endif
 
     rt_list_t   list;                                   /**< the object list */

include/rtthread.h

@@ -57,8 +57,8 @@ rt_object_t rt_object_find(const char *name, rt_uint8_t type);
 
 #ifdef RT_USING_HEAP
 /* custom object */
-rt_object_t rt_custom_object_create(const char *name, void *data, void (*data_destroy)(void *));
-void rt_custom_object_destroy(rt_object_t obj);
+rt_object_t rt_custom_object_create(const char *name, void *data, rt_err_t (*data_destroy)(void *));
+rt_err_t rt_custom_object_destroy(rt_object_t obj);
 #endif
 
 #ifdef RT_USING_HOOK

src/object.c

@@ -29,7 +29,7 @@
 struct rt_custom_object
 {
     struct rt_object parent;
-    void (*destroy)(void *);
+    rt_err_t (*destroy)(void *);
     void *data;
 };
 
@@ -484,21 +484,6 @@ rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
         rt_list_insert_after(&(information->object_list), &(object->list));
     }
 
-#ifdef RT_USING_LWP
-    {
-        struct rt_lwp *lwp = lwp_self();
-        if (lwp && type != RT_Object_Class_Thread)
-        {
-            /* insert object into lwP object list */
-            rt_list_insert_after(&(lwp->object_list), &(object->lwp_obj_list));
-        }
-        else
-        {
-            rt_list_init(&(object->lwp_obj_list));
-        }
-    }
-#endif
-
     /* unlock interrupt */
     rt_hw_interrupt_enable(temp);
 
@@ -530,11 +515,6 @@ void rt_object_delete(rt_object_t object)
     /* remove from old list */
     rt_list_remove(&(object->list));
 
-#ifdef RT_USING_LWP
-    /* remove from the object list of lwP */
-    rt_list_remove(&(object->lwp_obj_list));
-#endif
-
     /* unlock interrupt */
     rt_hw_interrupt_enable(temp);
 
@@ -643,7 +623,7 @@ rt_object_t rt_object_find(const char *name, rt_uint8_t type)
  * @note this function shall not be invoked in interrupt status.
  */
 
-rt_object_t rt_custom_object_create(const char *name, void *data, void (*data_destroy)(void *))
+rt_object_t rt_custom_object_create(const char *name, void *data, rt_err_t (*data_destroy)(void *))
 {
     struct rt_custom_object *cobj = RT_NULL;
 
@@ -661,23 +641,25 @@ rt_object_t rt_custom_object_create(const char *name, void *data, void (*data_de
  * This function will destroy a custom object
  * container.
  *
- * @param name the specified name of object.
+ * @param obj the specified name of object.
  *
  * @note this function shall not be invoked in interrupt status.
  */
-void rt_custom_object_destroy(rt_object_t obj)
+rt_err_t rt_custom_object_destroy(rt_object_t obj)
 {
+    rt_err_t ret = -1;
+
     struct rt_custom_object *cobj = (struct rt_custom_object *)obj;
 
-    if (!obj || obj->type != RT_Object_Class_Custom)
+    if (obj && obj->type == RT_Object_Class_Custom)
     {
-        return;
-    }
-    if (cobj->destroy)
-    {
-        cobj->destroy(cobj->data);
+        if (cobj->destroy)
+        {
+            ret = cobj->destroy(cobj->data);
+        }
+        rt_object_delete(obj);
     }
-    rt_object_delete(obj);
+    return ret;
 }
 #endif