/**************************************************************************//**
* @brief vApplicationIdleHook
* Override the default definition of vApplicationIdleHook()
*****************************************************************************/
void vApplicationIdleHook(void)
{
#ifdef CHECK_STACK_USAGE
static bool b_tasks_registered = false;
if (!b_tasks_registered)
{
// Register Idle & Timer Task with stack check code
TaskHandle_t task;
task = xTaskGetIdleTaskHandle();
// Task init complete. Register task and some metrics with main info structure
task_info_t info;
info.task_handle = task;
info.stack_size = configMINIMAL_STACK_SIZE;
info.stack_use_percentage = 0;
register_task(TASK_IDLE, &info);
task = xTimerGetTimerDaemonTaskHandle();
info.task_handle = task;
info.stack_size = configTIMER_TASK_STACK_DEPTH;
info.stack_use_percentage = 0;
register_task(TASK_TIMER, &info);
b_tasks_registered = true;
}
#endif
}
RtecScheduler::handle_t
ACE_Config_Scheduler::create (const char * entry_point)
{
typedef RtecScheduler::RT_Info* RT_Info_ptr;
RtecScheduler::RT_Info** rt_info = 0;
ACE_NEW_RETURN (rt_info, RT_Info_ptr[1], -1);
ACE_NEW_RETURN (rt_info[0], RtecScheduler::RT_Info, -1);
rt_info[0]->entry_point = CORBA::string_dup(entry_point);
rt_info[0]->handle = -1;
rt_info[0]->worst_case_execution_time = ORBSVCS_Time::zero ();
rt_info[0]->typical_execution_time = ORBSVCS_Time::zero ();
rt_info[0]->cached_execution_time = ORBSVCS_Time::zero ();
rt_info[0]->period = 0;
rt_info[0]->criticality = RtecScheduler::VERY_LOW_CRITICALITY;
rt_info[0]->importance = RtecScheduler::VERY_LOW_IMPORTANCE;
rt_info[0]->quantum = ORBSVCS_Time::zero ();
rt_info[0]->threads = 0;
rt_info[0]->priority = 0;
rt_info[0]->preemption_subpriority = 0;
rt_info[0]->preemption_priority = 0;
rt_info[0]->info_type = RtecScheduler::OPERATION;
rt_info[0]->volatile_token = 0;
RtecScheduler::handle_t handle = -1;
#if defined (TAO_USES_STRATEGY_SCHEDULER)
switch (impl->register_task (rt_info[0], handle))
#else
switch (impl->register_task (rt_info, 1, handle))
#endif /* defined (TAO_USES_STRATEGY_SCHEDULER) */
{
case BaseSchedImplType::SUCCEEDED:
break;
case BaseSchedImplType::ST_VIRTUAL_MEMORY_EXHAUSTED:
case BaseSchedImplType::ST_TASK_ALREADY_REGISTERED:
default:
delete rt_info[0];
delete[] rt_info;
ORBSVCS_ERROR ((LM_ERROR,
"Config_Scheduler::create - register_task failed\n"));
// @@ TODO: throw something.
break;
}
return handle;
}
void init_schedule() {
current = (struct task_t *)0;
tasks_count = 0;
register_task(0);
tasks[0].t_counter = 0;
tasks[0].t_priority = 0;
current = &tasks[0];
asm volatile ("pushfl; andl $0xffffbfff, (%esp); popfl"); /* clear NT */
asm volatile ("ltr %%ax"::"a"(_TSS(0)));
asm volatile ("lldt %%ax"::"a"(_LDT(0)));
}
int multitasking_init(void)
{
if (BUILTIN_EXPECT(task_table[0].status != TASK_IDLE, 0)) {
kputs("Task 0 is not an idle task\n");
return -ENOMEM;
}
task_table[0].prio = IDLE_PRIO;
task_table[0].stack = (void*) &boot_stack;
task_table[0].page_map = read_cr3();
// register idle task
register_task();
return 0;
}
HRESULT
setup_jumplist(wstring appid, int n, wstring titles[], wstring cmds[], wstring icons[], int ii[])
{
OSVERSIONINFO ver;
ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&ver);
//printf("setup_jumplist\n");
// if running under the machine older than Windows 7, silently return.
if (!((ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 1) || ver.dwMajorVersion >= 7)) {
return S_OK;
}
HRESULT hr = S_OK;
hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
if (FAILED(hr))
return hr;
hr = clear_jumplist();
hr = S_OK;
if (SUCCEEDED(hr)) {
IObjectCollection * pobjs = init_jumplist();
//printf("setup_jumplist items %p\n", pobjs);
if (pobjs) {
for (int i = 0; i < n; ++i) {
hr = register_task(pobjs, titles[i], cmds[i], icons[i], ii[i]);
if (FAILED(hr)) {
break;
}
}
if (SUCCEEDED(hr))
hr = create_jumplist(appid, pobjs);
pobjs->lpVtbl->Release((void *)pobjs);
}
}
CoUninitialize();
return hr;
}
task_t *new_task(void (*fptr)(void), uint8_t priority, uint32_t period) {
task_ctrl *task = create_task(fptr, priority, period);
if (task == NULL) {
goto fail;
}
int ret = register_task(task, period);
if (ret != 0) {
goto fail2;
}
total_tasks += 1;
return get_task_t(task);
fail2:
free(task->stack_limit);
kfree(task);
fail:
panic_print("Could not allocate task with function pointer 0x%x", fptr);
}
static int do_register(char * args)
{
// parse registration information
char * str_pid = strsep(&args, DELIMITER);
char * str_per = strsep(&args, DELIMITER);
char * str_cmp = strsep(&args, DELIMITER);
unsigned int pid;
unsigned int period;
unsigned int comp_time;
int parse_failure = 0;
parse_failure |= kstrtouint(str_pid, 10, &pid);
parse_failure |= kstrtouint(str_per, 10, &period);
parse_failure |= kstrtouint(str_cmp, 10, &comp_time);
if(parse_failure)
return parse_failure;
printk(KERN_ALERT "Registered %d (period %d).\n", pid, period);
register_task((pid_t) pid, period, comp_time);
return 0;
}
static struct snobj *port_inc_init(struct module *m, struct snobj *arg)
{
struct port_inc_priv *priv = get_priv(m);
const char *port_name;
task_id_t ret;
if (!arg || !(port_name = snobj_str_get(arg)))
return snobj_err(EINVAL, "Argument must be a port name " \
"(string)");
priv->port = find_port(port_name);
if (!priv->port)
return snobj_err(ENODEV, "Port %s not found", port_name);
ret = register_task(m, NULL);
if (ret == INVALID_TASK_ID)
return snobj_err(ENOMEM, "Task creation failed");
acquire_queue(priv->port, PACKET_DIR_INC, 0 /* XXX */, m);
return NULL;
}
