struct SHEET *open_console(struct SHTCTL *shtctl, unsigned int memtotal)
{
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct SHEET *sht = sheet_alloc(shtctl);
unsigned char *buf = (unsigned char *) memman_alloc_4k(memman, 256 * 165);
struct TASK *task = task_alloc();
int *cons_fifo = (int *) memman_alloc_4k(memman, 128 * 4);
sheet_setbuf(sht, buf, 256, 165, -1); /* 透明色なし */
make_window8(buf, 256, 165, "console", 0);
make_textbox8(sht, 8, 28, 240, 128, COL8_000000);
task->cons_stack = memman_alloc_4k(memman, 64 * 1024);
task->tss.esp = task->cons_stack + 64 * 1024 - 12;
task->tss.eip = (int) &console_task;
task->tss.es = 1 * 8;
task->tss.cs = 2 * 8;
task->tss.ss = 1 * 8;
task->tss.ds = 1 * 8;
task->tss.fs = 1 * 8;
task->tss.gs = 1 * 8;
*((int *) (task->tss.esp + 4)) = (int) sht;
*((int *) (task->tss.esp + 8)) = memtotal;
task_run(task, 2, 2); /* level=2, priority=2 */
sht->task = task;
sht->flags |= 0x20; /* カーソルあり */
fifo32_init(&task->fifo, 128, cons_fifo, task);
return sht;
}
void schedule(void)
{
struct task_struct *task_next = NULL;
struct list_head *le = NULL, *last = NULL;
bool intr_flag = false;
local_intr_store(intr_flag);
{
current->need_resched = false;
// 如果当前是内核调度线程在执行，就从任务链起始开始，否则从当前任务开始
le = last = (current == glb_idle_task) ? &task_list : &(current->list);
for (le = le->next; le != last; le = le->next) {
if (le != &task_list) {
task_next = le_to_task(le);
if (task_next->state == TASK_RUNNABLE) {
break;
}
}
}
// 未找到可运行的任务
if (!task_next || task_next->state != TASK_RUNNABLE) {
task_next = glb_idle_task;
}
// 时间片递增
task_next->runs_time++;
if (task_next != current) {
task_run(task_next);
}
}
local_intr_restore(intr_flag);
}
//打开新的console的函数
LAYER *open_console(LAYER_MANAGE *layer_manage, unsigned int memory_total)
{
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
LAYER *layer_console = layer_alloc(layer_manage);
unsigned char *buf_console = (unsigned char *)memmanage_alloc_4K(memmanage, 256 * 165);
TASK *task_console = task_alloc();
int *console_fifo = (int *)memmanage_alloc_4K(memmanage, 128 * 4);
layer_set(layer_console, buf_console, 256, 165, -1);
create_window(buf_console, 256, 165, "console", INACTIVE);
create_textbox(layer_console, 8, 28, 240, 128, COL8_000000);
task_console->console_stack = memmanage_alloc_4K(memmanage, 64 * 1024) + 64 * 1024 - 12; //由于这里要传入两个参数，所以减去了12
task_console->tss.esp = task_console->console_stack;
task_console->tss.eip = (int) &console_task; //eip指向的是运行console的函数首地址
task_console->tss.es = 1 * 8;
task_console->tss.cs = 2 * 8;
task_console->tss.ss = 1 * 8;
task_console->tss.ds = 1 * 8;
task_console->tss.fs = 1 * 8;
task_console->tss.gs = 1 * 8;
*((int *) (task_console->tss.esp + 4)) = (int) layer_console;
*((int *) (task_console->tss.esp + 8)) = memory_total;
task_run(task_console, 2, 2); /* level=2, priority=2 */
layer_console->task = task_console;
layer_console->flags |= 0x20; //flags的0x20代表当前窗口的光标ON
init_fifo(&task_console->fifo, 128, console_fifo, task_console);
return layer_console;
}
ssize_t sendfile_a(int out_fd, int in_fd, off_t *offset, size_t count) {
struct sendfile_s s = {
.out_fd = out_fd,
.in_fd = in_fd,
.offset = offset,
.count = count
};
(void) task_run(NULL, sendfile_task, &s, -1);
return s.sz;
}
static void
libcec_vpi(vpi_op_t op, struct htsmsg *info, struct prop *p)
{
if(!conn)
return;
if(op == VPI_START) {
task_run(activate_self, NULL);
}
}
int main(int argc, char** argv)
{
struct heaptimer_t* timer;
struct task_t* t;
struct task_step_t* t1, *t2, *t3;
struct timeval timeout;
struct timeval tv;
int32_t loop = argc > 1 ? atoi(argv[1]) : 3;
cp = curl_pool_init();
assert(cp);
timer = timer_init();
assert(timer);
t = task_init(on_success, on_fail, (void*)&loop);
assert(t);
t1 = task_step_init(t1_run);
assert(t1);
task_push_back_step(t, t1);
id = task_step_id(t1);
t2 = task_step_init(t2_run);
assert(t2);
task_push_back_step(t, t2);
t3 = task_step_init(t3_run);
assert(t3);
task_push_back_step(t, t3);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
task_run(t, timer, &timeout);
while (1) {
if (curl_pool_running_count(cp) > 0) {
curl_pool_run(cp);
}
util_gettimeofday(&tv, NULL);
timer_poll(timer, &tv);
if (task_finished(t) == 0) {
break;
}
}
task_release(t);
timer_release(timer);
curl_pool_release(cp);
return 0;
}
task_t * task_create_and_run(char * task_name, task_t * parent_task, void (*entry)(void), uint32_t eflags, uint32_t pagedir) {
/* Create task: */
task_t * new_task = task_create(task_name, entry, eflags, pagedir);
IRQ_OFF(); /* Keep IRQs off */
/* Add it to the tree (and by adding, the switcher function will now switch to this process): */
task_run(parent_task, new_task);
IRQ_RES();
return new_task;
}
int ReadDir_a(const char *dir, FileInfo **info) {
struct readdir_s r = {0};
r.dir = dir;
r.finfo = info;
int rc = task_run(NULL, readdir_task, &r, -1);
if (rc != -1)
return r.nfiles;
assert(errno);
*info = NULL;
return -1;
}
/**
* prop_mutex can be held here, so we need to avoid locking it
*/
void
mp_release(media_pipe_t *mp)
{
if(atomic_dec(&mp->mp_refcount))
return;
event_t *e;
/* Make sure a clean shutdown has been made */
assert(mp->mp_audio_decoder == NULL);
assert(mp != media_primary);
if(media_pipe_fini_extra != NULL)
media_pipe_fini_extra(mp);
while((e = TAILQ_FIRST(&mp->mp_eq)) != NULL) {
TAILQ_REMOVE(&mp->mp_eq, e, e_link);
event_release(e);
}
mq_flush(mp, &mp->mp_audio, 1);
mq_flush(mp, &mp->mp_video, 1);
mq_destroy(&mp->mp_audio);
mq_destroy(&mp->mp_video);
video_overlay_flush_locked(mp, 0);
dvdspu_destroy_all(mp);
hts_cond_destroy(&mp->mp_backpressure);
hts_mutex_destroy(&mp->mp_mutex);
hts_mutex_destroy(&mp->mp_clock_mutex);
hts_mutex_destroy(&mp->mp_overlay_mutex);
pool_destroy(mp->mp_mb_pool);
if(mp->mp_satisfied == 0)
atomic_dec(&media_buffer_hungry);
cancellable_release(mp->mp_cancellable);
/**
* We need to destroy mp_prop_root but there is a risk that prop_mutex
* is held here, so we need to dispatch
*/
task_run(mp_final_release, mp);
}
////检查状态未WAIT的任务，一旦发现这些任务有子进程结束信号，将这些放到可运行的状态
static void check_sigchld_signal()
{
int i;
struct TASK *task = NULL;
for (i = 0; i < MAX_TASKS; i++) {
if (taskctl->tasks0[i].flags == TASK_STATUS_WAITING) {
task = &taskctl->tasks0[i];
if( (task->signal >> (SIGCHLD-1)) & 0x01 ){
/* 复位信号 */
task->signal &= ~(1<<(SIGCHLD-1));
/* 检测到子进程结束信号，重新进入可执行状态 */
task_run(task, -1, 0);
}
}
}
/*
init taskctl and allocate the first task to the thread that calls the init method
we don't need to assign it a fifo
because all it doesn't is to switch by calling farjmp()
and doesn't need to put data to any buffer
*/
struct TASK *task_init(struct MEMMAN *memman) {
int i;
struct TASK *task, *idle;
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
taskctl = (struct TASKCTL *)memman_alloc_4k(memman, sizeof(struct TASKCTL));
for(i = 0; i < MAX_TASKS; i++) {
taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8;
taskctl->tasks0[i].flags = 0;
set_segmdesc(gdt + TASK_GDT0 + i, 103, (int)&taskctl->tasks0[i].tss, AR_TSS32);
}
/* initialize all levels */
for(i = 0; i < MAX_TASKLEVELS; i++) {
taskctl->level[i].running = 0;
taskctl->level[i].now = 0;
}
/* after initializaing all tasks in taskctl,
we need to alloc the first task and assign it to the thread that calls init */
task = task_alloc();
task->flags = 2; /* running */
task->priority = 2;
task->level = 0; /* the first task(for mouse/keyboard/timer interruption) should be in highest level */
task_add(task);
task_switchsub(); /* update taskctl->now_lv */
/* set task register to current task */
load_tr(task->sel);
idle = task_alloc();
idle->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 8;
idle->tss.eip = (int)&task_idle;
idle->tss.es = 1 * 8;
idle->tss.cs = 2 * 8;
idle->tss.ss = 1 * 8;
idle->tss.ds = 1 * 8;
idle->tss.fs = 1 * 8;
idle->tss.gs = 1 * 8;
/*
the idle task will always be running at lowest level
in case there's no when there's no active task to run and OS doesn't know where to jump
*/
task_run(idle, MAX_TASKLEVELS - 1, 1);
task_timer = timer_alloc();
timer_settime(task_timer, task->priority);
return task;
}
//任务管理主体的初始化（并为调用这个函数的那个程序分配一个任务状态段）
TASK *task_init(MEMMANAGE *memman)
{
int i;
TASK *task, *idle;
SEGMENT_DESCRIPTOR *gdt = (SEGMENT_DESCRIPTOR *) ADR_GDT;
taskctl = (TASKCTL *) memmanage_alloc_4K(memman, sizeof (TASKCTL));
//对taskctl进行初始化
for (i = 0; i < MAX_TASKS; i++)
{
taskctl->tasks[i].flags = UNUSED;
taskctl->tasks[i].selector = (TASK_GDT0 + i) * 8; //为这个任务分配任务状态段所在的GDT描述符
set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks[i].tss, AR_TSS32);
}
for (i = 0; i < MAX_TASKLEVELS; i++)
{
taskctl->task_level[i].running_number = 0;
taskctl->task_level[i].task_now = 0;
}
/*为调用这个初始化函数的程序分配一个属于它的任务*/
/*为调用这个初始化函数的程序分配一个属于它的任务*/
task = task_alloc();
task->flags = RUNNING; //这个任务当前正在运行中
task->priority = 2; //任务的优先级默认的都是2，即可以占用CPU0.02秒
task->level = 0; //调用这个函数的任务默认设定为最高级0级
task_add(task); //自动根据task的level添加到相应等级任务队列中
level_switch(); //由于有新任务添加进来，所以需要改变当前的lv_now
load_tr(task->selector); //改写TR寄存器，让它存储当前这个任务的段偏移值
task_timer = timer_alloc(); //分配一个用于任务切换的计时器
timer_set(task_timer, task->priority); //0.02秒切换一次任务
/*给整个操作系统一个最低级的任务，这样当没有任务且键盘鼠标等任务休眠的时候就可以转到这个任务里
**，这个任务永远存在
*/
idle = task_alloc();
idle->tss.esp = memmanage_alloc_4K(memman, 64 * 1024) + 64 * 1024;
idle->tss.eip = (int) &task_idle;
idle->tss.es = 1 * 8;
idle->tss.cs = 2 * 8;
idle->tss.ss = 1 * 8;
idle->tss.ds = 1 * 8;
idle->tss.fs = 1 * 8;
idle->tss.gs = 1 * 8;
task_run(idle, MAX_TASKLEVELS - 1, 1);
return task;
}
static fa_handle_t *
es_fap_open(struct fa_protocol *fap, const char *url,
char *errbuf, size_t errsize, int flags,
struct fa_open_extra *foe)
{
es_fa_handle_t *fah = calloc(1, sizeof(es_fa_handle_t));
fah->fah_size = -1;
es_fap_t *ef = fap->fap_opaque;
fah->fh.fh_proto = fap;
fah->fah_ef = ef;
es_resource_retain(&ef->super);
fah->fah_url = strdup(url);
fah->fah_errbuf = errbuf;
fah->fah_errsize = errsize;
fah->fah_flags = flags;
atomic_set(&fah->fah_refcount, 2); // One to return, one for task
hts_mutex_lock(&es_fa_mutex);
fah->fah_status = ES_FA_WORKING;
task_run(es_fa_open, fah);
while(fah->fah_status == ES_FA_WORKING)
hts_cond_wait(&es_fa_cond, &es_fa_mutex);
fah->fah_errbuf = NULL;
fah->fah_errsize = 0;
hts_mutex_unlock(&es_fa_mutex);
switch(fah->fah_status) {
case ES_FA_OK:
return &fah->fh;
case ES_FA_CANCELLED:
snprintf(errbuf, errsize, "Cancelled");
// FALLTHRU
case ES_FA_ERROR:
fah_release(fah);
break;
}
return NULL;
}
static void
es_fap_close(fa_handle_t *fh)
{
es_fa_handle_t *fah = (es_fa_handle_t *)fh;
hts_mutex_lock(&es_fa_mutex);
fah->fah_status = ES_FA_WORKING;
task_run(es_fa_close, fah_retain(fah));
while(fah->fah_status == ES_FA_WORKING)
hts_cond_wait(&es_fa_cond, &es_fa_mutex);
hts_mutex_unlock(&es_fa_mutex);
fah_release(fah);
}
/* 整个多任务系统的初始化初始化 */
struct TASK *task_init(struct MEMMAN *memman)
{
int i;
struct TASK *task, *idle;
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
taskctl = (struct TASKCTL *) memman_alloc_4k(memman, sizeof (struct TASKCTL));
/* 初始化所有的任务的task结构 */
for (i = 0; i < MAX_TASKS; i++) {
taskctl->tasks0[i].flags = 0;
taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8; /* 选择子初始化 */
/* 描述符初始化 */
set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32);
}
/* 初始化所有level结构 */
for (i = 0; i < MAX_TASKLEVELS; i++) {
taskctl->level[i].running = 0; /* 没有正在运行的任务 */
taskctl->level[i].now = 0;
}
task = task_alloc();
task->flags = 2; /* 活动中标志 */
task->priority = 2; /* 0.02秒 */
task->level = 0; /* 最高LEVEL */
task_add(task);
task_switchsub(); /* LEVEL设置 */
load_tr(task->sel); /* 修改tr寄存器 */
task_timer = timer_alloc(); /* 重头戏！！任务切换的定时器 */
timer_settime(task_timer, task->priority);
/* 闲置任务的初始化 */
idle = task_alloc();
idle->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024;
idle->tss.eip = (int) &task_idle;
idle->tss.es = 1 * 8;
idle->tss.cs = 2 * 8;
idle->tss.ss = 1 * 8;
idle->tss.ds = 1 * 8;
idle->tss.fs = 1 * 8;
idle->tss.gs = 1 * 8;
task_run(idle, MAX_TASKLEVELS - 1, 1);
return task;
}
/**
* @description 初始化
* @param menman：内存地址
*/
struct TASK *task_init(struct MEMMAN *memman){
int i;
struct TASK *task, *idle;
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
taskctl = (struct TASKCTL *) memman_alloc_4k(memman, sizeof (struct TASKCTL));
//TODO 初始化所有任务
for (i = 0; i < MAX_TASKS; i++) {
taskctl->tasks0[i].flags = 0;
taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8;
set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32);
}
//TODO 初始化所有优先级层
for (i = 0; i < MAX_TASKLEVELS; i++) {
taskctl->level[i].running = 0;
taskctl->level[i].now = 0;
}
task = task_alloc();
task->flags = 2; //
task->priority = 2; //0.02秒
task->level = 0; //最高级别
task_add(task);
task_switchsub(); //切换
load_tr(task->sel);
task_timer = timer_alloc();
timer_settime(task_timer, task->priority);
//TODO 初始化空闲进程
idle = task_alloc();
idle->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024; //X86的栈是向下增长的，所以需要+64*1024
idle->tss.eip = (int) &task_idle;
idle->tss.es = 1 * 8;
idle->tss.cs = 2 * 8;
idle->tss.ss = 1 * 8;
idle->tss.ds = 1 * 8;
idle->tss.fs = 1 * 8;
idle->tss.gs = 1 * 8;
task_run(idle, MAX_TASKLEVELS - 1, 1);
return task;
}
int
fifo_put(fifo32_t* fifo, int data)
{
if (fifo->size == fifo->storage) {
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->rear] = data;
fifo->rear = (fifo->rear + 1) % fifo->storage;
++fifo->size;
if (0 != fifo->task) {
if (2 != fifo->task->flags)
task_run(fifo->task, -1, 0); /* the task need to wake up */
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：往缓冲区内插入一个数据，当有任务处于休眠的时候要唤醒
//参数：
int fifo32_put(struct FIFO32 *fifo, int data)
{
if (fifo->free == 0) {//溢出
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {//当插入位置到达最后时再返回第一个位置
fifo->p = 0;
}
fifo->free--;
if(fifo->task!=0){//如果设置了有唤醒任务就唤醒
if(fifo->task->flags!=2){//如果处于休眠状态
task_run(fifo->task, -1, 0); //将任务唤醒
}
}
return 0;
}
task_t*
task_init(mem_mgr_t* mem_mgr)
{
int i;
task_t* task;
task_t* idle;
segment_descriptor_t* gdt = (segment_descriptor_t*)ADR_GDT;
g_taskctrl = (task_ctrl_t*)mem_mgr_alloc_4k(mem_mgr, sizeof(task_ctrl_t));
for (i = 0; i < MAX_TASKS; ++i) {
g_taskctrl->tasks[i].flags = 0;
g_taskctrl->tasks[i].sel = (TASK_GDT0 + i) * 8;
set_segment_descriptor(gdt + TASK_GDT0 + i,
103, (int)&g_taskctrl->tasks[i].tss, AR_TSS32);
}
for (i = 0; i < MAX_TASKLEVELS; ++i) {
g_taskctrl->levels[i].running = 0;
g_taskctrl->levels[i].now = 0;
}
task = task_alloc();
task->flags = 2; /* flags about activity */
task->level = 0; /* top task level */
task->priority = 2; /* 0.02 s */
task_add(task);
task_switch_sub(); /* setting level */
load_tr(task->sel);
g_task_timer = timer_alloc();
timer_settimer(g_task_timer, task->priority);
idle = task_alloc();
idle->tss.esp = mem_mgr_alloc_4k(mem_mgr, 64 * 1024) + 64 * 1024;
idle->tss.eip = (int)&task_idle;
idle->tss.es = 1 * 8;
idle->tss.cs = 2 * 8;
idle->tss.ss = 1 * 8;
idle->tss.ds = 1 * 8;
idle->tss.fs = 1 * 8;
idle->tss.gs = 1 * 8;
task_run(idle, MAX_TASKLEVELS - 1, 1);
return task;
}
struct _task *task_init(struct _memman *memman) {
int i;
struct _task *task, *idle;
struct _segmdes *gdt = (struct _segmdes *) ADR_GDT;
taskctl = (struct _taskctl *) memman_alloc_4k(memman, sizeof (struct _taskctl));
for (i = 0; i < MAX_TASKS; i++) {
/* Register all task slots on segment descriptor table */
taskctl->tasks0[i].flags = TASK_UNUSED;
taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8; /* Setup selector (GDT segment) number */
set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32);
}
for (i = 0; i < MAX_TASKLEVELS; i++) {
taskctl->level[i].running = 0;
taskctl->level[i].now = 0;
}
/* Allocate new task for task_init caller */
task = task_alloc();
task->flags = TASK_RUNNING;
/* Priority and level */
task->priority = 2; /* Timeslice = 10ms * pri */
task->level = 0; /* Highest Level */
/* Add task to level control */
task_add(task);
/* Recalebrate Running Level */
task_switchsub();
/* Activate Current Task */
load_tr(task->sel);
task_timer = timer_alloc();
timer_settime(task_timer, task->priority);
/* idle Task */
idle = task_alloc();
idle->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024;
idle->tss.eip = (int) &task_idle;
idle->tss.es = 1 * 8;
idle->tss.cs = 2 * 8;
idle->tss.ss = 1 * 8;
idle->tss.ds = 1 * 8;
idle->tss.fs = 1 * 8;
idle->tss.gs = 1 * 8;
task_run(idle, MAX_TASKLEVELS - 1, 1);
return task;
}
//启动一个命令行窗口任务
TASK *open_console_task(LAYER *layer, unsigned int mem_total)
{
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
TASK *task_console = task_alloc();
int *console_fifo = (int *)memmanage_alloc_4K(memmanage, 128 * 4);
task_console->console_stack = memmanage_alloc_4K(memmanage, 64 * 1024); //由于这里要传入两个参数，所以减去了12
task_console->tss.esp = task_console->console_stack + 64 * 1024 - 12;
task_console->tss.eip = (int) &console_task; //eip指向的是运行console的函数首地址
task_console->tss.es = 1 * 8;
task_console->tss.cs = 2 * 8;
task_console->tss.ss = 1 * 8;
task_console->tss.ds = 1 * 8;
task_console->tss.fs = 1 * 8;
task_console->tss.gs = 1 * 8;
*((int *) (task_console->tss.esp + 4)) = (int) layer;
*((int *) (task_console->tss.esp + 8)) = mem_total;
task_run(task_console, 2, 2); /* level=2, priority=2 */
init_fifo(&task_console->fifo, 128, console_fifo, task_console);
return task_console;
}
struct TASK *open_constask(struct SHEET *sht, unsigned int memtotal)
{
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct TASK *task = task_alloc();
int *cons_fifo = (int *) memman_alloc_4k(memman, 128 * 4);
task->cons_stack = memman_alloc_4k(memman, 64 * 1024);
task->tss.esp = task->cons_stack + 64 * 1024 - 12;
task->tss.eip = (int) &console_task;
task->tss.es = 1 * 8;
task->tss.cs = 2 * 8;
task->tss.ss = 1 * 8;
task->tss.ds = 1 * 8;
task->tss.fs = 1 * 8;
task->tss.gs = 1 * 8;
*((int *) (task->tss.esp + 4)) = (int) sht;
*((int *) (task->tss.esp + 8)) = memtotal;
task_run(task, 2, 2); /* level=2, priority=2 */
fifo32_init(&task->fifo, 128, cons_fifo, task);
return task;
}
int fifo32_put(struct FIFO32 *fifo, int data)
/*向FIFO传送数据并保存*/
{
if(0 == fifo->free) {
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if(fifo->size == fifo->p) {
fifo->p =0;
}
fifo->free--;
if (0 != fifo->task) {
if (2 != fifo->task->flags) {
task_run(fifo->task, -1, 0);
}
}
return 0;
}
int fifo32_put(struct FIFO32 *fifo, int data)
/* FIFOへデータを送り込んで蓄える */
{
if (fifo->free == 0) {
/* 空きがなくてあふれた */
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {
fifo->p = 0;
}
fifo->free--;
if (fifo->task) {
if (fifo->task->flags != 2)
task_run(fifo->task, -1, 0); /* タスクが寝てたら起こす */
}
return 0;
}
/**
* @description 将指定数据放入缓冲
* @param fifo：目标缓冲
* data：欲放入的数据
* @return 放入成功否则返回0，否则返回-1，可能是缓冲已满
*/
int fifo32_put(struct FIFO32 *fifo, int data) {
//TODO 缓冲有效区间检查
if (fifo->free == 0) {
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {
fifo->p = 0;
}
fifo->free--;
if (fifo->task != 0) {
//TODO 任务唤醒
if (fifo->task->flags != 2) {
task_run(fifo->task, -1, 0);
}
}
return 0;
}
/* 向FIFO传送数据并保存 */
int fifo32_put(struct FIFO32 *fifo, int data)
{
if (fifo->free == 0) {
/* 空余没有了，溢出 */
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {
fifo->p = 0;
}
fifo->free--;
if (fifo->task != 0) {
if (fifo->task->flags != 2) { /* 如果任务处于休眠状态 */
task_run(fifo->task); /* 将任务唤醒 */
}
}
return 0;
}
static int
es_fap_stat(struct fa_protocol *fap, const char *url,
struct fa_stat *buf,
int flags, char *errbuf, size_t errsize)
{
es_fa_handle_t *fah = calloc(1, sizeof(es_fa_handle_t));
es_fap_t *ef = fap->fap_opaque;
fah->fah_url = strdup(url);
fah->fh.fh_proto = fap;
fah->fah_ef = ef;
es_resource_retain(&ef->super);
atomic_set(&fah->fah_refcount, 2);
fah->fah_errbuf = errbuf;
fah->fah_errsize = errsize;
fah->fah_status = ES_FA_WORKING;
task_run(es_fa_stat, fah);
hts_mutex_lock(&es_fa_mutex);
while(fah->fah_status == ES_FA_WORKING)
hts_cond_wait(&es_fa_cond, &es_fa_mutex);
fah->fah_errbuf = NULL;
fah->fah_errsize = 0;
hts_mutex_unlock(&es_fa_mutex);
int r = fah->fah_return_value;
if(!r) {
buf->fs_size = fah->fah_size;
buf->fs_type = fah->fah_type;
buf->fs_mtime = fah->fah_mtime;
}
fah_release(fah);
return r;
}
/*****************************************************************
* 2015-02-16 18:34:32
* V1.0 By Breaker
*
* void task_init(LinkedList *ll)
* 初始化系统任务管理机制
* return void
*/
void task_init()
{
//初始化 task_ready
task_ready = &task_ready_ll;
ll_init(task_ready);
//初始化 MSG_list
MSG_list = & MSG_list_ll;
ll_init(MSG_list);
//创建一个默认任务, 当前的代码将会以任务的方式执行
u8 rank = MAX_rank ;
u32 task_func = (u32)task_idle;
u8 TID = task_create( rank , task_func);
task_run(TID);
//初始化task_global
task_global.schedule_lock = false;
task_global.current_TID = TID;
task_global.current_tasktable = (u32) &task_table[TID];
}
int fifo32_put(struct FIFO32 *fifo, int data)
/* 向FIFO写入数据并累积起来 */
{
if (fifo->free == 0) {
/* 没有剩余空间则溢出 */
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {
fifo->p = 0;
}
fifo->free--;
if (fifo->task != 0) {
if (fifo->task->flags != 2) { /* 如果任务处于休眠状态 */
task_run(fifo->task, -1, 0); /* 将任务唤醒 */
}
}
return 0;
}
int fifo32_put(struct FIFO32 *fifo, int data)
/* FIFO写入数据 */
{
if (fifo->free == 0) {
/* 没有空余了 */
fifo->flags |= FLAGS_OVERRUN;
return -1;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {
fifo->p = 0;
}
fifo->free--;
if (fifo->task != 0) {
if (fifo->task->flags != 2) { //如果任务出于休眠状态
task_run(fifo->task, -1, 0);
}
}
return 0;
}
