720 lines
17 KiB
C
720 lines
17 KiB
C
/**
|
||
* @file futex.c
|
||
* @author ATShining (1358745329@qq.com)
|
||
* @brief futex在内核中实现
|
||
* @note TODO: 可以使用hashmap优化
|
||
* @version 0.1
|
||
* @date 2023-11-20
|
||
*
|
||
* @copyright Copyright (c) 2023
|
||
*
|
||
*/
|
||
#include "types.h"
|
||
#include "init.h"
|
||
#include "prot.h"
|
||
#include "kobject.h"
|
||
#include "factory.h"
|
||
#include "task.h"
|
||
#include "thread.h"
|
||
#include "assert.h"
|
||
#include "slist.h"
|
||
#include "spinlock.h"
|
||
#include "globals.h"
|
||
#include "string.h"
|
||
#include "ipc.h"
|
||
#include "err.h"
|
||
#include "slist.h"
|
||
#include "access.h"
|
||
#include "limits.h"
|
||
#include "futex.h"
|
||
#include "thread_arch.h"
|
||
#include <pre_cpu.h>
|
||
/**
|
||
* @brief 以下是futex的操作码
|
||
*
|
||
*/
|
||
#define FUTEX_WAIT 0
|
||
#define FUTEX_WAKE 1
|
||
#define FUTEX_FD 2
|
||
#define FUTEX_REQUEUE 3
|
||
#define FUTEX_CMP_REQUEUE 4
|
||
#define FUTEX_WAKE_OP 5
|
||
#define FUTEX_LOCK_PI 6
|
||
#define FUTEX_UNLOCK_PI 7
|
||
#define FUTEX_TRYLOCK_PI 8
|
||
#define FUTEX_WAIT_BITSET 9
|
||
#define FUTEX_WAKE_CLEAR 10
|
||
#define FUTEX_WAITERS 0x80000000
|
||
|
||
/**
|
||
* @brief futex对象的操作码
|
||
*
|
||
*/
|
||
enum futex_op
|
||
{
|
||
FUTEX_CTRL, //!< futex的控制
|
||
};
|
||
|
||
struct timespec
|
||
{
|
||
time_t tv_sec; /* seconds */
|
||
long tv_nsec; /* nanoseconds */
|
||
};
|
||
/**
|
||
* @brief 存储锁信息
|
||
*
|
||
*/
|
||
typedef struct futex_lock
|
||
{
|
||
uint32_t *uaddr; //!< 锁的地址
|
||
slist_head_t thread_list_head; //!< 存储线程的头节点
|
||
size_t cnt; //!< 有多少个线程在等待锁
|
||
} futex_lock_t;
|
||
|
||
/**
|
||
* @brief futex的对象定义
|
||
*
|
||
*/
|
||
typedef struct futex
|
||
{
|
||
kobject_t kobj;
|
||
futex_lock_t fl_list[CONFIG_FT_ADDR_NR]; //!< 存储加锁的地址
|
||
} futex_t;
|
||
|
||
static futex_t futex_obj; //!< 全局的futex对象
|
||
static void futex_init(futex_t *ft);
|
||
/**
|
||
* @brief futex的等待的item
|
||
*
|
||
*/
|
||
typedef struct futex_wait_item
|
||
{
|
||
slist_head_t node;
|
||
thread_t *th;
|
||
mword_t sleep_times;
|
||
} futex_wait_item_t;
|
||
|
||
static PER_CPU(slist_head_t, wait_list); //!< futex的等待队列
|
||
|
||
/**
|
||
* @brief 初始化一个超时等待队列
|
||
*
|
||
*/
|
||
static void futex_wait_list_init(void)
|
||
{
|
||
for (int i = 0; i < CONFIG_CPU; i++)
|
||
{
|
||
slist_init(pre_cpu_get_var_cpu(i, &wait_list));
|
||
}
|
||
}
|
||
INIT_KOBJ(futex_wait_list_init);
|
||
/**
|
||
* @brief 检查超时队列
|
||
*
|
||
*/
|
||
void futex_timeout_times_tick(void)
|
||
{
|
||
futex_wait_item_t *item;
|
||
|
||
slist_foreach_not_next(item,
|
||
(slist_head_t *)pre_cpu_get_current_cpu_var(&wait_list),
|
||
node) //!< 第一次循环等待的ipc
|
||
{
|
||
futex_wait_item_t *next = slist_next_entry(item,
|
||
(slist_head_t *)pre_cpu_get_current_cpu_var(&wait_list),
|
||
node);
|
||
if (item->sleep_times > 0)
|
||
{
|
||
if ((--item->sleep_times) == 0)
|
||
{
|
||
slist_del(&item->node);
|
||
//!< 超时时间满后直接唤醒等待者
|
||
thread_ready_remote(item->th, TRUE);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
slist_del(&item->node);
|
||
thread_ready_remote(item->th, TRUE);
|
||
}
|
||
item = next;
|
||
}
|
||
}
|
||
/**
|
||
* @brief 初始化全局的futex并注册
|
||
*
|
||
*/
|
||
static void futex_reg(void)
|
||
{
|
||
futex_init(&futex_obj);
|
||
global_reg_kobj(&futex_obj.kobj, FUTEX_PROT);
|
||
}
|
||
INIT_KOBJ(futex_reg);
|
||
/**
|
||
* @brief 查找futex中指定线程是否存在
|
||
*
|
||
* @param flt futex_lock_t对象
|
||
* @param thread_hd 线程的指针
|
||
* @return bool_t TRUE：存在 FALSE：不存在
|
||
*/
|
||
static bool_t futex_find_thread(futex_lock_t *flt, thread_t *thread_hd)
|
||
{
|
||
thread_t *pos;
|
||
|
||
slist_foreach(pos, &flt->thread_list_head, futex_node)
|
||
{
|
||
if (pos == thread_hd)
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
/**
|
||
* @brief futex进队
|
||
*
|
||
* @param flt
|
||
* @param th
|
||
*/
|
||
static void futex_enqueue(futex_lock_t *flt, thread_t *th)
|
||
{
|
||
slist_add_append(&flt->thread_list_head, &th->futex_node);
|
||
flt->cnt++;
|
||
}
|
||
/**
|
||
* @brief futex出队
|
||
*
|
||
* @param flt
|
||
* @param th
|
||
* @return int
|
||
*/
|
||
static int futex_dequeue(futex_lock_t *flt, thread_t **th)
|
||
{
|
||
assert(th);
|
||
if (slist_is_empty(&flt->thread_list_head))
|
||
{
|
||
return -1;
|
||
}
|
||
slist_head_t *first = slist_first(&flt->thread_list_head);
|
||
slist_del(first);
|
||
flt->cnt--;
|
||
*th = container_of(first, thread_t, futex_node);
|
||
|
||
return 0;
|
||
}
|
||
/**
|
||
* @brief 获取futex的锁有多少个线程在等待
|
||
*
|
||
* @param flt
|
||
* @return size_t
|
||
*/
|
||
static size_t futex_cnt(futex_lock_t *flt)
|
||
{
|
||
return flt->cnt;
|
||
}
|
||
/**
|
||
* @brief 查找一个地址，如果已经有了，则加入等待，否则增加一个信息，并加入等待
|
||
*
|
||
* @param ft
|
||
* @param uaddr
|
||
* @param hd
|
||
* @return futex_lock_t*
|
||
*/
|
||
static futex_lock_t *futex_set_addr(futex_t *ft, void *uaddr, thread_t *hd)
|
||
{
|
||
int empty_inx = -1;
|
||
|
||
for (int i = 0; i < CONFIG_FT_ADDR_NR; i++)
|
||
{
|
||
if (ft->fl_list[i].uaddr == uaddr)
|
||
{
|
||
if (!futex_find_thread(&ft->fl_list[i], hd))
|
||
{
|
||
futex_enqueue(&ft->fl_list[i], hd);
|
||
}
|
||
return &ft->fl_list[i];
|
||
}
|
||
else if (ft->fl_list[i].uaddr == NULL)
|
||
{
|
||
empty_inx = i;
|
||
}
|
||
}
|
||
if (empty_inx != -1)
|
||
{
|
||
ft->fl_list[empty_inx].uaddr = uaddr;
|
||
futex_enqueue(&ft->fl_list[empty_inx], hd);
|
||
return &ft->fl_list[empty_inx];
|
||
}
|
||
return NULL;
|
||
}
|
||
/**
|
||
* @brief 找到指定地址的锁结构体
|
||
*
|
||
* @param fst
|
||
* @param uaddr
|
||
* @return futex_lock_t*
|
||
*/
|
||
static futex_lock_t *futex_find(futex_t *fst, void *uaddr)
|
||
{
|
||
for (int i = 0; i < CONFIG_FT_ADDR_NR; i++)
|
||
{
|
||
if (fst->fl_list[i].uaddr == uaddr)
|
||
{
|
||
return &fst->fl_list[i];
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
static int futex_wake(futex_t *fst, uint32_t *uaddr, int val)
|
||
{
|
||
mword_t status;
|
||
int rel_cnt = 0;
|
||
uint32_t *paddr;
|
||
|
||
status = spinlock_lock(&fst->kobj.lock);
|
||
paddr = (uint32_t *)task_get_currnt_paddr((vaddr_t)uaddr);
|
||
if (paddr == 0)
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
// printk("%s:%d uaddr: 0x%lx paddr: 0x%lx\n", __func__, __LINE__, uaddr, paddr);
|
||
futex_lock_t *flt = futex_find(fst, paddr);
|
||
|
||
if (flt)
|
||
{
|
||
rel_cnt = val = INT_MAX ? futex_cnt(flt) : val;
|
||
|
||
for (int i = 0; i < rel_cnt; i++)
|
||
{
|
||
thread_t *th;
|
||
int ret = futex_dequeue(flt, (&th));
|
||
|
||
if (ret == 0)
|
||
{
|
||
if (futex_cnt(flt) == 0)
|
||
{
|
||
flt->uaddr = 0;
|
||
}
|
||
thread_ready_remote(th, TRUE);
|
||
}
|
||
}
|
||
}
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
|
||
return rel_cnt;
|
||
}
|
||
static int futex_wait(thread_t *cur_th, futex_t *fst, uint32_t *uaddr, int val, umword_t timeout)
|
||
{
|
||
umword_t status;
|
||
uint32_t *p_addr;
|
||
|
||
status = spinlock_lock(&fst->kobj.lock);
|
||
if (!is_rw_access(thread_get_bind_task(cur_th), uaddr, sizeof(*uaddr), FALSE))
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
p_addr = (uint32_t *)task_get_currnt_paddr((vaddr_t)uaddr);
|
||
if (p_addr == 0)
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
// printk("%s:%d uaddr: 0x%lx paddr: 0x%lx\n", __func__, __LINE__, uaddr, p_addr);
|
||
if (val == *p_addr) //!< 检查值是否时期望值
|
||
{
|
||
ref_counter_inc(&cur_th->ref); //!< 指定线程引用计数+1
|
||
if (futex_set_addr(fst, p_addr, cur_th) == NULL)
|
||
{
|
||
ref_counter_dec_and_release(&cur_th->ref, &cur_th->kobj);
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -ENOMEM;
|
||
}
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
if (timeout != 0)
|
||
{
|
||
//! 加入到等待队列中
|
||
futex_wait_item_t item = {
|
||
.th = cur_th,
|
||
.sleep_times = timeout,
|
||
};
|
||
|
||
slist_init(&item.node);
|
||
slist_add_append((slist_head_t *)pre_cpu_get_current_cpu_var(&wait_list), &item.node);
|
||
thread_suspend(cur_th);
|
||
preemption();
|
||
if (item.sleep_times <= 0)
|
||
{
|
||
ref_counter_dec_and_release(&cur_th->ref, &cur_th->kobj);
|
||
// spinlock_set(&fst->kobj.lock, status);
|
||
return -ETIMEDOUT;
|
||
}
|
||
if (cur_th->ipc_status == THREAD_IPC_ABORT)
|
||
{
|
||
cur_th->ipc_status = THREAD_NONE;
|
||
// spinlock_set(&fst->kobj.lock, status);
|
||
return 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 一直等待
|
||
thread_suspend(cur_th);
|
||
preemption();
|
||
if (cur_th->ipc_status == THREAD_IPC_ABORT)
|
||
{
|
||
cur_th->ipc_status = THREAD_NONE;
|
||
// spinlock_set(&fst->kobj.lock, status);
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
ref_counter_dec_and_release(&cur_th->ref, &cur_th->kobj);
|
||
}
|
||
else
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EAGAIN;
|
||
}
|
||
return 0;
|
||
}
|
||
static int futex_wake_clear(thread_t *cur_th, futex_t *fst, uint32_t *uaddr, int val)
|
||
{
|
||
mword_t status;
|
||
uint32_t *paddr;
|
||
status = spinlock_lock(&fst->kobj.lock);
|
||
|
||
paddr = (uint32_t *)task_get_currnt_paddr((vaddr_t)uaddr);
|
||
if (paddr == 0)
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
if (!is_rw_access(thread_get_bind_task(cur_th), paddr, sizeof(*paddr), FALSE))
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
futex_lock_t *flt = futex_find(fst, paddr);
|
||
int rel_cnt = 0;
|
||
|
||
if (flt)
|
||
{
|
||
rel_cnt = val = INT_MAX ? futex_cnt(flt) : val;
|
||
|
||
for (int i = 0; i < rel_cnt; i++)
|
||
{
|
||
thread_t *th;
|
||
int ret = futex_dequeue(flt, (&th));
|
||
|
||
if (ret == 0)
|
||
{
|
||
if (futex_cnt(flt) == 0)
|
||
{
|
||
flt->uaddr = 0;
|
||
}
|
||
thread_ready_remote(th, TRUE);
|
||
}
|
||
}
|
||
}
|
||
*paddr = 0;
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return 0;
|
||
}
|
||
static int futex_requeue(thread_t *cur_th, futex_t *fst,
|
||
uint32_t *uaddr, uint32_t *uaddr2, int val, int val3)
|
||
{
|
||
mword_t status;
|
||
uint32_t *paddr;
|
||
uint32_t *paddr2;
|
||
|
||
status = spinlock_lock(&fst->kobj.lock);
|
||
if (!is_rw_access(thread_get_bind_task(cur_th), uaddr, sizeof(*uaddr), FALSE))
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
paddr = (uint32_t *)task_get_currnt_paddr((vaddr_t)uaddr);
|
||
if (paddr == 0)
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
paddr2 = (uint32_t *)task_get_currnt_paddr((vaddr_t)uaddr2);
|
||
if (paddr2 == 0)
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
if (val3 == *paddr)
|
||
{
|
||
futex_lock_t *flt = futex_find(fst, paddr);
|
||
int rel_cnt = 0;
|
||
int wake_cnt = 0;
|
||
|
||
if (flt)
|
||
{
|
||
wake_cnt = val = INT_MAX ? futex_cnt(flt) : val;
|
||
|
||
for (int i = 0; i < wake_cnt; i++)
|
||
{
|
||
thread_t *th;
|
||
int ret = futex_dequeue(flt, &th);
|
||
|
||
if (ret != 0)
|
||
{
|
||
continue;
|
||
}
|
||
if (futex_cnt(flt) == 0)
|
||
{
|
||
flt->uaddr = 0;
|
||
}
|
||
thread_ready_remote(th, TRUE);
|
||
}
|
||
if (futex_cnt(flt) <= 0)
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return wake_cnt;
|
||
}
|
||
int requeue_cn = futex_cnt(flt);
|
||
rel_cnt = requeue_cn;
|
||
for (int i = 0; i < rel_cnt; i++)
|
||
{
|
||
thread_t *th;
|
||
int ret = futex_dequeue(flt, &th);
|
||
|
||
if (ret != 0)
|
||
{
|
||
continue;
|
||
}
|
||
if (futex_cnt(flt) == 0)
|
||
{
|
||
flt->uaddr = 0;
|
||
}
|
||
futex_set_addr(fst, (void *)paddr2, th);
|
||
}
|
||
}
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return wake_cnt;
|
||
}
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return 0;
|
||
}
|
||
static int futex_lock_pi(thread_t *cur_th, futex_t *fst, uint32_t *uaddr, uint32_t tid)
|
||
{
|
||
mword_t status;
|
||
uint32_t *paddr;
|
||
|
||
status = spinlock_lock(&fst->kobj.lock);
|
||
if (!is_rw_access(thread_get_bind_task(cur_th), uaddr, sizeof(*uaddr), FALSE))
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
paddr = (uint32_t *)task_get_currnt_paddr((vaddr_t)uaddr);
|
||
if (paddr == 0)
|
||
{
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return -EACCES;
|
||
}
|
||
if ((*paddr) == 0)
|
||
{
|
||
*paddr = tid;
|
||
}
|
||
else
|
||
{
|
||
*paddr |= FUTEX_WAITERS;
|
||
}
|
||
spinlock_set(&fst->kobj.lock, status);
|
||
return 0;
|
||
}
|
||
/**
|
||
* @brief futex的处理函数
|
||
*
|
||
* @param fst
|
||
* @param uaddr
|
||
* @param futex_op
|
||
* @param val
|
||
* @param timeout
|
||
* @param uaddr2
|
||
* @param val3
|
||
* @param tid
|
||
* @return int
|
||
*/
|
||
static int futex_dispose(futex_t *fst, uint32_t *uaddr, int futex_op, uint32_t val,
|
||
umword_t timeout /*val2*/, umword_t uaddr2, uint32_t val3, int tid)
|
||
|
||
{
|
||
thread_t *cur_th = thread_get_current();
|
||
umword_t status;
|
||
int ret = 0;
|
||
|
||
futex_op = futex_op & 0x7f;
|
||
|
||
switch (futex_op)
|
||
{
|
||
case FUTEX_REQUEUE:
|
||
{
|
||
ret = futex_requeue(cur_th, fst, uaddr, (void *)uaddr2, val, val3);
|
||
if (ret < 0)
|
||
{
|
||
return ret;
|
||
}
|
||
}
|
||
break;
|
||
case FUTEX_WAIT:
|
||
{
|
||
// printk("futex wait:0x%lx\n", uaddr);
|
||
ret = futex_wait(cur_th, fst, uaddr, val, timeout);
|
||
if (ret < 0)
|
||
{
|
||
return ret;
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
case FUTEX_WAKE:
|
||
{
|
||
int rel_cnt;
|
||
// printk("futex wake:0x%lx\n", uaddr);
|
||
rel_cnt = futex_wake(fst, uaddr, val);
|
||
return rel_cnt;
|
||
}
|
||
case FUTEX_UNLOCK_PI:
|
||
case FUTEX_WAKE_CLEAR:
|
||
{
|
||
int rel_cnt;
|
||
|
||
rel_cnt = futex_wake_clear(cur_th, fst, uaddr, val);
|
||
return rel_cnt;
|
||
}
|
||
case FUTEX_LOCK_PI:
|
||
{
|
||
ret = futex_lock_pi(cur_th, fst, uaddr, tid);
|
||
if (ret < 0)
|
||
{
|
||
return ret;
|
||
}
|
||
}
|
||
default:
|
||
return -ENOSYS;
|
||
}
|
||
return ret;
|
||
}
|
||
/**
|
||
* @brief futex的系统调用
|
||
*
|
||
* @param kobj
|
||
* @param sys_p
|
||
* @param in_tag
|
||
* @param f
|
||
*/
|
||
static void futex_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);
|
||
thread_t *th = thread_get_current();
|
||
futex_t *futex = container_of(kobj, futex_t, kobj);
|
||
ipc_msg_t *msg;
|
||
|
||
if (sys_p.prot != FUTEX_PROT)
|
||
{
|
||
f->regs[0] = msg_tag_init4(0, 0, 0, -EPROTO).raw;
|
||
return;
|
||
}
|
||
msg = thread_get_msg_buf(th);
|
||
if (msg == NULL)
|
||
{
|
||
f->regs[0] = msg_tag_init4(0, 0, 0, -ENOBUFS).raw;
|
||
return;
|
||
}
|
||
switch (sys_p.op)
|
||
{
|
||
case FUTEX_CTRL:
|
||
{
|
||
int ret;
|
||
umword_t *msg_buf = thread_get_kmsg_buf(th);
|
||
uint32_t *uaddr = (uint32_t *)(msg_buf[0]);
|
||
int futex_op = msg_buf[1];
|
||
uint32_t val = msg_buf[2];
|
||
umword_t timeout = msg_buf[3];
|
||
uint32_t uaddr2 = msg_buf[4];
|
||
uint32_t val3 = msg_buf[5];
|
||
int tid = msg_buf[6];
|
||
mword_t lock_status = cpulock_lock();
|
||
|
||
ret = futex_dispose(futex, uaddr, futex_op, val, timeout, uaddr2, val3, tid);
|
||
cpulock_set(lock_status);
|
||
tag = msg_tag_init4(0, 0, 0, ret);
|
||
}
|
||
break;
|
||
}
|
||
f->regs[0] = tag.raw;
|
||
}
|
||
/**
|
||
* @brief 在task结束时，需要删除某个task所关联的futex
|
||
*
|
||
* @param obj_space 需要操作的task的obj_space
|
||
* @param kobj 哪一个futex对象
|
||
*/
|
||
static void futex_unmap(obj_space_t *obj_space, kobject_t *kobj)
|
||
{
|
||
task_t *task = container_of(obj_space, task_t, obj_space);
|
||
futex_t *futex = container_of(kobj, futex_t, kobj);
|
||
printk("%s:%d\n", __func__, __LINE__);
|
||
|
||
umword_t status = spinlock_lock(&futex->kobj.lock);
|
||
for (int i = 0; i < CONFIG_FT_ADDR_NR; i++)
|
||
{
|
||
thread_t *pos;
|
||
|
||
if (futex->fl_list[i].uaddr)
|
||
{
|
||
slist_foreach_not_next(pos, &futex->fl_list[i].thread_list_head, futex_node)
|
||
{
|
||
thread_t *next = slist_next_entry(pos, &futex->fl_list[i].thread_list_head, futex_node);
|
||
task_t *bind_task = thread_get_bind_task(pos);
|
||
|
||
if (bind_task == task)
|
||
{
|
||
assert(pos->status == THREAD_SUSPEND);
|
||
slist_del(&pos->futex_node);
|
||
pos->status = THREAD_IPC_ABORT;
|
||
thread_ready_remote(pos, TRUE);
|
||
}
|
||
pos = next;
|
||
}
|
||
}
|
||
}
|
||
spinlock_set(&futex->kobj.lock, status);
|
||
}
|
||
static void futex_release_stage1(kobject_t *kobj)
|
||
{
|
||
}
|
||
static bool_t futex_release_put(kobject_t *kobj)
|
||
{
|
||
return FALSE;
|
||
}
|
||
static void futex_release_stage2(kobject_t *kobj)
|
||
{
|
||
printk("futex don't release.\n");
|
||
}
|
||
/**
|
||
* @brief 初始化futex对象
|
||
*
|
||
* @param ft
|
||
*/
|
||
static void futex_init(futex_t *ft)
|
||
{
|
||
kobject_init(&ft->kobj, FUTEX_TYPE);
|
||
for (int i = 0; i < CONFIG_FT_ADDR_NR; i++)
|
||
{
|
||
slist_init(&ft->fl_list[i].thread_list_head);
|
||
}
|
||
ft->kobj.invoke_func = futex_syscall;
|
||
ft->kobj.unmap_func = futex_unmap;
|
||
ft->kobj.stage_1_func = futex_release_stage1;
|
||
ft->kobj.stage_2_func = futex_release_stage2;
|
||
ft->kobj.put_func = futex_release_put;
|
||
}
|