/**
 * @file thread.c
 * @author ATShining (1358745329@qq.com)
 * @brief
 * @version 0.1
 * @date 2023-09-29
 *
 * @copyright Copyright (c) 2023
 *
 */

#include "thread.h"

#include <arch.h>
#include <pre_cpu.h>
#include <thread_arch.h>

#include "access.h"
#include "arch.h"
#include "assert.h"
#include "err.h"
#include "factory.h"
#include "init.h"
#include "ipc.h"
#include "kobject.h"
#include "map.h"
#include "mm_wrap.h"
#include "ram_limit.h"
#include "slist.h"
#include "string.h"
#include "task.h"
#include "thread.h"
#include "thread_task_arch.h"
#include "types.h"
#include "sema.h"
#include "sleep.h"
#include "thread_knl.h"
#if IS_ENABLED(CONFIG_SMP)
#include <ipi.h>
#endif
#if IS_ENABLED(CONFIG_MPU)
#include <mpu.h>
#endif

#define TAG "[thread]"
enum thread_op
{
    SET_EXEC_REGS,
    RUN_THREAD,
    BIND_TASK,
    MSG_BUG_GET,
    MSG_BUG_SET,
    YIELD,
    DO_IPC = 6, //!< 与ipc对象中的额IPC_DO一致
    SET_EXEC,   //!< 设置异常处理
    SLEEP,
};
enum IPC_TYPE
{
    IPC_CALL,
    IPC_REPLY,
    IPC_WAIT,
    IPC_RECV,
    IPC_SEND,
    IPC_FAST_CALL,   //!< 快速CALL通信，不切换上下文
    IPC_FAST_REPLAY, //!<
};
static void thread_syscall(kobject_t *kobj, syscall_prot_t sys_p,
                           msg_tag_t in_tag, entry_frame_t *f);
static bool_t thread_put(kobject_t *kobj);
static void thread_release_stage1(kobject_t *kobj);
static void thread_release_stage2(kobject_t *kobj);
#if 0
typedef struct thread_wait_entry
{
    slist_head_t node;
    slist_head_t node_timeout;
    thread_t *th;
    mword_t times;
} thread_wait_entry_t;

static inline void thread_wait_entry_init(thread_wait_entry_t *entry,
                                          thread_t *th, mword_t times)
{
    slist_init(&entry->node);
    slist_init(&entry->node_timeout);
    entry->th = th;
    entry->times = times;
}
static PER_CPU(slist_head_t, wait_send_queue);
static PER_CPU(slist_head_t, wait_recv_queue);

static void thread_timeout_init(void)
{
    for (int i = 0; i < CONFIG_CPU; i++)
    {
        slist_init(pre_cpu_get_var_cpu(i, (&wait_send_queue)));
        slist_init(pre_cpu_get_var_cpu(i, (&wait_recv_queue)));
    }
}
INIT_KOBJ(thread_timeout_init);
#endif

#if IS_ENABLED(CONFIG_BUDDY_SLAB)
#include <buddy.h>
#endif
/**
 * @brief 在系统初始化时调用，初始化thread的内存
 *
 */
static void thread_mem_init(void)
{
#if IS_ENABLED(CONFIG_BUDDY_SLAB)
#endif
}
INIT_KOBJ_MEM(thread_mem_init);

/**
 * @brief 线程的初始化函数
 *
 * @param th
 */
void thread_init(thread_t *th, ram_limit_t *lim, umword_t flags)
{
    assert(th);
    assert(th->com);
    assert(lim);
    kobject_init(&th->kobj, THREAD_TYPE);
    sched_init(&th->sche);
    slist_init(&th->futex_node);
    slist_init(&th->release_node);
#if 0
    slist_init(&th->wait_send_head);
    spinlock_init(&th->recv_lock);
    spinlock_init(&th->send_lock);
#endif
    ref_counter_init(&th->ref);
    ref_counter_inc(&th->ref);
    thread_arch_init(th, flags);

    kobject_set_name(&th->kobj, kobject_get_name(&th->kobj));
    slist_init(&th->com->fast_ipc_node);
    stack_init(&th->com->fast_ipc_stack, &th->com->fast_ipc_stack_data,
               ARRARY_LEN(th->com->fast_ipc_stack_data),
               sizeof(th->com->fast_ipc_stack_data[0]));
    th->com->th = th;

    th->cpu = arch_get_current_cpu_id();
    th->lim = lim;
    th->kobj.invoke_func = thread_syscall;
    th->kobj.put_func = thread_put;
    th->kobj.stage_1_func = thread_release_stage1;
    th->kobj.stage_2_func = thread_release_stage2;
    th->magic = THREAD_MAGIC;
}
static bool_t thread_put(kobject_t *kobj)
{
    thread_t *th = container_of(kobj, thread_t, kobj);

    return ref_counter_dec(&th->ref) == 1;
}
static void thread_release_stage1_impl(thread_t *th)
{
    if (stack_len(&th->com->fast_ipc_stack)==0){
        //处于ipc通信中，不能直接删除，否者会立刻中断ipc中的执行
        if (th->status == THREAD_READY)
        {
            thread_suspend(th);
        }
        
        thread_sleep_del(th); //!< 从休眠中删除
        thread_unbind(th);
        th->ipc_status = THREAD_IPC_ABORT;
    } else {
        th->ipc_status = THREAD_IPC_ABORT;
    }
}
#if IS_ENABLED(CONFIG_SMP)
static int thread_remote_release_stage1_handler(ipi_msg_t *msg, bool_t *is_sched)
{
    thread_t *th = (thread_t *)msg->msg;
    assert(th);
    thread_release_stage1_impl(th);
    return 0;
}
#endif
int thread_release_stage1_remote(thread_t *th)
{
#if IS_ENABLED(CONFIG_SMP)
    if (th->cpu != arch_get_current_cpu_id())
    {
        th->ipi_msg_node.msg = (umword_t)th;
        th->ipi_msg_node.cb = thread_remote_release_stage1_handler;
        cpu_ipi_to_msg(1 << th->cpu, &th->ipi_msg_node, IPI_CALL);
    }
    else
    {
        thread_release_stage1_impl(th);
    }
#else
    thread_release_stage1_impl(th);
#endif
    return 0;
}
static void thread_release_stage1(kobject_t *kobj)
{
    thread_t *th = container_of(kobj, thread_t, kobj);
    thread_t *cur = thread_get_current();
    kobject_invalidate(kobj);

    if (cur != th)
    {
        thread_release_stage1_remote(th);
    }
    else
    {
        thread_release_stage1_remote(cur);
    }
}
static void thread_release_stage2(kobject_t *kobj)
{
    thread_t *th = container_of(kobj, thread_t, kobj);
    thread_t *cur_th = thread_get_current();

    if (cur_th == th)
    {
        scheduler_reset();
        thread_sched(FALSE);
        arch_to_sche();
    }
#if IS_ENABLED(CONFIG_BUDDY_SLAB)
    mm_limit_free_buddy(th->lim, kobj, CONFIG_THREAD_BLOCK_SIZE);
#else
    mm_limit_free_align(th->lim, kobj, CONFIG_THREAD_BLOCK_SIZE);
    // mm_trace();
    printk("release thread 0x%x, name:%s\n", kobj, kobject_get_name(kobj));
#endif
}

