int tmlib_init (void)
{
#ifdef SFS_WANTED
clock_t init_ticks = times (NULL);
init_scheduler ();
create_parent_task (init_ticks);
create_idle_task ();
init_soft_irq ();
init_io ();
#endif
mem_init ();
msg_Q_init ();
init_timer_mgr ();
#ifdef SFS_WANTED
setup_interrupt ();
#endif
return 0;
}
void init (int argc,char *argv[])
{
struct lac *lac;
init_args (argc,argv);
rand_source = 0;
init_addr ();
if (init_config ())
{
log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
exit (1);
}
if (uname (&uts))
{
log (LOG_CRIT, "%s : Unable to determine host system\n",
__FUNCTION__);
exit (1);
}
init_tunnel_list (&tunnels);
if (init_network ())
exit (1);
if (gconfig.daemon)
daemonize ();
signal (SIGTERM, &death_handler);
signal (SIGINT, &death_handler);
signal (SIGCHLD, &child_handler);
signal (SIGUSR1, &status_handler);
signal (SIGHUP, &null_handler);
init_scheduler ();
mkfifo (CONTROL_PIPE, 0600);
control_fd = open (CONTROL_PIPE, O_RDONLY | O_NONBLOCK, 0600);
if (control_fd < 0)
{
log (LOG_CRIT, "%s: Unable to open " CONTROL_PIPE " for reading.",
__FUNCTION__);
exit (1);
}
log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());
log (LOG_LOG,
"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
log (LOG_LOG, "Inhereted by Jeff McAdams, (C) 2002\n");
log (LOG_LOG, "%s version %s on a %s, port %d\n", uts.sysname,
uts.release, uts.machine, gconfig.port);
lac = laclist;
while (lac)
{
if (lac->autodial)
{
#ifdef DEBUG_MAGIC
log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
lac->entname[0] ? lac->entname : "(unnamed)");
#endif
lac->active = -1;
switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */
magic_lac_dial (lac);
}
lac = lac->next;
}
}
int main(int argc, char* argv[]) {
SharedVariable v;
int runningTimeInSec = 10;
if (argc == 2) {
runningTimeInSec = atoi(argv[1]);
}
if (wiringPiSetup() == -1) {
printf("Failed to setup wiringPi.");
return 1;
}
printf("start");
// Initialize for the interfaces provided
signal(SIGINT, signal_handler);
init_deferred_buffer(1024*1024); // 1MB
init_userspace_governor();
init_workload();
printf("stop");
// Initializers that you need to implement
init_shared_variable(&v);
init_sensors(&v);
learn_workloads(&v);
printf("Init scheduler start");
// Init scheduler
int aliveTasks[NUM_TASKS];
init_scheduler(runningTimeInSec);
set_by_max_freq(); // reset to the max freq
printf("Init scheduler stop");
printDBG("Start Scheduling with %d threads\n", NUM_TASKS);
TaskSelection sel;
long long idleTime;
while (v.bProgramExit != 1) {
// 1. Prepare tasks
idleTime = prepare_tasks(aliveTasks, &v);
if (idleTime < 0)
break;
// 2. Select a process: You need to implement.
sel = select_task(&v, aliveTasks, idleTime);
if (sel.task < 0)
break;
// 3. Run the selected task
execute_task(sel);
}
finish_workload();
release_buffer(fileno(stdout));
printf("Scheduler program finished.\n");
return 0;
}
int main(void)
{
init_scheduler();
AddTask(0,50, keypak, NULL);
AddTask(1, 20, keypak1, NULL);
AddTask(7, 500, NULL, NULL);
init_timer_irq();
execute();
}
void dispatch_to_scheduler(th_t* thread)
{
int pri, currentPri;
th_queue_t* foundQueueTh;
int flag = 1;
if(num_Thread ==0)
{
init_scheduler();
}
thread->tid = num_Thread++;
thread->mctx.status = TH_WAITING;
th_queue_insert(ready_queueHead, pri, thread);
printf("*** %d thread insert ***\n", num_Thread);
//Choose kernel thread to be added
if(num_kernel_thread < maxKernelThreads)
{
//Create a new kernel thread
//Create scheduler stack for new kernel thread
th_t *scheduleThread;
int pid;
if((scheduleThread = thread_alloc()) == NULL)
abort();
scheduleThread->mctx.status = TH_SCHED;
pid = scheduleThread->tid = getpid()+1;
scheduleThread->current_tid = 0;
num_kernel_thread++;
if((scheduleThread->mctx.stackAddr = stack_alloc()) == NULL)
abort();
th_queue_insert(sched_queueHead, PRIORITY_SCHEDULER, scheduleThread);
rfork_thread(RFPROC | RFNOTEG|RFMEM, scheduleThread->mctx.stackAddr, (int(*)(void*))start_kernel_thread, pid);
}
return;
/*
if(pri > currentPri)
{
foundQueueTh->thread->mctx.status = TH_WAITING;
currentTid = thread->tid;
thread->mctx.status = TH_RUNNING;
enable_timer();
mctx_switch(&(foundQueueTh->thread->mctx), &(thread->mctx));
}
else
switch_to_scheduler();
*/
}
void initialize( Kern_Globals *GLOBALS ) {
init_profiling( GLOBALS );
initialize_context_switching();
init_hardware();
init_message_queues( GLOBALS );
init_task_descriptors( GLOBALS );
init_scheduler( GLOBALS );
}
/* Initialize all kernel subsystems and run system */
int main(void) {
printa("In main %x\n", (unsigned)main);
init_int();
init_page_alloc();
init_pipes();
init_scheduler();
add_task(&init_systems);
while (1) {
schedule();
}
return 0;
}
static void init_env(void) {
SCM smob;
char *ver;
SOURCE_HANDLE *handle;
init_log();
init_alsa_module();
ver = scm_to_locale_string(scm_version());
log_msg("Guile version %s\n", ver);
free(ver);
init_messaging(msg_port);
init_time();
init_json();
init_scheduler();
init_audiofile();
if (use_jack) init_jackport();
init_feeds();
init_recorder();
init_stream();
init_source_mod();
init_ladspa();
init_unitgen();
fader = (SOURCE_OBJ *)my_malloc(sizeof(SOURCE_OBJ), "main fader");
handle = (SOURCE_HANDLE *)my_gc_malloc(sizeof(SOURCE_HANDLE), "mains",
"mains");
handle->body = (void *)fader;
handle->src = fader;
init_source(fader);
mains_tag = scm_make_smob_type("mains", sizeof(SOURCE_OBJ));
SCM_NEWSMOB(smob, mains_tag, handle);
scm_c_define("mains", smob);
if (use_jack) {
scm_c_define("jack-client-name",
scm_from_locale_string(client_name));
scm_c_define_gsubr("patch-out", 2, 0, 0, patch_out);
scm_c_define_gsubr("unpatch-out", 2, 0, 0, unpatch_out);
}
scm_c_define_gsubr("quit", 0, 0, 0, qmx_quit);
scm_c_define_gsubr("db", 1, 0, 0, db20);
scm_c_define_gsubr("period-duty-cycle", 0, 0, 0, get_duty_cycle);
scm_permanent_object(console_display =
scm_c_eval_string(console_display_src));
scm_permanent_object(catch_display =
scm_c_eval_string(catch_display_src));
return;
}
int main(void) {
#ifdef debug
uartInit();
sei();
printf("AVR Scheduler\n");
printf("PortB test.\n");
DDRB = 0b11111111;
PORTB = 5;
_delay_ms(500);
#endif
PORTB = 0;
#ifdef debug
printf("Initializing Scheduler...\n");
#endif
init_scheduler();
int res_a, res_b;
int arg_a = 1;
int arg_b = 2;
int tid_a = create(&thr_run, THREAD_PRIORITY_NORMAL, MINIMAL_STACK_SIZE, &arg_a);
#ifdef debug
printf("Thread A created\n");
#endif
int tid_b = create(&thr_run, THREAD_PRIORITY_NORMAL, MINIMAL_STACK_SIZE, &arg_b);
#ifdef debug
printf("Thread B created\n");
#endif
//UNUSED(tid_a); //remove warning the variavel nao utilizada
//UNUSED(tid_b);
join(tid_a, &res_a);
join(tid_b, &res_b);
while(1) {
#ifdef debug
printf("While(1):Main\n");
#endif
PORTB = 0;
}
}
/// Main function, primary avionics functions, thread 0, highest priority.
int main(int argc, char **argv) {
// Data Structures
struct imu imuData;
struct xray xrayData;
struct gps gpsData;
struct nav navData;
struct control controlData;
uint16_t cpuLoad;
// Timing variables
double etime_daq, etime_datalog, etime_telemetry;
// Include datalog definition
#include DATALOG_CONFIG
// Populate dataLog members with initial values //
dataLog.saveAsDoubleNames = &saveAsDoubleNames[0];
dataLog.saveAsDoublePointers = &saveAsDoublePointers[0];
dataLog.saveAsFloatNames = &saveAsFloatNames[0];
dataLog.saveAsFloatPointers = &saveAsFloatPointers[0];
dataLog.saveAsXrayNames = &saveAsXrayNames[0];
dataLog.saveAsXrayPointers = &saveAsXrayPointers[0];
dataLog.saveAsIntNames = &saveAsIntNames[0];
dataLog.saveAsIntPointers = &saveAsIntPointers[0];
dataLog.saveAsShortNames = &saveAsShortNames[0];
dataLog.saveAsShortPointers = &saveAsShortPointers[0];
dataLog.logArraySize = LOG_ARRAY_SIZE;
dataLog.numDoubleVars = NUM_DOUBLE_VARS;
dataLog.numFloatVars = NUM_FLOAT_VARS;
dataLog.numXrayVars = NUM_XRAY_VARS;
dataLog.numIntVars = NUM_INT_VARS;
dataLog.numShortVars = NUM_SHORT_VARS;
double tic,time,t0=0;
static int t0_latched = FALSE;
int loop_counter = 0;
pthread_mutex_t mutex;
uint32_t cpuCalibrationData;//, last100ms, last1s, last10s;
cyg_cpuload_t cpuload;
cyg_handle_t loadhandle;
// Populate sensorData structure with pointers to data structures //
sensorData.imuData_ptr = &imuData;
sensorData.gpsData_ptr = &gpsData;
sensorData.xrayData_ptr = &xrayData;
// Set main thread to highest priority //
struct sched_param param;
param.sched_priority = sched_get_priority_max(SCHED_FIFO);
pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
// Setup CPU load measurements //
cyg_cpuload_calibrate(&cpuCalibrationData);
cyg_cpuload_create(&cpuload, cpuCalibrationData, &loadhandle);
// Initialize set_actuators (PWM or serial) at zero //
// init_actuators();
// set_actuators(&controlData);
// Initialize mutex variable. Needed for pthread_cond_wait function //
pthread_mutex_init(&mutex, NULL);
pthread_mutex_lock(&mutex);
// Initialize functions //
init_daq(&sensorData, &navData, &controlData);
init_telemetry();
while(1){
//Init Interrupts
printf("intr init");
cyg_uint32 uChannel = MPC5XXX_GPW_GPIO_WKUP_7;
BOOL enable = true;
BOOL bInput = 1;
// uChannel initialisation
GPIO_GPW_EnableGPIO(uChannel, enable);
GPIO_GPW_SetDirection(uChannel, bInput);
GPIO_GPW_EnableInterrupt(uChannel, enable, MPC5XXX_GPIO_INTTYPE_RISING);
GPIO_GPW_ClearInterrupt(uChannel);
HAL_WRITE_UINT32(MPC5XXX_GPW+MPC5XXX_GPW_ME, 0x01000000);
cyg_uint32 temp;
HAL_READ_UINT32(MPC5XXX_ICTL_MIMR, temp);
HAL_WRITE_UINT32(MPC5XXX_ICTL_MIMR, temp&0xFFFFFEFF);
// wake-up interrupt service routine initialisation
cyg_vector_t int1_vector = CYGNUM_HAL_INTERRUPT_GPIO_WAKEUP;
cyg_priority_t int1_priority = 0;
cyg_bool_t edge = 0;
cyg_bool_t rise = 1;
cyg_drv_interrupt_create(int1_vector, int1_priority,0,interrupt_1_isr, interrupt_1_dsr,&int1_handle,&int1);
cyg_drv_interrupt_attach(int1_handle);
cyg_drv_interrupt_configure(int1_vector,edge,rise);
cyg_drv_interrupt_unmask(int1_vector);
hasp_mpc5xxx_i2c_init(); // Append: Initialise I2C bus and I2C interrupt routine; device defined in i2c_mpc5xxx.h and .c
cyg_interrupt_enable();
HAL_ENABLE_INTERRUPTS();
controlData.mode = 1; // initialize to manual mode
controlData.run_num = 0; // reset run counter
reset_Time(); // initialize real time clock at zero
init_scheduler(); // Initialize scheduling
threads_create(); // start additional threads
init_datalogger(); // Initialize data logging
//+++++++++++//
// Main Loop //
//+++++++++++//
while (controlData.mode != 0) {
loop_counter++; //.increment loop counter
//**** DATA ACQUISITION **************************************************
pthread_cond_wait (&trigger_daq, &mutex);
tic = get_Time();
get_daq(&sensorData, &navData, &controlData);
etime_daq = get_Time() - tic - DAQ_OFFSET; // compute execution time
//************************************************************************
//**** NAVIGATION ********************************************************
// pthread_cond_wait (&trigger_nav, &mutex);
// if(navData.err_type == got_invalid){ // check if get_nav filter has been initialized
// if(gpsData.navValid == 0) // check if GPS is locked
// init_nav(&sensorData, &navData, &controlData);// Initialize get_nav filter
// }
// else
// get_nav(&sensorData, &navData, &controlData);// Call NAV filter
//************************************************************************
if (controlData.mode == 2) { // autopilot mode
if (t0_latched == FALSE) {
t0 = get_Time();
t0_latched = TRUE;
}
time = get_Time()-t0; // Time since in auto mode
}
else{
if (t0_latched == TRUE) {
t0_latched = FALSE;
}
//reset_control(&controlData); // reset controller states and set get_control surfaces to zero
} // end if (controlData.mode == 2)
// Add trim biases to get_control surface commands
//add_trim_bias(&controlData);
//**** DATA LOGGING ******************************************************
pthread_cond_wait (&trigger_datalogger, &mutex);
datalogger(&sensorData, &navData, &controlData, cpuLoad);
cyg_drv_interrupt_mask(int1_vector);
xray_dump = dataprinter(sensorData, xray_dump);
cyg_drv_interrupt_unmask(int1_vector);
etime_datalog = get_Time() - tic - DATALOG_OFFSET; // compute execution time
//************************************************************************
//**** TELEMETRY *********************************************************
if(loop_counter >= BASE_HZ/TELEMETRY_HZ){
loop_counter = 0;
pthread_cond_wait (&trigger_telemetry, &mutex);
//
// get current cpu load
// cyg_cpuload_get (loadhandle, &last100ms, &last1s, &last10s);
// cpuLoad = (uint16_t)last100ms;
//
send_telemetry(&sensorData, &navData, &controlData, cpuLoad);
//
// etime_telemetry = get_Time() - tic - TELEMETRY_OFFSET; // compute execution time
}
//************************************************************************
} //end while (controlData.mode != 0)
close_scheduler();
close_datalogger(); // dump data
} // end while(1)
/**********************************************************************
* close
**********************************************************************/
pthread_mutex_destroy(&mutex);
// close_actuators();
//close_nav();
return 0;
} // end main
void init (int argc,char *argv[])
{
struct lac *lac;
struct in_addr listenaddr;
int myRet=0;
init_args (argc,argv);
srand( time(NULL) );
rand_source = 0;
init_addr ();
if (init_config ())
{
log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
exit (1);
}
init_tunnel_list (&tunnels);
if (init_network ())
exit (1);
//if (gconfig.daemon)
//daemonize ();
signal (SIGTERM, &death_handler);
signal (SIGINT, &death_handler);
signal (SIGCHLD, &child_handler);
signal (SIGUSR1, &status_handler);
signal (SIGHUP, &null_handler);
init_scheduler ();
unlink (gconfig.controlfile);
myRet=mkfifo (gconfig.controlfile, 0600);
// log (LOG_LOG,"gconfig.controlfile=%s, myRet=%d,errno=%d",gconfig.controlfile,myRet,errno);//Added for test
if(myRet<0)
{
log (LOG_CRIT, "%s: Unable to mkfifo %s.",__FUNCTION__, gconfig.controlfile);
exit (1);
}
control_fd = open (gconfig.controlfile, O_RDONLY | O_NONBLOCK, 0600);
if (control_fd < 0)
{
log (LOG_CRIT, "%s: Unable to open %s for reading.",
__FUNCTION__, gconfig.controlfile);
exit (1);
}
log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());
log (LOG_LOG,
"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
log (LOG_LOG, "Inherited by Jeff McAdams, (C) 2002\n");
listenaddr.s_addr = gconfig.listenaddr;
log (LOG_LOG, "Listening on IP address %s, port %d\n",
inet_ntoa(listenaddr), gconfig.port);
lac = laclist;
while (lac)
{
if (lac->autodial)
{
#ifdef DEBUG_MAGIC
log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
lac->entname[0] ? lac->entname : "(unnamed)");
#endif
lac->active = -1;
switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */
magic_lac_dial (lac);
}
lac = lac->next;
}
}
void start_kernel(void)
{
char str[] = "C FUNCTION START!";
/*
* ARCHITECTURE DEPENDENT INITIALIZATIONS
*/
/* screen - message display */
init_screen();
caos_printf("%s\n", str);
/* memory manager */
setup_memory();
/* exception & interrupt */
init_idt();
set_idtr();
/* device & IRQ */
init_char_dev();
keyboard_init();
init_timer();
/* scheduling */
init_scheduler();
/* task management */
setup_task();
init_cpu_tss();
/* after task setup, start scheduler */
start_scheduler();
/*************************************************/
/*
* ARCHITECTURE INDEPENDENT PROCESSING
*/
if (create_task(init, "init") < 0)
caos_printf("Create Init fail..\n");
if (create_task(user1, "user1") < 0)
caos_printf("Create user1 fail..\n");
if (create_task(user2, "user2") < 0)
caos_printf("Create user2 fail..\n");
caos_printf("CaOS KERNEL END!!\n");
/* execute user mode task */
start_init();
while (1);
}
void init6(int argc, char *argv[])
{
struct lac6 *lac;
// struct in6_addr listenaddr;
struct utsname uts;
// char ipaddr[16];
// char ipaddrStr[INET6_ADDRSTRLEN];
init_args (argc,argv);
srand( time(NULL) );
rand_source = 0;
//RY: required only when IP_ALLOCATION is defined
//init_addr ();
if (init_config6 ())
{
l2tp_log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
exit (1);
}
//inet_pton(AF_INET6, "1002:0:0:0:0:0:12", gconfig.ipaddr.listenaddr6);
// inet_pton(AF_INET6, "2001::12", gconfig.ipaddr.listenaddr6);
// inet_ntop(AF_INET6, gconfig.ipaddr.listenaddr6, ipaddrStr, sizeof(ipaddrStr));
if (uname (&uts)<0)
{
l2tp_log (LOG_CRIT, "%s : Unable to determine host system\n",
__FUNCTION__);
exit (1);
}
init_tunnel_list6 (&tunnels6);
if (init_network ())
exit (1);
if (gconfig.daemon)
// daemonize (); //RY: commented for debugging
consider_pidfile();
signal (SIGTERM, &death_handler6);
signal (SIGINT, &death_handler6);
signal (SIGCHLD, &child_handler6);
signal (SIGUSR1, &status_handler6);
signal (SIGHUP, &null_handler);
init_scheduler ();
unlink(gconfig.controlfile);
mkfifo (gconfig.controlfile, 0600);
open_controlfd();
/*l2tp_log (LOG_INFO, "xl2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());*/
printf( "xl2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());
printf(
"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
printf( "Forked by Scott Balmos and David Stipp, (C) 2001\n");
printf( "Inherited by Jeff McAdams, (C) 2002\n");
printf( "Forked again by Xelerance (www.xelerance.com) (C) 2006\n");
printf( "Listening on IP address %s, port %d\n", IPADDY6(gconfig.ipaddr.listenaddr6)
, gconfig.port); //printing IP addr on screen
lac = laclist6;
while (lac)
{
if (lac->autodial)
{
#ifdef DEBUG_MAGIC
l2tp_log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
lac->entname[0] ? lac->entname : "(unnamed)");
#endif
lac->active = -1;
switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */
magic_lac_dial6 (lac);
}
lac = lac->next;
}
}
void init (int argc,char *argv[])
{
struct lac *lac;
struct in_addr listenaddr;
struct utsname uts;
init_args (argc,argv);
srand( time(NULL) );
rand_source = 0;
init_addr ();
if (init_config ())
{
l2tp_log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
exit (1);
}
if (uname (&uts)<0)
{
l2tp_log (LOG_CRIT, "%s : Unable to determine host system\n",
__FUNCTION__);
exit (1);
}
init_tunnel_list (&tunnels);
if (init_network ())
exit (1);
if (gconfig.daemon)
daemonize ();
consider_pidfile();
signal (SIGTERM, &sigterm_handler);
signal (SIGINT, &sigint_handler);
signal (SIGCHLD, &sigchld_handler);
signal (SIGUSR1, &sigusr1_handler);
signal (SIGHUP, &sighup_handler);
init_scheduler ();
unlink(gconfig.controlfile);
mkfifo (gconfig.controlfile, 0600);
open_controlfd();
l2tp_log (LOG_INFO, "xl2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());
l2tp_log (LOG_INFO,
"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
l2tp_log (LOG_INFO, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
l2tp_log (LOG_INFO, "Inherited by Jeff McAdams, (C) 2002\n");
l2tp_log (LOG_INFO, "Forked again by Xelerance (www.xelerance.com) (C) 2006\n");
listenaddr.s_addr = gconfig.listenaddr;
l2tp_log (LOG_INFO, "Listening on IP address %s, port %d\n",
inet_ntoa(listenaddr), gconfig.port);
lac = laclist;
while (lac)
{
if (lac->autodial)
{
#ifdef DEBUG_MAGIC
l2tp_log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
lac->entname[0] ? lac->entname : "(unnamed)");
#endif
lac->active = -1;
switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */
magic_lac_dial (lac);
}
lac = lac->next;
}
}
int main_loop(struct multiboot_info *boot_info)
{
_kclear();
syscall_init();
module_start = (char*) *((unsigned int*)boot_info->mods_addr);
module_end = *((unsigned int*)(boot_info->mods_addr+4));
_kcolor(BRIGHT_GREEN);
_kputs(DREAMOS_VER);
_kcolor(WHITE);
_kputs(LNG_SITE);
_kcolor(BRIGHT_BLUE);
_kputs(SITEURL);
_kputs("\n");
_kcolor(WHITE);
_kputs("\n");
_kputs(LNG_GDT);
init_gdt();
_kprintOK();
outportb(0xFF, MASTER_PORT_1);
outportb(0xFF, SLAVE_PORT_1);
_kputs(LNG_IDT);
asm("cli");
init_idt();
_kprintOK();
_kputs(LNG_PIC8259);
init_IRQ();
_kprintOK();
set_memorysize((boot_info->mem_upper+boot_info->mem_lower)*1024);
init_mem();
asm("sti");
_kprintOK();
init_paging();
_kprintOK();
printf("Memory (upper) amount-> %d Mb \n", boot_info->mem_upper/1024);
printf("Memory (lower) amount-> %d kb \n", boot_info->mem_lower);
/** Alloc and fill CPUID structure */
sinfo = kmalloc(sizeof(struct cpuinfo_generic));
get_cpuid (sinfo);
vfs_init();
initfs_init();
if(boot_info->mods_count > 0) printf("Found n. %d Modules\n", boot_info->mods_count);
printf("\n");
tasks_init();
init_scheduler();
_kprintOK();
printf(LNG_PIT8253);
printf("----\n");
printf(LNG_SHELL);
_kprintOK();
printf("[+] Address: 0x%x\n", &end);
printf("\n");
dbg_bochs_print((const unsigned char*)"DreamOS Debug String for Bochs\n");
#ifdef BOCHS_DEBUG
dbg_bochs_print((const unsigned char*)"DreamOS Debug String for Bochs\n");
#endif
configure_PIT ();
new_task("idle", idle);
new_task("dreamshell", shell);
return 0;
}
int init_essentials(void) {
init_scheduler();
return 0;
}
CAgentManager::CAgentManager ()
{
init_scheduler ();
init_components ();
}
