void simple_scheduler::thread_proc(int id) {
try {
schedule_queue_type::value_type instance;
while (!stop_requested_) {
instance = queue_.pop();
if (!instance) {
boost::unique_lock<boost::mutex> lock(idle_thread_mutex_);
idle_thread_cond_.wait(lock);
continue;
}
try {
boost::posix_time::time_duration off = now() - (*instance).time;
if (off.total_seconds() > error_threshold_) {
log_error("Ran scheduled item " + strEx::s::xtos(instance->schedule_id) + " " + strEx::s::xtos(off.total_seconds()) + " seconds to late from thread " + strEx::s::xtos(id));
}
boost::thread::sleep((*instance).time);
} catch (boost::thread_interrupted &e) {
if (!queue_.push(*instance))
log_error("ERROR");
if (stop_requested_) {
log_error("Terminating thread: " + strEx::s::xtos(id));
return;
}
continue;
} catch (...) {
if (!queue_.push(*instance))
log_error("ERROR");
continue;
}
boost::posix_time::ptime now_time = now();
boost::optional<schedules::schedule_object> item = get_task((*instance).schedule_id);
if (item) {
try {
if (handler_)
handler_->handle_schedule(*item);
reschedule(*item,now_time);
} catch (...) {
log_error("UNKNOWN ERROR RUNING TASK: ");
reschedule(*item);
}
} else {
log_error("Task not found: " + strEx::s::xtos(instance->schedule_id));
}
}
} catch (const std::exception &e) {
log_error("Exception in scheduler thread (thread will be killed): " + utf8::utf8_from_native(e.what()));
} catch (...) {
log_error("Exception in scheduler thread (thread will be killed)");
}
}
void Courier::setForwardRescheduleSignal(QObject &ob, bool fwd)
{
if(fwd) {
if(!connect(&ob,SIGNAL(reschedule(quint64)),this,SIGNAL(reschedule(quint64)),OC_CONTYPE)) {
qWarning()<<"ERROR: Could not connect "<<ob.objectName();
}
} else {
if(!disconnect(&ob,SIGNAL(reschedule(quint64)),this,SIGNAL(reschedule(quint64)))) {
qWarning()<<"ERROR: Could not disconnect "<<ob.objectName();
}
}
}
char *resolve_name(int serviceid)
{
struct directory_resolvename res_cmd;
struct directory_response dir_res;
char *service_name = "";
int id_proc;
res_cmd.command = DIRECTORY_RESOLVENAME;
res_cmd.serviceid = serviceid;
res_cmd.ret_port = dirlib_port;
res_cmd.thr_id = get_current_thread();
// we will send an smo with size 1 first
// servicename will not fit and directory will return
// an error spacifying dir name size.
res_cmd.name_smo = share_mem(DIRECTORY_TASK, service_name, 1, WRITE_PERM);
send_msg(DIRECTORY_TASK, DIRECTORY_PORT, &res_cmd);
while (get_msg_count(dirlib_port) == 0) { reschedule(); }
get_msg(dirlib_port, &dir_res, &id_proc);
claim_mem(res_cmd.name_smo);
if(dir_res.ret == DIRECTORYERR_SMO_TOOSMALL)
{
// now malloc for servicename
service_name = (char *)malloc(dir_res.ret_value + 1);
res_cmd.name_smo = share_mem(DIRECTORY_TASK, service_name, len(service_name) + 1, WRITE_PERM);
send_msg(DIRECTORY_TASK, DIRECTORY_PORT, &res_cmd);
while (get_msg_count(dirlib_port) == 0) { reschedule(); }
get_msg(dirlib_port, &dir_res, &id_proc);
claim_mem(res_cmd.name_smo);
if(dir_res.ret != DIRECTORYERR_OK)
{
free(service_name);
return NULL; // fail
}
return service_name;
}
else
{
return NULL; // fail
}
}
/*
* Change task priority.
*/
EXPORT void change_task_priority( TCB *tcb, INT priority )
{
INT oldpri;
if ( tcb->state == TS_READY ) {
/*
* When deleting a task from the ready queue,
* a value in the 'priority' field in TCB is needed.
* Therefore you need to delete the task from the
* ready queue before changing 'tcb->priority.'
*/
ready_queue_delete(&ready_queue, tcb);
tcb->priority = (UB)priority;
ready_queue_insert(&ready_queue, tcb);
reschedule();
} else {
oldpri = tcb->priority;
tcb->priority = (UB)priority;
/* If the hook routine at the task priority change is defined,
execute it */
if ( (tcb->state & TS_WAIT) != 0 && tcb->wspec->chg_pri_hook) {
(*tcb->wspec->chg_pri_hook)(tcb, oldpri);
}
}
}
virtual void operator() ()
{
m_dht.restore();
m_dht.maintain();
reschedule();
}
virtual void operator() ()
{
m_dht.refresh();
m_dht.sweep_rdp();
reschedule();
}
void
ser_base_async (struct serial *scb,
int async_p)
{
if (async_p)
{
/* Force a re-schedule. */
scb->async_state = NOTHING_SCHEDULED;
if (serial_debug_p (scb))
fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
scb->fd);
reschedule (scb);
}
else
{
if (serial_debug_p (scb))
fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
scb->fd);
/* De-schedule whatever tasks are currently scheduled. */
switch (scb->async_state)
{
case FD_SCHEDULED:
delete_file_handler (scb->fd);
break;
case NOTHING_SCHEDULED:
break;
default: /* TIMER SCHEDULED */
delete_timer (scb->async_state);
break;
}
}
}
/* block_thread() & preempt_thread() */
void block_thread(void)
{
cthread->state = THREAD_BLOCKED;
memcpy((void *) &cthread->ctx, (void *) __ctx, sizeof(struct sys_context)); /* save threads context */
reschedule();
return;
}
void Monotonic::Manager::start(Monotonic *timer)
{
if(timer == nullptr)
{
throw;
}
bool added = false;
for(auto i = timers.begin(); i != timers.end(); ++i)
{
Monotonic *current = *i;
if(current->time + current->offset > timer->time + timer->offset)
{
timers.insert(i, timer);
added = true;
break;
}
}
if(!added)
{
timers.push_back(timer);
}
Watcher::start();
reschedule();
}
// Warning: this function is called in the context of an unknown thread.
// As a result, it must be thread-safe relative to other operations on
// the alarm list.
static void timer_callback(void *ptr) {
alarm_t *alarm = (alarm_t *)ptr;
assert(alarm != NULL);
pthread_mutex_lock(&monitor);
bool alarm_valid = list_remove(alarms, alarm);
alarm_callback_t callback = alarm->callback;
void *data = alarm->data;
alarm->deadline = 0;
alarm->callback = NULL;
alarm->data = NULL;
reschedule();
// The alarm was cancelled before we got to it. Release the monitor
// lock and exit right away since there's nothing left to do.
if (!alarm_valid) {
pthread_mutex_unlock(&monitor);
return;
}
// Downgrade lock.
pthread_mutex_lock(&alarm->callback_lock);
pthread_mutex_unlock(&monitor);
callback(data);
pthread_mutex_unlock(&alarm->callback_lock);
}
static void
fd_event (int error, void *context)
{
struct serial *scb = context;
if (error != 0)
{
scb->bufcnt = SERIAL_ERROR;
}
else if (scb->bufcnt == 0)
{
/* Prime the input FIFO. The readchar() function is used to
pull characters out of the buffer. See also
generic_readchar(). */
int nr;
nr = scb->ops->read_prim (scb, BUFSIZ);
if (nr == 0)
{
scb->bufcnt = SERIAL_EOF;
}
else if (nr > 0)
{
scb->bufcnt = nr;
scb->bufp = scb->buf;
}
else
{
scb->bufcnt = SERIAL_ERROR;
}
}
scb->async_handler (scb, scb->async_context);
reschedule (scb);
}
void DefaultFileSource::Impl::startRealRequest(DefaultFileRequest& request) {
assert(!request.realRequest);
// Cancel the timer if we have one.
if (request.timerRequest) {
request.timerRequest->stop();
}
auto callback = [this, &request](std::shared_ptr<const Response> response) {
request.realRequest = nullptr;
if (cache) {
// Store response in database. Make sure we only refresh the expires column if the data
// didn't change.
FileCache::Hint hint = FileCache::Hint::Full;
if (request.getResponse() && response->data == request.getResponse()->data) {
hint = FileCache::Hint::Refresh;
}
cache->put(request.resource, response, hint);
}
request.setResponse(response);
request.notify();
reschedule(request);
};
if (algo::starts_with(request.resource.url, "asset://")) {
request.realRequest =
assetContext->createRequest(request.resource, callback, loop, assetRoot);
} else {
request.realRequest =
httpContext->createRequest(request.resource, callback, loop, request.getResponse());
}
}
int timer_wait(unsigned int ticks)
{
uint64_t eticks = per_core(timer_ticks) + ticks;
task_t* curr_task = per_core(current_task);
if (curr_task->status == TASK_IDLE)
{
/*
* This will continuously loop until the given time has
* been reached
*/
while (per_core(timer_ticks) < eticks) {
check_workqueues();
// recheck break condition
if (per_core(timer_ticks) >= eticks)
break;
PAUSE;
}
} else if (per_core(timer_ticks) < eticks) {
check_workqueues();
if (per_core(timer_ticks) < eticks) {
set_timer(eticks);
reschedule();
}
}
return 0;
}
void
dumpme(int flag)
{
int f;
double x;
struct event *e;
int i;
f = flag;
Ship.quadx = ranf(NQUADS);
Ship.quady = ranf(NQUADS);
Ship.sectx = ranf(NSECTS);
Ship.secty = ranf(NSECTS);
x = 1.5 * franf();
Move.time += x;
if (f) {
printf("%s falls into a black hole.\n", Ship.shipname);
} else {
printf("Computer applies full reverse power to avoid hitting "
"the\n");
printf(" negative energy barrier. A space warp was "
"entered.\n");
}
/* bump repair dates forward */
for (i = 0; i < MAXEVENTS; i++) {
e = &Event[i];
if (e->evcode != E_FIXDV)
continue;
reschedule(e, (e->date - Now.date) + x);
}
events(1);
printf("You are now in quadrant %d,%d. It is stardate %.2f\n",
Ship.quadx, Ship.quady, Now.date);
Move.time = 0;
}
void Monotonic::Manager::stop(Monotonic *timer)
{
for(auto i = timers.begin(); i != timers.end();)
{
Monotonic *current = *i;
if(current == timer)
{
i = timers.erase(i);
}
else
{
++i;
}
}
if(!timers.empty())
{
reschedule();
}
else
{
Watcher::disable();
}
}
void wake_thread(unsigned int id)
{
if(threads[id-1] != NULL)
threads[id-1]->state = THREAD_READY;
reschedule();
return;
}
void Real::Manager::stop(Real *timer)
{
for(std::list<Real *>::iterator i = timers.begin(); i != timers.end();)
{
Real *current = *i;
if(current == timer)
{
i = timers.erase(i);
}
else
{
++i;
}
}
if(!timers.empty())
{
reschedule();
}
else
{
Watcher::disable();
}
}
void __attribute__((noreturn)) kernel_main(unsigned int _memory_size)
{
struct vm_translation_map *init_map;
struct process *init_proc;
vm_page_init(_memory_size);
init_map = vm_translation_map_init();
boot_init_heap((char*) KERNEL_HEAP_BASE + PAGE_STRUCTURES_SIZE(_memory_size));
vm_address_space_init(init_map);
bootstrap_vm_cache();
bool_init_kernel_process();
boot_init_thread();
// Start other threads
REGISTERS[REG_THREAD_RESUME] = 0xffffffff;
spawn_kernel_thread("Grim Reaper", grim_reaper, 0);
init_proc = exec_program("program.elf");
// Idle task
for (;;)
{
if (list_is_empty(&init_proc->thread_list))
{
kprintf("init process has exited, shutting down\n");
REGISTERS[REG_THREAD_HALT] = 0xffffffff;
}
reschedule();
}
}
void NORETURN do_exit(int arg)
{
task_t* curr_task = per_core(current_task);
const uint32_t core_id = CORE_ID;
LOG_INFO("Terminate task: %u, return value %d\n", curr_task->id, arg);
uint8_t flags = irq_nested_disable();
// decrease the number of active tasks
spinlock_irqsave_lock(&readyqueues[core_id].lock);
readyqueues[core_id].nr_tasks--;
spinlock_irqsave_unlock(&readyqueues[core_id].lock);
// release the thread local storage
destroy_tls();
curr_task->status = TASK_FINISHED;
reschedule();
irq_nested_enable(flags);
LOG_ERROR("Kernel panic: scheduler found no valid task\n");
while(1) {
HALT;
}
}
/** @brief A procedure to be called by
* procedures which are called by exiting tasks. */
static void NORETURN do_exit(int arg)
{
int task_id;
task_t* curr_task = current_task;
kprintf("Terminate task: %u, return value %d\n", curr_task->id, arg);
page_map_drop();
for (task_id = 0; task_id = MAX_TASKS; task_id++) {
task_t* task = &task_table[task_id];
if (task->status == TASK_IDLE && task->wait_id == curr_task->id) {
task->wait_id = -1;
task->status = TASK_READY;
}
}
// decrease the number of active tasks
spinlock_irqsave_lock(&readyqueues.lock);
readyqueues.nr_tasks--;
spinlock_irqsave_unlock(&readyqueues.lock);
curr_task->status = TASK_FINISHED;
reschedule();
kprintf("Kernel panic: scheduler found no valid task\n");
while(1) {
HALT;
}
}
// Runs in exclusion with alarm_cancel and timer_callback.
void alarm_set(alarm_t *alarm, period_ms_t deadline, alarm_callback_t cb, void *data) {
assert(alarms != NULL);
assert(alarm != NULL);
assert(cb != NULL);
pthread_mutex_lock(&monitor);
// If the alarm is currently set and it's at the start of the list,
// we'll need to re-schedule since we've adjusted the earliest deadline.
bool needs_reschedule = (!list_is_empty(alarms) && list_front(alarms) == alarm);
if (alarm->callback)
list_remove(alarms, alarm);
alarm->deadline = now() + deadline;
alarm->callback = cb;
alarm->data = data;
// Add it into the timer list sorted by deadline (earliest deadline first).
if (list_is_empty(alarms))
list_prepend(alarms, alarm);
else
for (list_node_t *node = list_begin(alarms); node != list_end(alarms); node = list_next(node)) {
list_node_t *next = list_next(node);
if (next == list_end(alarms) || ((alarm_t *)list_node(next))->deadline >= alarm->deadline) {
list_insert_after(alarms, node, alarm);
break;
}
}
// If the new alarm has the earliest deadline, we need to re-evaluate our schedule.
if (needs_reschedule || (!list_is_empty(alarms) && list_front(alarms) == alarm))
reschedule();
pthread_mutex_unlock(&monitor);
}
void free(void* p, std::size_t count = 1)
{
if (NULL == p || !threads::threadmanager_is(running))
return;
// if this is called from outside a HPX thread we need to
// re-schedule the request
typedef boost::is_same<boost::shared_mutex, SharedMutex>
reschedule_pred;
if (reschedule(p, count, reschedule_pred()))
return;
shared_lock_type guard(mtx_);
// Find the heap which allocated this pointer.
for (iterator it = heap_list_.begin(); it != heap_list_.end(); ++it)
{
if ((*it)->did_alloc(p))
{
(*it)->free(p, count);
free_count_ += count;
return;
}
}
HPX_THROW_EXCEPTION(bad_parameter,
name() + "::free",
boost::str(boost::format(
"pointer %1% was not allocated by this %2%")
% p % name()));
}
/*
* Rotate the ready queue including the highest priority task.
*/
EXPORT void rotate_ready_queue_run( void )
{
if ( schedtsk != NULL ) {
ready_queue_rotate(&ready_queue,
ready_queue_top_priority(&ready_queue));
reschedule();
}
}
void MprTimer::reschedule(int msec)
{
if (msec < 10) { // Sanity check
msec = 10;
}
period = msec;
reschedule();
}
static void battery_exit(void)
{
trace("");
reschedule( 0 ); // make sure we kill the timer :)
flush_workqueue( g_Workqueue );
destroy_workqueue( g_Workqueue );
}
dock()
{
register int i, j;
int ok;
register struct event *e;
if (Ship.cond == DOCKED)
return (printf("Chekov: But captain, we are already docked\n"));
/* check for ok to dock, i.e., adjacent to a starbase */
ok = 0;
for (i = Ship.sectx - 1; i <= Ship.sectx + 1 && !ok; i++)
{
if (i < 0 || i >= NSECTS)
continue;
for (j = Ship.secty - 1; j <= Ship.secty + 1; j++)
{
if (j < 0 || j >= NSECTS)
continue;
if (Sect[i][j] == BASE)
{
ok++;
break;
}
}
}
if (!ok)
return (printf("Chekov: But captain, we are not adjacent to a starbase.\n"));
/* restore resources */
Ship.energy = Param.energy;
Ship.torped = Param.torped;
Ship.shield = Param.shield;
Ship.crew = Param.crew;
Game.captives += Param.brigfree - Ship.brigfree;
Ship.brigfree = Param.brigfree;
/* reset ship's defenses */
Ship.shldup = 0;
Ship.cloaked = 0;
Ship.cond = DOCKED;
Ship.reserves = Param.reserves;
/* recalibrate space inertial navigation system */
Ship.sinsbad = 0;
/* output any saved radio messages */
dumpssradio();
/* reschedule any device repairs */
for (i = 0; i < MAXEVENTS; i++)
{
e = &Event[i];
if (e->evcode != E_FIXDV)
continue;
reschedule(e, (e->date - Now.date) * Param.dockfac);
}
return;
}
/* This is where most of the magic happens. This function gets called
* every millisecond to handle scheduling decisions.
*/
static void scheduler_cb(void) {
U32 time = nx_systick_get_ms();
bool need_reschedule = FALSE;
/* Security mechanism: in case the system crashes, as long as the
* scheduler is still running, the brick can be powered off.
*/
if (nx_avr_get_button() == BUTTON_CANCEL)
nx_core_halt();
/* If the scheduler state is locked, nothing can be done. */
if (sched_lock > 0)
return;
sched_lock = 1;
/* Process pending commands, if any */
if (task_command != CMD_NONE) {
switch (task_command) {
case CMD_YIELD:
need_reschedule = TRUE;
break;
case CMD_DIE:
destroy_running_task();
need_reschedule = TRUE;
break;
default:
break;
}
task_command = CMD_NONE;
nx_systick_unmask_scheduler();
} else {
/* Check if the task quantum for the running task has expired. */
if (time - sched_state.last_context_switch >= TASK_EXECUTION_QUANTUM)
need_reschedule = TRUE;
}
/* Wake up tasks that have scheduled alarms. */
while (!mv_list_is_empty(sched_state.alarms_pending) &&
sched_state.alarms_pending->wakeup_time <= time) {
struct mv_alarm_entry *a = sched_state.alarms_pending;
mv_list_remove(sched_state.alarms_pending, sched_state.alarms_pending);
mv__scheduler_task_unblock(a->task);
nx_free(a);
}
/* Task switching time? */
if (need_reschedule) {
if (sched_state.task_current != NULL)
sched_state.task_current->stack_current = mv__task_get_stack();
reschedule();
mv__task_set_stack(sched_state.task_current->stack_current);
sched_state.last_context_switch = nx_systick_get_ms();
}
sched_lock = 0;
}
int simple_scheduler::add_task(schedules::schedule_object item) {
{
boost::mutex::scoped_lock l(mutex_);
item.id = ++schedule_id_;
targets_[item.id] = item;
}
reschedule(item);
return item.id;
}
static void
push_event (void *context)
{
struct serial *scb = context;
scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
scb->async_handler (scb, scb->async_context);
/* re-schedule */
reschedule (scb);
}
void main (uint32_t mboot_magic, uint32_t mboot_info)
{
multiboot_memmap_t *first_free;
uint64_t *new_stack;
asm volatile ("cli");
cpu_early_init();
x64_gdt_init();
x64_idt_init();
vga_console_init();
printk("\n================================\n");
printk("||==Welcome to CELLOS 64 bit==||");
printk("\n================================\n");
/* Read mboot header */
first_free = mboot_init(mboot_info, mboot_magic);
if (first_free == NULL)
{
panic("No free memory for use! STOP~!\n");
}
mb_parse_kernel_image();
paging_init(first_free->base_addr,
first_free->base_addr + first_free->length);
/* Init page allocator */
page_alloc_init(mem_get_low_addr(),mem_get_high_addr());
/* Initialize the memory pool */
init_memory_pool(CONFIG_KHEAP_SIZE,
(void *)page_alloc_contig(CONFIG_KHEAP_SIZE/PAGE_SIZE));
detect_cpu();
acpi_init();
smp_init();
paging_late_init();
sched_core_init();
sched_init();
reschedule();
/* No reached */
}