/**
 * @brief 设置运行寄存器
 *
 * @param th
 * @param pc
 * @param ip
 */
void thread_set_exc_regs(thread_t *th, umword_t pc, umword_t user_sp,
                         umword_t ram)
{
    thread_user_pf_set(th, (void *)pc, (void *)user_sp, (void *)ram);
}
/**
 * @brief 线程绑定到task
 *
 * @param th
 * @param tk
 */
void thread_bind(thread_t *th, kobject_t *tk)
{
    th->task = tk;
    task_t *tsk = container_of(tk, task_t, kobj);

    ref_counter_inc(&tsk->ref_cn);
}
/**
 * @brief 解除task绑定
 *
 * @param th
 */
void thread_unbind(thread_t *th)
{
    if (th->task)
    {
        task_t *tsk = container_of(th->task, task_t, kobj);

        ref_counter_dec_and_release(&tsk->ref_cn, &tsk->kobj);
        th->task = NULL;
    }
}
void thread_suspend_sw(thread_t *th, bool_t is_sche)
{
    assert(cpulock_get_status());
    assert(slist_in_list(&th->sche.node));
    assert(th->cpu == arch_get_current_cpu_id());
    umword_t status = cpulock_lock();

    th->status = THREAD_SUSPEND;
    scheduler_del(&th->sche);

    /* 当前线程才能够切出，不是当前线程执行这个也没有效果，而且还会导致当前线程切出*/
    if (th == thread_get_current() && is_sche)
    {
        thread_sched(TRUE);
    }
    else
    {
        thread_sched(FALSE);
        arch_to_sche(); //!< 触发调度中断
    }
    // printk("suspend: th:0x%lx\n", th);
    cpulock_set(status);
}
/**
 * @brief 挂起一个线程
 *
 * @param th
 */
void thread_suspend(thread_t *th)
{
    thread_suspend_sw(th, TRUE);
}

/**
 * @brief 线程死亡
 *
 * @param th
 */
void thread_dead(thread_t *th)
{
    if (!slist_in_list(&th->sche.node))
    {
        assert(slist_in_list(&th->sche.node));
    }
    scheduler_del(&th->sche);
    th->status = THREAD_DEAD;
    thread_sched(TRUE);
}

/**
 * @brief 进行一次调度
 *
 * @param th
 */
bool_t thread_sched(bool_t is_sche)
{
    umword_t status = cpulock_lock();
    sched_t *next_sche = scheduler_next();
    thread_t *th = thread_get_current();

    assert(next_sche);
    assert(th->magic == THREAD_MAGIC);
    if (next_sche == &th->sche)
    {
        //!< 线程没有发生变化，则不用切换
        cpulock_set(status);
        return FALSE;
    }
    if (is_sche)
    {
        // 立刻进行切换
#if IS_ENABLED(CONFIG_MMU)
        sche_arch_sw_context();
#else
        arch_to_sche();
#endif
    }
    // printk("sched: cpu:%d sp:0x%lx\n", arch_get_current_cpu_id(), th->sp.sp);
    cpulock_set(status);
    return TRUE;
}

#if IS_ENABLED(CONFIG_SMP)
static int thread_ready_remote_handler(ipi_msg_t *msg, bool_t *is_sched)
{
    thread_t *to_ready_th = (thread_t *)(msg->msg);
    thread_ready(to_ready_th, msg->msg2);

    thread_t *src_th = container_of(msg, thread_t, ipi_msg_node);

    *is_sched = src_th != to_ready_th;
    return 0;
}
#endif
void thread_ready_remote(thread_t *th, bool_t is_sche)
{
#if IS_ENABLED(CONFIG_SMP)
    thread_t *cur_th = thread_get_current();
    if (th->cpu == arch_get_current_cpu_id())
    {
        thread_ready(th, is_sche);
    }
    else
    {
        cur_th->ipi_msg_node.msg = (umword_t)th;
        cur_th->ipi_msg_node.msg2 = is_sche;
        cur_th->ipi_msg_node.cb = thread_ready_remote_handler;
        cpu_ipi_to_msg(1 << th->cpu, &cur_th->ipi_msg_node, IPI_CALL);
    }
#else
    thread_ready(th, is_sche);
#endif
}
/**
 * @brief 线程进入就绪态
 *
 * @param th
 */
void thread_ready(thread_t *th, bool_t is_sche)
{
    assert(th);
    bool_t ret;
    umword_t status = cpulock_lock();

    if (slist_in_list(&th->sche.node))
    {
#if THREAD_IS_DEBUG
        dbg_printk(TAG "%s:%d panic : %s[0x%x] status:%d ipc_status:%d \n", __func__, __LINE__,
                   kobject_get_name(&th->kobj), th, th->status, th->ipc_status);
#endif
        assert(!slist_in_list(&th->sche.node));
    }
    assert(th->cpu == arch_get_current_cpu_id());
    th->status = THREAD_READY;
    ret = scheduler_add(&th->sche);
    if (is_sche && ret && th == thread_get_current())
    {
        // ready线程的优先级大于最大优先级
        thread_sched(TRUE);
    }
    else
    {
        thread_sched(FALSE);
        arch_to_sche();
    }
    // printk("ready: th:0x%lx\n", th);
    cpulock_set(status);
}
void thread_todead(thread_t *th, bool_t is_sche)
{
    // if (!!slist_in_list(&th->sche.node))
    // {
    assert(!slist_in_list(&th->sche.node));
    // }
    scheduler_add(&th->sche);
    th->status = THREAD_TODEAD;
    if (is_sche)
    {
        thread_sched(TRUE);
    }
}
/**
 * @brief 创建线程
 *
 * @param ram
 * @return thread_t*
 */
thread_t *thread_create(ram_limit_t *ram, umword_t flags)
{
    thread_t *th = NULL;

#if IS_ENABLED(CONFIG_BUDDY_SLAB)
    th = mm_limit_alloc_buddy(ram, CONFIG_THREAD_BLOCK_SIZE);
#else
    th = mm_limit_alloc_align(ram, CONFIG_THREAD_BLOCK_SIZE,
                              CONFIG_THREAD_BLOCK_SIZE);
#endif
    if (!th)
    {
        return NULL;
    }
    memset(th, 0, CONFIG_THREAD_BLOCK_SIZE);
    th->com = mm_limit_alloc(ram, sizeof(*th->com));
    if (!th->com)
    {
        mm_limit_free(ram, th);
        return NULL;
    }
    // assert(((mword_t)th & (~(CONFIG_THREAD_BLOCK_SIZE - 1))) == 0);
    memset(th->com, 0, sizeof(*th->com));
    thread_init(th, ram, flags);
    printk("create thread 0x%x\n", th);
    return th;
}

static int ipc_dat_copy_raw(obj_space_t *dst_obj, obj_space_t *src_obj, ram_limit_t *lim,
                            ipc_msg_t *dst_ipc, ipc_msg_t *src_ipc, msg_tag_t tag, int is_reply)
{
    int i = 0;
    if (tag.map_buf_len > 0)
    {
        kobj_del_list_t del;
        int map_len = tag.map_buf_len;

        kobj_del_list_init(&del);

        for (i = 0; i < map_len; i++)
        {
            int ret = 0;

            vpage_t dst_page = vpage_create_raw(dst_ipc->map_buf[i]);
            vpage_t src_page = vpage_create_raw(src_ipc->map_buf[i]);

            // printk("map-> src:%d dst:%d\n", src_page.addr, dst_page.addr);
            if ((src_page.flags & VPAGE_FLAGS_MAP) || is_reply)
            {
                ret = obj_map_src_dst(dst_obj, src_obj,
                                      vpage_get_obj_handler(dst_page),
                                      vpage_get_obj_handler(src_page), lim,
                                      vpage_get_attrs(src_page), &del);
            }

            if (ret < 0)
            {
                return ret;
            }
        }
        kobj_del_list_to_do(&del);
    }
    memcpy(dst_ipc->msg_buf, src_ipc->msg_buf,
           MIN(tag.msg_buf_len * WORD_BYTES, IPC_MSG_SIZE));
    return i;
}
#if 0
/**
 * @brief ipc传输时的数据拷贝
 *
 * @param dst_th
 * @param src_th
 * @param tag
 * @return int
 */
static int ipc_data_copy(thread_t *dst_th, thread_t *src_th, msg_tag_t tag, int is_reply)
{
    void *src = thread_get_kmsg_buf(src_th);
    void *dst = thread_get_kmsg_buf(dst_th);
    ipc_msg_t *src_ipc;
    ipc_msg_t *dst_ipc;
    task_t *src_tk = thread_get_bind_task(src_th);
    task_t *dst_tk = thread_get_bind_task(dst_th);

    src_ipc = src;
    dst_ipc = dst;

    ipc_dat_copy_raw(&dst_tk->obj_space, &src_tk->obj_space, dst_tk->lim, dst_ipc, src_ipc, tag, is_reply);
    dst_ipc->user[2] = task_pid_get(src_tk);

    dst_th->msg.tag = tag;
    return 0;
}
#if IS_ENABLED(CONFIG_SMP)
static int thread_del_wait_send_handler(ipi_msg_t *msg, bool_t *is_sched)
{
    thread_wait_entry_t *wait = (void *)msg->msg;
    if (slist_in_list(&wait->node_timeout))
    {
        slist_del(&wait->node_timeout);
    }
    thread_ready(wait->th, TRUE);
    return 0;
}
#endif
int thread_del_wait_send_remote(thread_wait_entry_t *wait)
{
    assert(cpulock_get_status() == TRUE);
    thread_t *th = wait->th;
#if IS_ENABLED(CONFIG_SMP)
    if (th->cpu != arch_get_current_cpu_id())
    {
        th->ipi_msg_node.msg = (umword_t)wait;
        th->ipi_msg_node.cb = thread_del_wait_send_handler;
        cpu_ipi_to_msg(1 << th->cpu, &th->ipi_msg_node, IPI_CALL);
    }
    else
#endif
    {
        if (slist_in_list(&wait->node_timeout))
        {
            slist_del(&wait->node_timeout);
        }
        thread_ready(th, FALSE);
    }
    return 0;
}
/**
 * @brief 当前线程接收数据
 *
 * @return int
 */
static int thread_ipc_recv(msg_tag_t *ret_msg, ipc_timeout_t timeout,
                           umword_t *ret_user_id, ipc_t *ipc_kobj,
                           thread_t *recv_obj)
{
    assert(ret_msg);
    assert(ret_user_id);
    int ret = 0;
    umword_t lock_status = 0;
    umword_t lock_status2 = 0;
    thread_wait_entry_t wait = {0};
    slist_head_t *ready_head = NULL; //!< 有发送者
    thread_t *cur_th = thread_get_current();

    assert(cur_th != recv_obj);

    lock_status = cpulock_lock();
    lock_status2 = spinlock_lock(&cur_th->recv_lock);
    if (ipc_kobj)
    {
        /*IPC对象的引用计数+1*/
        ref_counter_inc(&ipc_kobj->ref);
        cur_th->ipc_kobj = &ipc_kobj->kobj;
    }
    else
    {
        cur_th->ipc_kobj = NULL;
    }
#if THREAD_IS_DEBUG
    dbg_printk(TAG "%s:%d ipc recv start: %s[0x%x] status:%d ipc_status:%d recv_obj:0x%x\n", __func__, __LINE__,
               kobject_get_name(&cur_th->kobj), cur_th, cur_th->status, cur_th->ipc_status, recv_obj);
#endif

    if (!slist_is_empty(&cur_th->wait_send_head) && !recv_obj)
    {
        ready_head = slist_first(&cur_th->wait_send_head);
        slist_del(ready_head); //!< 从当前线程中删除唤醒的线程
        thread_wait_entry_t *wait =
            container_of(ready_head, thread_wait_entry_t, node);
        assert(wait->th->status == THREAD_SUSPEND);

        thread_del_wait_send_remote(wait);
#if THREAD_IS_DEBUG
        dbg_printk(TAG "%s:%d ipc recv start3: %s[0x%x] status:%d ipc_status:%d wait_th:0x%x\n", __func__, __LINE__,
                   kobject_get_name(&cur_th->kobj), cur_th, cur_th->status, cur_th->ipc_status, wait->th);
#endif
    }
    else
    {
        if (timeout.recv_timeout)
        {
            thread_wait_entry_init(&wait, cur_th, timeout.recv_timeout);
            // printk("add timeout:0x%lx\n", cur_th);
            slist_add_append(pre_cpu_get_current_cpu_var(&wait_recv_queue),
                             &wait.node); //!< 放到等待队列中
#if THREAD_IS_DEBUG
            dbg_printk(TAG "%s:%d ipc recv app sleep: %s[0x%x] status:%d ipc_status:%d\n", __func__, __LINE__,
                       kobject_get_name(&cur_th->kobj), cur_th, cur_th->status, cur_th->ipc_status);
#endif
        }
    }
    if (recv_obj)
    {
        thread_timeout_del_recv_remote(recv_obj, TRUE);

#if THREAD_IS_DEBUG
        dbg_printk(TAG "%s:%d ipc call wake: %s[0x%x] status:%d ipc_status:%d\n", __func__, __LINE__,
                   kobject_get_name(&recv_obj->kobj), recv_obj, recv_obj->status, recv_obj->ipc_status);
#endif
    }
    // cur_th->has_wait_send_th = FALSE;
    cur_th->has_wait_send_th = TRUE;
    thread_set_ipc_state(cur_th, THREAD_RECV);
    thread_suspend_sw(cur_th, FALSE);
    spinlock_set(&cur_th->recv_lock, lock_status2);
    preemption(); //!< 进行调度
#if THREAD_IS_DEBUG
    dbg_printk(TAG "%s:%d ipc recv wait: %s[0x%x] status:%d ipc_status:%d recv_obj:0x%x\n", __func__, __LINE__,
               kobject_get_name(&cur_th->kobj), cur_th, cur_th->status, cur_th->ipc_status, recv_obj);
#endif
    assert(cur_th->status == THREAD_READY);
    // cur_th->has_wait_send_th = FALSE;
#if THREAD_IS_DEBUG
    dbg_printk(TAG "%s:%d ipc recv wake: %s[0x%x] recv_obj:0x%x\n", __func__, __LINE__,
               kobject_get_name(&cur_th->kobj), cur_th, recv_obj);
#endif
    if (cur_th->ipc_status == THREAD_IPC_ABORT)
    {
        ret = -ESHUTDOWN;
    }
    else if (cur_th->ipc_status == THREAD_TIMEOUT)
    {
        ret = -ERTIMEDOUT;
    }
    else
    {
        *ret_msg = cur_th->msg.tag;
        *ret_user_id = cur_th->user_id;
    }
    cur_th->ipc_status = THREAD_NONE;
    cpulock_set(lock_status);

    return ret;
}
static int thread_ipc_reply_inner(thread_t *form, thread_t *to,
                                  msg_tag_t in_tag)
{
again:;
    mword_t status_lock2 = spinlock_lock(&to->recv_lock);
    if (to->status != THREAD_SUSPEND || to->ipc_status != THREAD_RECV)
    {
        /*TODO:这里应该挂起等待*/
        if (to->ipc_status == THREAD_IPC_ABORT)
        {
            ref_counter_dec_and_release(&to->ref, &to->kobj);
            spinlock_set(&to->recv_lock, status_lock2);
            return -ECANCELED;
        }
        thread_sched(TRUE);
        spinlock_set(&to->recv_lock, status_lock2);
        preemption();
        goto again;
    }
#if THREAD_IS_DEBUG
    dbg_printk(TAG "%s:%d ipc reply: %s[0x%x]-->%s[0x%x]\n", __func__, __LINE__,
               kobject_get_name(&form->kobj), form, kobject_get_name(&to->kobj), to);
#endif
    //!< 发送数据给上一次的发送者
    int ret = ipc_data_copy(to, form, in_tag, TRUE); //!< 拷贝数据

    if (ret < 0)
    {
        in_tag.prot = ret;
    }
    to->msg.tag = in_tag;
    if (to->ipc_status != THREAD_IPC_ABORT)
    {
#if THREAD_IS_DEBUG
        dbg_printk(TAG "%s:%d ipc reply to:%s[0x%x] status:%d\n", __func__, __LINE__,
                   kobject_get_name(&to->kobj), to, to->status);
#endif
        assert(to->status == THREAD_SUSPEND && to->ipc_status == THREAD_RECV);
        thread_timeout_del_from_send_queue_remote(to);
    }
    ref_counter_dec_and_release(&to->ref, &to->kobj);
    spinlock_set(&to->recv_lock, status_lock2);
    return 0;
}
#if IS_ENABLED(CONFIG_SMP)
static int thread_ipc_reply_handler(ipi_msg_t *msg, bool_t *is_sched)
{
    thread_t *form;
    thread_t *to;
    msg_tag_t in_tag;

    form = (thread_t *)msg->msg;
    to = (thread_t *)msg->msg2;
    in_tag = msg_tag_init(msg->msg3);

    return thread_ipc_reply_inner(form, to, in_tag);
}
#endif
int thread_ipc_reply_remote(thread_t *form, thread_t *to, msg_tag_t in_tag)
{
#if IS_ENABLED(CONFIG_SMP)
    if (to->cpu == arch_get_current_cpu_id())
    {
        return thread_ipc_reply_inner(form, to, in_tag);
    }
    else
    {
        to->ipi_msg_node.msg = (umword_t)form;
        to->ipi_msg_node.msg2 = (umword_t)to;
        to->ipi_msg_node.msg3 = (umword_t)in_tag.raw;
        to->ipi_msg_node.cb = thread_ipc_reply_handler;
        cpu_ipi_to_msg(1 << to->cpu, &to->ipi_msg_node, IPI_CALL);

        return to->ipi_msg_node.ret;
    }
#else
    return thread_ipc_reply_inner(form, to, in_tag);
#endif
}
/**
 * @brief 当前线程回复数据给上一次的发送者，回复完成后则释放上一次的接收者指针
 *
 * @param in_tag
 * @return int
 */
static int thread_ipc_reply(msg_tag_t in_tag)
{
    thread_t *cur_th = thread_get_current();
    umword_t status;
    thread_t *last_th;
    int ret;

    if (cur_th->last_send_th == NULL)
    {
        return -1;
    }
    status = spinlock_lock(&cur_th->send_lock);
    if (cur_th->last_send_th == NULL)
    {
        spinlock_set(&cur_th->send_lock, status);
        return -1;
    }
    last_th = cur_th->last_send_th;
    ret = thread_ipc_reply_inner(cur_th, last_th, in_tag);
    spinlock_set(&cur_th->send_lock, status);
    return ret;
}
#if IS_ENABLED(CONFIG_SMP)
static int thread_remote_suspend_handler(ipi_msg_t *msg, bool_t *is_sched)
{
    thread_t *th = (thread_t *)msg->msg;
    assert(th);
    thread_suspend(th);
    return 0;
}
#endif
int thread_suspend_remote(thread_t *th, bool_t is_sche)
{
    assert(cpulock_get_status());
#if IS_ENABLED(CONFIG_SMP)
    if (th->cpu != arch_get_current_cpu_id())
    {
        th->ipi_msg_node.msg = (umword_t)th;
        th->ipi_msg_node.cb = thread_remote_suspend_handler;
        cpu_ipi_to_msg(1 << th->cpu, &th->ipi_msg_node, IPI_CALL);
    }
    else
    {
        thread_suspend_sw(th, is_sche);
    }
#else
    thread_suspend_sw(th, is_sche);
#endif
    return 0;
}

/**
 * @brief 等待某个线程进入挂起状态
 *
 * @param recv_th
 * @param timeout
 * @return int
 */
static int thread_wait_recv_thread(thread_t *recv_th, ipc_timeout_t timeout)
{
    int ret = 0;
    assert(cpulock_get_status() == TRUE);
    thread_t *cur_th = thread_get_current();
    mword_t lock_status;

again_check:
    lock_status = spinlock_lock(&recv_th->recv_lock);
    if ((thread_get_status(recv_th) != THREAD_SUSPEND ||
         thread_get_ipc_state(recv_th) != THREAD_RECV) ||
        recv_th->has_wait_send_th == FALSE /*如果已经在有人准备从这个线程获取数据，则当前call者需要挂起*/)
    {
        thread_wait_entry_t wait;

        // 初始化等待队列
        thread_wait_entry_init(&wait, cur_th, timeout.send_timeout);
#if THREAD_IS_DEBUG
        dbg_printk(TAG "%s:%d ipc wait for: %s[0x%x]\n", __func__, __LINE__,
                   kobject_get_name(&recv_th->kobj), recv_th);
#endif
        slist_add_append(&recv_th->wait_send_head,
                         &wait.node); //!< 放到线程的等待队列中
        slist_add_append(pre_cpu_get_current_cpu_var(&wait_send_queue),
                         &wait.node_timeout);

        recv_th->has_wait_send_th = TRUE;
        thread_set_ipc_state(cur_th, THREAD_SEND);
        thread_suspend_sw(cur_th, FALSE);
        spinlock_set(&recv_th->recv_lock, lock_status);
        preemption();
        if (thread_get_ipc_state(cur_th) == THREAD_IPC_ABORT)
        {
            thread_set_state(cur_th, THREAD_NONE);
            ret = -ESHUTDOWN;
            goto end;
        }
        else if (thread_get_ipc_state(cur_th) == THREAD_TIMEOUT)
        {
            thread_set_state(cur_th, THREAD_NONE);
            ret = -EWTIMEDOUT;
            goto end;
        }
        thread_set_state(cur_th, THREAD_NONE);
        goto again_check;
    }
    else
    {
        recv_th->has_wait_send_th = FALSE;
        spinlock_set(&recv_th->recv_lock, lock_status);
#if THREAD_IS_DEBUG
        dbg_printk(TAG "%s:%d ipc wait end: %s[0x%x] status:%d ipc_status:%d\n", __func__,
                   __LINE__, kobject_get_name(&recv_th->kobj), recv_th, recv_th->status,
                   recv_th->ipc_status);
#endif
    }
end:
    assert(recv_th->status == THREAD_SUSPEND && recv_th->ipc_status == THREAD_RECV);
    return ret;
}
//__attribute__((optimize(0)))
int thread_ipc_call(
    thread_t *to_th, msg_tag_t in_tag, msg_tag_t *ret_tag, ipc_timeout_t timout,
    umword_t *ret_user_id, bool_t is_call)
{
    int ret = -EINVAL;
    if (is_call)
    {
        assert(is_call && ret_tag);
    }
    thread_t *cur_th = thread_get_current();
    thread_t *recv_kobj = to_th;
    mword_t lock_stats2;

#if THREAD_IS_DEBUG
    dbg_printk(TAG "%s:%d ipc call: %s[0x%x]-->%s[0x%x]\n", __func__, __LINE__,
               kobject_get_name(&cur_th->kobj), cur_th,
               kobject_get_name(&recv_kobj->kobj), recv_kobj);
#endif
    lock_stats2 = spinlock_lock(&cur_th->send_lock);
again:
    ret = thread_wait_recv_thread(recv_kobj, timout); //!< 进入接收状态
    if (ret < 0)
    {
        goto end;
    }
    // 下面开始数据接收的流程
    if (thread_get_status(recv_kobj) == THREAD_SUSPEND && thread_get_ipc_state(recv_kobj) == THREAD_RECV)
    {
        //!< 开始发送数据
        ret = ipc_data_copy(recv_kobj, cur_th, in_tag, FALSE); //!< 拷贝数据
        if (ret < 0)
        {
            //!< 拷贝失败
            goto end;
        }
#if THREAD_IS_DEBUG
        dbg_printk(TAG "%s:%d ipc send data success: %s[0x%x]-->%s[0x%x]\n", __func__,
                   __LINE__, kobject_get_name(&cur_th->kobj), cur_th,
                   kobject_get_name(&recv_kobj->kobj), recv_kobj);
#endif
        if (is_call)
        {
            if (recv_kobj->ipc_kobj)
            {
                // 绑定回复的ipc到当前的线程
                assert(ipc_bind(((ipc_t *)(recv_kobj->ipc_kobj)), -1, 0, cur_th) >= 0);
                ref_counter_dec_and_release(&((ipc_t *)(recv_kobj->ipc_kobj))->ref,
                                            recv_kobj->ipc_kobj);
                recv_kobj->ipc_kobj = NULL;
                recv_kobj->last_send_th = NULL;
            }
            else
            {
                ref_counter_inc(&cur_th->ref);    //!< 作为发送者增加一次引用
                recv_kobj->last_send_th = cur_th; //!< 设置接收者的上一次发送者是谁
            }

            ret = thread_ipc_recv(ret_tag, timout, ret_user_id, NULL,
                                  recv_kobj); //!< 当前线程进行接收
            if (ret < 0)
            {
                //!< 接收超时
                goto end;
            }
        }
        else
        {
            thread_timeout_del_recv_remote(recv_kobj, TRUE);
#if THREAD_IS_DEBUG
            dbg_printk(TAG "%s:%d ipc call wake: %s[0x%x]\n", __func__, __LINE__,
                       kobject_get_name(&recv_kobj->kobj), recv_kobj);
#endif
        }
        preemption();
    }
    else
    {
        printk("recv_kobj->status:%d, recv_kobj->ipc_status:%d", recv_kobj->status,
               recv_kobj->ipc_status);
        assert(0);
        // goto again;
    }
    ret = 0;
end:
    spinlock_set(&cur_th->send_lock, lock_stats2);
#if THREAD_IS_DEBUG
    dbg_printk(TAG "%s:%d ipc call done: %s[0x%x]-->%s[0x%x]\n", __func__, __LINE__,
               kobject_get_name(&cur_th->kobj), cur_th,
               kobject_get_name(&recv_kobj->kobj), recv_kobj);
#endif
    return ret;
}
#endif
/**
 *  快速ipc call
 * FIXME:以下代码是arch相关的，需要整理
 **/
msg_tag_t thread_fast_ipc_call(task_t *to_task, entry_frame_t *f, umword_t user_id)
{
    task_t *cur_task = thread_get_current_task();
    thread_t *cur_th = thread_get_current();
    msg_tag_t in_tag = msg_tag_init(f->regs[0]);
    int ret;
    // 1.需要切换的资源有r9，task，和用户栈
    // 2.在对方进程中被杀死，需要还原当前线程的状态，并返回一个错误
    // 3.多线程访问时，服务端提供一个小的用户线程栈，然后内核到用户部分为临界区域，在服务端重新分配用户栈用，使用新的用户栈。
    // 4.fastipc嵌套访问会有问题，内核必须要提供一个软件上的调用栈。
    // 在嵌套调用时，如果在其它进程中挂掉，如果是当前线程则需要还原
    // 回收ipc线程注意事项：
    // 1.ipc的线程在与其它进程通信时在其它进程中死亡（这个最常见）
    // 2.ipc的线程在其它进程通信时其它进程死亡（需要吧其它进程的ipc线程给还原回去）
    // 3.ipc的线程在与其他的进程通信时，ipc线程的原进程死亡（需要推迟ipc线程的删除到ipc操作完成，否者可能发生未知的错误）

    if (to_task->notify_point == NULL)
    {
        printk("task:0x%x, notify point is not set.\n", to_task);
        return msg_tag_init4(0, 0, 0, -EIO);
    }
    sema_down(&to_task->notify_sema, 0);
    mutex_lock(&to_task->nofity_lock, 0);
    umword_t cpu_status = cpulock_lock();
    assert(cur_th->magic == THREAD_MAGIC);

    ref_counter_inc((&to_task->ref_cn));
    //!< 执行目标线程时用的是当前线程的资源，这里还需要备份当前线程的上下文。
    ret = thread_fast_ipc_save(cur_th, to_task, (void *)(to_task->nofity_stack - 4 * 8 /*FIXME:改成宏*/)); //!< 备份栈和usp
    if (ret >= 0)
    {
        ipc_msg_t *dst_ipc = (void *)to_task->nofity_msg_buf;
        ipc_msg_t *src_ipc = (void *)cur_th->msg.msg;
        ret = ipc_dat_copy_raw(&to_task->obj_space, &cur_task->obj_space, to_task->lim,
                               dst_ipc, src_ipc, in_tag, FALSE);
        if (ret >= 0)
        {
            dst_ipc->user[2] = task_pid_get(cur_task);                            // 设置pid
            slist_add(&to_task->nofity_theads_head, &cur_th->com->fast_ipc_node); // 添加到链表中，用于进程关闭时进行释放
            pf_s_t *usr_stask_point = (void *)arch_get_user_sp();

            if (thread_is_knl(cur_th))
            {
                // 如果是内核线程则全部重新设置
                thread_set_user_pf_noset_knl_sp(cur_th, to_task->notify_point,
                                                (void *)to_task->nofity_stack, (void *)to_task->mm_space.mm_block);
                usr_stask_point->rg0[0] = in_tag.raw;
                usr_stask_point->rg0[1] = user_id;
                usr_stask_point->rg0[2] = f->regs[2];
                usr_stask_point->rg0[3] = f->regs[3];

                scheduler_get_current()->sched_reset = 2;
            }
            else
            {
                usr_stask_point->r12 = 0x12121212;
                usr_stask_point->xpsr = 0x01000000L;
                usr_stask_point->lr = (umword_t)NULL; //!< 线程退出时调用的函数
                usr_stask_point->pc = (umword_t)(to_task->notify_point) | 0x1;

                //! 获得内核栈栈顶
                pf_t *cur_pf = ((pf_t *)((char *)cur_th + CONFIG_THREAD_BLOCK_SIZE + 8)) - 1;
                // 重新设置r9寄存器
                cur_pf->regs[5] = (umword_t)(to_task->mm_space.mm_block);
                cur_th->sp.user_sp = cur_pf;

                //! 寄存器传参数
                f->regs[0] = in_tag.raw;
                f->regs[1] = user_id;
                f->regs[2] = f->regs[2];
                f->regs[3] = f->regs[3];
            }
            // 切换mpu
            ref_counter_inc(&cur_th->ref);
            mpu_switch_to_task(to_task);
            cpulock_set(cpu_status);
            if (thread_is_knl(cur_th))
            {
                // 内核线程则立刻进行调度
                arch_to_sche();
                preemption();
            }
            return in_tag;
        }
        else
        {
            ref_counter_dec_and_release(&to_task->ref_cn, &to_task->kobj);
            cpulock_set(cpu_status);
            mutex_unlock(&to_task->nofity_lock);
            sema_up(&to_task->notify_sema);
        }
    }
    else
    {
        ref_counter_dec_and_release(&to_task->ref_cn, &to_task->kobj);
        cpulock_set(cpu_status);
        mutex_unlock(&to_task->nofity_lock);
        sema_up(&to_task->notify_sema);
    }
   
    return msg_tag_init4(0, 0, 0, ret);
}
msg_tag_t thread_fast_ipc_replay(entry_frame_t *f)
{
    task_t *cur_task = thread_get_current_task();
    thread_t *cur_th = thread_get_current();
    msg_tag_t in_tag = msg_tag_init(f->regs[0]);
    task_t *old_task = thread_get_bind_task(cur_th);
    int ret;

    assert(cur_th->magic == THREAD_MAGIC);
    *(cur_task->nofity_bitmap) &= ~(1 << MIN(f->regs[2], cur_task->nofity_bitmap_len)); //!< 解锁bitmap
    slist_del(&cur_th->com->fast_ipc_node);                                             // 从链表中删除

    ret = thread_fast_ipc_restore(cur_th); // 还原栈和usp
    if (ret < 0)
    {
        mutex_unlock(&old_task->nofity_lock);
        in_tag =  msg_tag_init4(0, 0, 0, ret);
        goto end;
    }
    umword_t cpu_status = cpulock_lock();

    cur_task = thread_get_current_task();
    ipc_msg_t *dst_ipc = (void *)cur_th->msg.msg;
    ipc_msg_t *src_ipc = (void *)old_task->nofity_msg_buf;
    ret = ipc_dat_copy_raw(&cur_task->obj_space, &old_task->obj_space, cur_task->lim,
                           dst_ipc, src_ipc, in_tag, TRUE); // copy数据
    // if (ret >=0 ) {
    for (int i = 0; i < CONFIG_THREAD_MAP_BUF_LEN; i++)
    {
        if (i < ret)
        {
            src_ipc->map_buf[i] = old_task->nofity_map_buf[i];
            old_task->nofity_map_buf[i] = 0;
        }
        else
        {
            src_ipc->map_buf[i] = old_task->nofity_map_buf[i];
        }
    }
    // }
    mutex_unlock(&old_task->nofity_lock);
    if (thread_is_knl(cur_th))
    {
        //! 吧r4-r11留出来
        cur_th->sp.user_sp = 0x0;
        cur_th->sp.sp_type = 0xfffffff9;
        scheduler_get_current()->sched_reset = 3;
    }
    else
    {
        pf_t *cur_pf = ((pf_t *)((char *)cur_th + CONFIG_THREAD_BLOCK_SIZE + 8)) - 1;

        cur_pf->regs[5] = (umword_t)(cur_task->mm_space.mm_block); // 更新r9寄存器
    }
    mpu_switch_to_task(cur_task); // 切换mpu
    ref_counter_dec_and_release(&old_task->ref_cn, &old_task->kobj);
    if (ret < 0)
    {
        in_tag = msg_tag_init4(0, 0, 0, ret);
    }
    cpulock_set(cpu_status);
    sema_up(&old_task->notify_sema);
    if (thread_is_knl(cur_th))
    {
        arch_to_sche();
        preemption();
    }
end:
    if (thread_get_ipc_state(cur_th) == THREAD_IPC_ABORT && stack_len(&cur_th->com->fast_ipc_stack)==0)
    {
        /*FIXME:这里面没有释放线程的内存*/
        cpu_status = cpulock_lock();
        thread_unbind(cur_th);
        thread_suspend(cur_th);
        thread_knl_release_helper(cur_th);
        cpulock_set(cpu_status);
    } else {
        ref_counter_dec_and_release(&cur_th->ref, &cur_th->kobj);
    }
    return in_tag;
}
/**
 * @brief 执行ipc
 *
 * @param kobj
 * @param in_tag
 * @param f
 * @return int
 */
msg_tag_t thread_do_ipc(kobject_t *kobj, entry_frame_t *f, umword_t user_id)
{
    assert(kobj);
    task_t *cur_task = thread_get_current_task();
    thread_t *cur_th = thread_get_current();
    task_t *to_tk = (task_t *)kobj;
    umword_t ipc_type = f->regs[1];
    obj_handler_t th_hd = 0;
    int ret = -EINVAL;

    switch (ipc_type)
    {
    case IPC_FAST_REPLAY:
    {
        return thread_fast_ipc_replay(f);
    }
    break;
    case IPC_FAST_CALL:
    {
        return thread_fast_ipc_call(to_tk, f, user_id);
    }
    break;
    default:
        ret = -ENOSYS;
        break;
    }

    return msg_tag_init4(0, 0, 0, ret);
}
#if IS_ENABLED(CONFIG_SMP)
static int thread_remote_migration(ipi_msg_t *msg, bool_t *is_sched)
{
    thread_t *th = (thread_t *)msg->msg;
    umword_t tagcpu = msg->msg2;
    int cur_cpu = arch_get_current_cpu_id();
    assert(th);
    assert(tagcpu == cur_cpu);
    assert(th->cpu != cur_cpu);

    // 在迁移之前必须在之前的核中已经挂起该线程
    assert(!slist_in_list(&th->sche.node));
    assert(th->cpu != cur_cpu);

    assert(th->status == THREAD_SUSPEND || th->status == THREAD_IDLE);
    assert(th->magic == THREAD_MAGIC);

    th->cpu = cur_cpu;
    *is_sched = FALSE;
    // 在新的核上调度
    thread_ready(th, TRUE);
    return 0;
}

#endif
int thread_set_prio(thread_t *th, int prio)
{
    assert(cpulock_get_status());
    int old_prio = thread_get_prio(th);

    if (old_prio != prio)
    {
        if (thread_get_status(th) == THREAD_READY)
        {
            thread_suspend(th);
            th->sche.prio = prio;
            thread_ready(th, TRUE);
        } else {
            th->sche.prio = prio;
        }
    }
    return old_prio;
}
static void thread_syscall(kobject_t *kobj, syscall_prot_t sys_p,
                           msg_tag_t in_tag, entry_frame_t *f)
{
    msg_tag_t tag = msg_tag_init4(0, 0, 0, -EINVAL);
    task_t *task = thread_get_current_task();
    thread_t *tag_th = container_of(kobj, thread_t, kobj);
    thread_t *cur_th = thread_get_current();

    if (sys_p.prot != THREAD_PROT)
    {
        f->regs[0] = msg_tag_init4(0, 0, 0, -EPROTO).raw;
        return;
    }

    switch (sys_p.op)
    {
    case SET_EXEC_REGS:
    {
        thread_set_exc_regs(tag_th, f->regs[1], f->regs[2], f->regs[3]);
        tag = msg_tag_init4(0, 0, 0, 0);
    }
    break;
    case MSG_BUG_SET:
    {
        task_t *tag_tk = thread_get_bind_task(tag_th);

        if (is_rw_access(tag_tk, (void *)(f->regs[1]), THREAD_MSG_BUG_LEN,
                         FALSE))
        {
            void *kmsg = (void *)task_get_paddr(tag_tk, f->regs[1]);

            if (kmsg)
            {
#if IS_ENABLED(CONFIG_MMU)
                thread_set_msg_buf(tag_th, kmsg, (void *)(f->regs[1]));
#else
                thread_set_msg_buf(tag_th, (void *)(f->regs[1]),
                                   (void *)(f->regs[1]));
#endif
                tag = msg_tag_init4(0, 0, 0, 0);
            }
            else
            {
                tag = msg_tag_init4(0, 0, 0, -EINVAL);
            }
        }
        else
        {
            //!< 内存不可访问
            tag = msg_tag_init4(0, 0, 0, -EACCES);
        }
    }
    case MSG_BUG_GET:
    {
        f->regs[1] = (umword_t)(thread_get_msg_buf(tag_th));
        f->regs[2] = THREAD_MSG_BUG_LEN;
        if (thread_get_msg_buf(tag_th) == NULL)
        {
            tag = msg_tag_init4(0, 0, 0, -EACCES);
        }
        else
        {
            tag = msg_tag_init4(0, 0, 0, 0);
        }
    }
    break;
    case RUN_THREAD:
    {
        task_t *tag_tsk = thread_get_bind_task(tag_th);
        if (tag_tsk == NULL)
        {
            tag = msg_tag_init4(0, 0, 0, -EACCES);
            break;
        }
        if (task_pid_get(tag_tsk) == -1)
        {
            //!< 只有设置了pid才能启动，pid只有init进程能够设置，这就使得只有pid能够启动应用程序
            tag = msg_tag_init4(0, 0, 0, -EACCES);
            break;
        }
        int cur_cpu = arch_get_current_cpu_id();
        mword_t tge_cpu = f->regs[2];
        int tge_prio = f->regs[1];
        umword_t status = cpulock_lock();

#if IS_ENABLED(CONFIG_SMP)
        if (tge_cpu >= CONFIG_CPU)
        {
            tge_cpu = cur_cpu;
        }
        if (tge_cpu < 0)
        {
            tge_cpu = cur_cpu;
        }
        // 刚刚创建的新线程直接运行
        if (tag_th->status == THREAD_NONE)
        {
            tag_th->sche.prio = (tge_prio >= PRIO_MAX ? PRIO_MAX - 1 : tge_prio);
            tag_th->cpu = tge_cpu;
            thread_ready_remote(tag_th, TRUE);
            goto run_thread_end;
        }

        if (tge_cpu == cur_cpu)
        {
            // 就在当前核，则直接修改优先级
            if (tag_th == cur_th)
            {
                thread_suspend_sw(tag_th, FALSE);
            }
            else
            {
                thread_suspend(tag_th);
            }
            tag_th->sche.prio =
                (tge_prio >= PRIO_MAX ? PRIO_MAX - 1 : tge_prio);
            thread_ready(tag_th, TRUE);
            goto run_thread_end;
        }
        if (tag_th != cur_th)
        {
            thread_suspend_remote(tag_th, TRUE);
        }
        tag_th->sche.prio = (tge_prio >= PRIO_MAX ? PRIO_MAX - 1 : tge_prio);
        tag_th->ipi_msg_node.msg = (umword_t)tag_th;
        tag_th->ipi_msg_node.msg2 = tge_cpu;
        tag_th->ipi_msg_node.msg3 = tge_prio;
        tag_th->ipi_msg_node.cb = thread_remote_migration;
        cpu_ipi_to_msg(1 << tge_cpu, &cur_th->ipi_msg_node, IPI_CALL);
        assert(tag_th->cpu == tge_cpu);
#else
        if (!slist_in_list(&tag_th->sche.node))
        {
            tag_th->sche.prio = tge_prio;
            thread_ready(tag_th, TRUE);
        }
        else
        {
            thread_suspend(tag_th);
            if (tag_th != thread_get_current())
            {
                preemption();
            }
            tag_th->sche.prio =
                (tge_prio >= PRIO_MAX ? PRIO_MAX - 1 : tge_prio);
            thread_ready(tag_th, TRUE);
        }
        goto run_thread_end;
#endif
    run_thread_end:
        cpulock_set(status);
        tag = msg_tag_init4(0, 0, 0, 0);
    }
    break;
    case BIND_TASK:
    {
        kobject_t *task_kobj = obj_space_lookup_kobj_cmp_type(
            &task->obj_space, f->regs[1], TASK_TYPE);
        if (task_kobj == NULL)
        {
            f->regs[0] = msg_tag_init4(0, 0, 0, -ENOENT).raw;
            return;
        }
        thread_bind(tag_th, task_kobj);
        tag = msg_tag_init4(0, 0, 0, 0);
        // printk("thread bind to %d\n", f->regs[1]);
    }
    break;
    case YIELD:
    {
        thread_sched(TRUE);
        // arch_to_sche();
        tag = msg_tag_init4(0, 0, 0, 0);
    }
    break;
    case DO_IPC:
    {
        tag = thread_do_ipc(&thread_get_task(container_of(kobj, thread_t, kobj))->kobj, f, 0);
    }
    break;
    case SET_EXEC:
    {
        kobject_t *th_kobj = obj_space_lookup_kobj_cmp_type(
            &task->obj_space, f->regs[0], THREAD_TYPE);
        if (th_kobj == NULL)
        {
            f->regs[0] = msg_tag_init4(0, 0, 0, -EINVAL).raw;
            return;
        }
        ref_counter_inc(&((thread_t *)th_kobj)->ref);
        task->exec_th = th_kobj;
        tag = msg_tag_init4(0, 0, 0, 0);
    }
    break;
    case SLEEP:
    {
        int ret;
        umword_t status;

        status = cpulock_lock();
        ret = thread_sleep(f->regs[0]);
        cpulock_set(status);
        tag = msg_tag_init4(0, 0, 0, ret);
    }
    break;
    }
    f->regs[0] = tag.raw;
}

/**
 * @brief 该函数创建一个工厂对象
 *
 * @param lim
 * @param arg0
 * @param arg1
 * @param arg2
 * @param arg3
 * @return kobject_t*
 */
static kobject_t *thread_create_func(ram_limit_t *lim, umword_t arg0,
                                     umword_t arg1, umword_t arg2,
                                     umword_t arg3)
{
    kobject_t *kobj;

    kobj = (kobject_t *)thread_create(lim, arg0);
    if (!kobj)
    {
        return NULL;
    }
    return kobj;
}

/**
 * @brief 工厂注册函数
 *
 */
static void thread_factory_register(void)
{
    factory_register(thread_create_func, THREAD_PROT);
}
INIT_KOBJ(thread_factory_register);
/**
 * @brief 获取当前的task
 *
 * @return task_t*
 */
task_t *thread_get_current_task(void)
{
    thread_t *cur = thread_get_current();
    kobject_t *kobj = cur->task;

    if (!kobj)
    {
        return NULL;
    }
    return container_of(kobj, task_t, kobj);
}
task_t *thread_get_task(thread_t *th)
{
    return container_of(th->task, task_t, kobj);
}