int __noreturn
kern_init(void) {
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
cprintf("%s\n\n", message);
print_kerninfo();
pmm_init(); // init physical memory management
pic_init(); // init interrupt controller
idt_init(); // init interrupt descriptor table
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
sync_init(); // init sync struct
ide_init(); // init ide devices
swap_init(); // init swap
fs_init(); // init fs
clock_init(); // init clock interrupt
intr_enable(); // enable irq interrupt
cpu_idle(); // run idle process
}
int main()
{
unsigned long i = 0, cnt = 0;
unsigned char c;
GPBCON = GPB7_out|GPB8_out|GPB9_out|GPB10_out;
init_uart( ); //波特率57600，8N1(8个数据位，无校验位，1个停止位)
DPRINTK(KERNEL_DEBUG,"\n\rkernel:enter main\n\r");
sched_init( );
// OS_ENTER_CRITICAL();
OSCreateProcess(15*1024,1024,NULL,NULL,5);
DPRINTK(KERNEL_DEBUG,"\n\rkernel:first\n\r");
while(1){
// schedule();
// DPRINTK(KERNEL_DEBUG,"kernel:main\n\r");
/* if(i&1){
DPRINTK(KERNEL_DEBUG,"1\n\r");
}
*/
// GPBDAT = (~(++i))<<7;
DPRINTK(KERNEL_DEBUG,"kernel:process 0\n\r");
wait(1000000);
}
return 0;
}
int main(void)
{
sched_init(); /* initialize the scheduler */
led_init(); /* initialize led */
button_init(); /* initialize button */
adc_init(); /* initialize ADC (battery voltage measurement) */
serial_init(); /* initialize serial communication */
wheel_init(); /* initialize encoders, PWM output, PID etc. */
pid_interval = 50; /* default PID update interval 50ms */
pid_rate = 1000/pid_interval; /* [Hz] always remember after setting pid_interval */
pfbst_interval = 20; /* send $PFBST at 20 ms interval */
nmea_wd_timeout = 1; /* set PFBCT watchdog timeout to 100ms */
nmea_wd = NMEA_WD_TOUT+1; /* make sure we begin in watchdog timeout state */
voltage_min = VOLTAGE_MIN_DEFAULT;
battery_low_warning = false;
state_update();
sei(); /* enable interrupts */
nmea_init(); /* initialize nmea protocol handler */
for (;;) /* go into an endless loop */
{
/* motor_update(); */
if (t1ms != 0) /* if the interrupt has timed out after 10ms */
{
t1ms --;
sched_update(); /* run the scheduler */
}
else
{
nmea_rx_update();
}
}
return 0; /* just for the principle as we never get here */
}
void threads_test_case(int nthreads, int nyields)
{
test_thread_param_t* params = calloc(nthreads, sizeof(test_thread_param_t));
int counter = 0;
int i;
printf("Started test case with %d threads, each yielding %d times.\n", nthreads, nyields);
for (i=0;i<nthreads;++i)
{
params[i].global_counter = &counter;
params[i].nthreads = nthreads;
params[i].num_yields = nyields;
params[i].thread_id = i;
}
thread_manager_init(sched_init(stFifo));
for (i=0;i<nthreads;++i)
{
create_thread(&test_thread, ¶ms[i]);
// printf("Thread %d created.\n", i);
}
// printf("Starting threads.\n");
threads_start();
// printf("All threads finished.\n");
}
static int __init resch_init(void)
{
int ret;
printk(KERN_INFO "RESCH: HELLO!\n");
/* get the device number of a char device. */
ret = alloc_chrdev_region(&dev_id, 0, 1, MODULE_NAME);
if (ret < 0) {
printk(KERN_WARNING "RESCH: failed to allocate device.\n");
return ret;
}
/* initialize the char device. */
cdev_init(&c_dev, &resch_fops);
/* register the char device. */
ret = cdev_add(&c_dev, dev_id, 1);
if (ret < 0) {
printk(KERN_WARNING "RESCH: failed to register device.\n");
return ret;
}
sched_init();
component_init();
return 0;
}
void filesystem_init() {
sched_init();
int a;
int b;
int c;
c = a+b;
printf("%s %d: %s()\n", __FILE__, __LINE__, __FUNCTION__);
}
void network_init() {
sched_init();
int a;
int b;
int c;
c = a+b;
printf("%s %d: %s()\n", __FILE__, __LINE__, __FUNCTION__);
}
void start_sched()
{
int rc = sched_init();
if (rc)
return;
sched_start_idle();
}
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 */
}
void main(void) /* This really IS void, no error here. */
{ /* The startup routine assumes (well, ...) this */
/*
* Interrupts are still disabled. Do necessary setups, then
* enable them
*/
ROOT_DEV = ORIG_ROOT_DEV;
drive_info = DRIVE_INFO;
memory_end = (1<<20) + (EXT_MEM_K<<10);
memory_end &= 0xfffff000;
if (memory_end > 16*1024*1024)
memory_end = 16*1024*1024;
if (memory_end > 12*1024*1024)
buffer_memory_end = 4*1024*1024;
else if (memory_end > 6*1024*1024)
buffer_memory_end = 2*1024*1024;
else
buffer_memory_end = 1*1024*1024;
main_memory_start = buffer_memory_end;
#ifdef RAMDISK
main_memory_start += rd_init(main_memory_start, RAMDISK*1024);
#endif
mem_init(main_memory_start,memory_end);
trap_init();
blk_dev_init();
chr_dev_init();
tty_init();
time_init();
sched_init();
buffer_init(buffer_memory_end);
hd_init();
floppy_init();
sti();
move_to_user_mode();
setup((void *) &drive_info);
(void) open("/dev/tty0",O_RDWR,0);
(void) dup(0);
(void) dup(0);
(void) open("/var/process.log",O_CREAT|O_TRUNC|O_WRONLY,0666);
#ifdef dis_func
(void) open("/var/dis_func.log",O_CREAT|O_TRUNC|O_WRONLY,0666);
#endif
if (!fork()) { /* we count on this going ok */
init();
}
/*
* NOTE!! For any other task 'pause()' would mean we have to get a
* signal to awaken, but task0 is the sole exception (see 'schedule()')
* as task 0 gets activated at every idle moment (when no other tasks
* can run). For task0 'pause()' just means we go check if some other
* task can run, and if not we return here.
*/
for(;;) pause();
}
int main() {
sched_init();
mythread_start(thread_function1, NULL);
mythread_start(thread_function2, NULL);
mythread_start(thread_function3, NULL);
timer_setup(sig_timer_handler, 25000);
while(1) ;
return 0;
}
int main(int argc, char **argv) {
struct sigaction sa;
sa.sa_flags=0;
sigemptyset(&sa.sa_mask);
sa.sa_handler=abrt_handler;
sigaction(SIGABRT,&sa,NULL);
sched_init(test_fn);
fprintf(stdout, "Should not ever get here.\n");
return 0;
}
/*
* Initialization code.
*
* Called from kernel_start() routine that is
* implemented in HAL.
* We assume that the following machine state has
* been already set before this routine.
* - Kernel BSS section is filled with 0.
* - Kernel stack is configured.
* - All interrupts are disabled.
* - Minimum page table is set. (MMU systems only)
*/
int
main(void)
{
sched_lock();
diag_init();
DPRINTF((BANNER));
/*
* Initialize memory managers.
*/
page_init();
kmem_init();
/*
* Do machine-dependent
* initialization.
*/
machine_startup();
/*
* Initialize kernel core.
*/
vm_init();
task_init();
thread_init();
sched_init();
exception_init();
timer_init();
object_init();
msg_init();
/*
* Enable interrupt and
* initialize devices.
*/
irq_init();
clock_init();
device_init();
/*
* Set up boot tasks.
*/
task_bootstrap();
/*
* Start scheduler and
* enter idle loop.
*/
sched_unlock();
thread_idle();
/* NOTREACHED */
return 0;
}
main()
{
struct sigaction sa;
sa.sa_flags=0;
sa.sa_handler=wakeup_handler;
sigemptyset(&sa.sa_mask);
sigaction(SIGUSR1,&sa,NULL);
sigaction(SIGUSR2,&sa,NULL);
sched_init(init_fn);
fprintf(stderr,"Whoops\n");
}
int main() {
sched_init();
mtx_yield_init(&m);
thread_t *t1 = thread_create("t1", demo_thread_1);
thread_t *t2 = thread_create("t2", demo_thread_2);
sched_add(t1);
sched_add(t2);
sched_run(10);
}
/*! \details This function initializes the hardware
*
*/
void init_hw(void){
_hwpl_core_setclock(cpu_init_freq, microcomputer_osc_freq); //Set the main clock
hwpl_fault_init();
_hwpl_core_priv_enable_interrupts(NULL); //Enable the interrupts
if ( sched_init() < 0 ){ //Initialize the hardware used for the scheduler
_hwpl_core_priv_disable_interrupts(NULL);
gled_priv_error(0);
}
check_reset_source();
}
/**
* 主核初始化
*/
asmlinkage void __init start_master(void)
{
debug_printstr_mmu("xby_debug, start cpu 0\n");
local_irq_disable();
//tick_init();
/* 为当前CPU设置其活动掩码 */
boot_cpu_init();
/* 体系结构特定的初始化过程 */
start_arch();
//初始化boot内存分配器
InitBootMemory(0xc0000000 + 8 * 1024 * 1024, 0xc0000000 + 24 * 1024 * 1024);
init_IRQ();
//体系结构和驱动的一些初始化过程
//run_initcall();
//为VFS分配一些大的内存块，用于哈希表。此过程必须在boot阶段分配。
//vfs_caches_init_early();
#ifdef FS
blk_dev_init();
inode_init();
file_table_init();
name_cache_init();
buffer_init_early();
#endif
memory_init();
#ifdef FS
buffer_init_tail();
tty_init();
#endif
sched_init();
time_init();
setup_timer();
serial_init();
//mmc_init();
//omap_gpio_init();
//初始化文件系统
//vfs_caches_init(num_physpages);
local_irq_enable();
//创建系统任务，以及用户任务入口
TaskEntry();
cpu_idle();
//不可能运行到这里来
BUG();
}
int main(void)
{
trap_init();
sched_init();
sti();
move_to_user_mode();
myprint("In kernel");
while(1){}
return 0;
}
int main(void)
{
irq_init();
irq_disable();
#ifdef CONFIG_FPU
*SCB_CPACR |= (SCB_CPACR_CP10_FULL | SCB_CPACR_CP11_FULL);
#endif
#ifdef CONFIG_DEBUG
dbg_device_init();
dbg_layer = DL_KDB;
#endif
__l4_printf("%s", banner);
run_init_hook(INIT_LEVEL_PLATFORM);
#ifdef CONFIG_SYMMAP
ksym_init();
#endif
sched_init();
memory_init();
syscall_init();
thread_init_subsys();
ktimer_event_init();
#ifdef CONFIG_KPROBES
kprobe_init();
#endif /* CONFIG_KPROBES */
#ifdef CONFIG_KDB
softirq_register(KDB_SOFTIRQ, debug_kdb_handler);
dbg_puts("Press '?' to print KDB menu\n");
#endif
run_init_hook(INIT_LEVEL_KERNEL);
/* Not creating kernel thread here because it corrupts current stack
*/
create_idle_thread();
create_root_thread();
ktimer_event_create(64, ipc_deliver, NULL);
mpu_enable(MPU_ENABLED);
run_init_hook(INIT_LEVEL_LAST);
switch_to_kernel();
/* Not reached */
return 0;
}
/* Entry point in to the kernel proper */
_noreturn _asmlinkage void setup(multiboot_info_t *mbi)
{
serio_init();
vga_preinit();
/* Need this mmediately to catch exceptions */
idt_init();
/* print a pretty message */
printk("ScaraOS v0.0.7 for IA-32");
if ( mbi->flags & MBF_CMDLINE ) {
cmdline = __va(mbi->cmdline);
printk(": %s", cmdline);
}
printk("\n");
/* Prints out CPU MHz */
calibrate_delay_loop();
/* Identify CPU features, also needs to be early because
* mm init may need to know which paging features are
* available
*/
cpuid_init();
/* Fire up the kernel memory allocators */
BUG_ON((mbi->flags & MBF_MMAP) == 0);
ia32_mm_init(__va(mbi->mmap), mbi->mmap_length);
/* setup the idle task */
sched_init();
ia32_gdt_finalize();
/* enable hardware interrupts */
pic_init();
/* start jiffie counter */
pit_start_timer1();
/* initialise fdt logic ready for use */
_fdt_init();
/* Setup the init task */
kernel_thread("[init]", init_task, NULL);
/* Finally, enable interupts and let it rip */
sti();
sched();
idle_task_func();
}
void start_hypervisor()
{
int i;
uint8_t nr_vcpus = 1; // TODO: It will be read from configuration file.
uint32_t pcpu = smp_processor_id();
if (pcpu == 0) {
timemanager_init();
sched_init();
vm_setup();
for (i = 0; i < NUM_GUESTS_STATIC; i++) {
vmid_t vmid;
if ((vmid = vm_create(nr_vcpus)) == VM_CREATE_FAILED) {
printf("vm_create(vm[%d]) is failed\n", i);
goto error;
}
if (vm_init(vmid) != HALTED) {
printf("vm_init(vm[%d]) is failed\n", i);
goto error;
}
if (vm_start(vmid) != RUNNING) {
printf("vm_start(vm[%d]) is failed\n", i);
goto error;
}
}
smp_pen = 1;
} else {
while (!smp_pen) ;
printf("cpu[%d] is enabled\n", pcpu);
}
/*
* TODO: Add a function - return vmid or vcpu_id to execute for the first time.
* TODO: Rename guest_sched_start to do_schedule or something others.
* do_schedule(vmid) or do_schedule(vcpu_id)
*/
printf("sched_start!!!\n");
sched_start();
/* The code flow must not reach here */
error:
printf("-------- [%s] ERROR: K-Hypervisor must not reach here\n", __func__);
abort();
}
/*
* initialisation function
* We start here as soon as we have a stack.
* Here we initialize the various systems
* and devices that need to be initialized.
*/
STARTUP(void kmain())
{
// TODO: move these to the appropriate headers
void vtinit();
void grayinit();
void loadavinit();
void battinit();
void usageinit();
void bogomips();
calloutinit();
lcdinit();
meminit();
grayinit();
vtinit();
linkinit();
audioinit();
sched_init();
procinit();
bufinit();
flashinit();
inodeinit();
loadavinit();
battinit();
usageinit();
#if 1
kprintf("%s build %s\n", uname_sysname, uname_version);
#else
kprintf("%s v%s\n", uname_sysname, uname_release);
kputs(
"Copyright 2005-2011 Christopher Williams <*****@*****.**>\n"
"Some portions copyright 2003, 2005 PpHd\n"
"\n"
"This program comes with ABSOLUTELY NO WARRANTY.\n"
"You may redistribute copies of this program\n"
"under the terms of the GNU General Public License.\n"
"\n");
#endif
if (realtime.tv_sec < 1000000000L) { /* before ~2001 */
extern const unsigned long build_date;
realtime.tv_sec = build_date;
realtime.tv_nsec = 0;
}
G.seconds = realtime.tv_sec;
uptime.tv_sec = uptime.tv_nsec = 0;
spl0();
bogomips();
}
void kmain( void )
{
sched_init();
p1=create_process((func_t*)&user_process_1);
p2=create_process((func_t*)&user_process_2);
__asm("cps 0x10"); // switch CPU to USER mode
// **********************************************************************
sys_yieldto(p1);
// this is now unreachable
PANIC();
}
void
kern_init()
{
kprintf("Loading IncOS ...\n");
vm_init();
proc_init();
sched_init();
run_boot_modules();
enable_interrupts();
for (;;);
}
void kmain()
{
irq_disable();
/*
* A primeira coisa a se fazer é iniciar todo o gerenciador
* de memória.
*/
mm_init();
arch_early_init();
ioremap_init();
irq_init();
sched_init();
timer_init();
/*
* Neste momento temos o gerenciador de memória e escalonador prontos,
* já podemos habilitar as interrupções, que podem ser utilizadas
* pelos drivers.
*/
irq_enable();
/* Inicia os drivers da plataforma */
arch_setup();
/* Requisita um modo se existir um framebuffer*/
fb_set_mode();
/* Inicia o console sobre o framebuffer */
fb_console_init();
kernel_info();
#if 1
irq_disable();
semaphore_init(&sem, 1);
create_task("a", 4);
create_task("b", 5);
create_task("c", 6);
create_task("d", 7);
create_task("b", 8);
create_task("b", 9);
irq_enable();
/* Fica de boas esperando as trocas de contexto */
#endif
/* Como queremos imprimir para depuração do driver, inicializamos ele agora */
//bcm2835_emmc_init();
for (;;) {
led_blink();
//printk("-");
}
}
void __noreturn
kern_init(void) {
//setup_exception_vector();
tlb_invalidate_all();
/*
unsigned base = 0xBE000000;
int i, j;
for (j = 10; j < 24; ++j) {
kprintf("\nj=%d\n\n\n", j);
for (i = 0; i < 10; ++i) {
int *addr = (int*)(base + i * 4 + (1 << j));
kprintf("0x%08x=0x%04x\n", addr, (*addr)&0xFFFF);
}
}
*/
pic_init(); // init interrupt controller
cons_init(); // init the console
clock_init(); // init clock interrupt
// panic("init");
check_initrd();
const char *message = "(THU.CST) os is loading ...\n\n";
kprintf(message);
print_kerninfo();
#if 0
kprintf("EX\n");
__asm__ volatile("syscall");
kprintf("EX RET\n");
#endif
pmm_init(); // init physical memory management
vmm_init(); // init virtual memory management
sched_init();
proc_init(); // init process table
ide_init();
fs_init();
intr_enable(); // enable irq interrupt
//*(int*)(0x00124) = 0x432;
//asm volatile("divu $1, $1, $1");
cpu_idle();
}
static int sched_start_init(void) {
struct schedee *current;
int err;
current = boot_thread_create(); /* 'init' thread ID=1 */
assert(current != NULL);
err = sched_init(current);
if (err) {
return err;
}
err = idle_thread_create(); /* idle thread always has ID=0 */
return err;
}
/*
* This is the kernel main routine. When the boot process is completed, this
* function is called.
*/
void start_kernel(void) {
int pid, i;
char *names[N_CONSOLES] = { "PRG1", "PRG2", "PRG3",
"PRG4", "PRG5", "PRG6" };
// init traps
init_traps();
// initialize IRQs
init_irq();
// initialize the tty driver. The tty is composed by a keyboard driver
// that read input keys a print the relative ASCII code on video.
tty_init();
// initialize the timer.
time_init();
// initialize the scheduler
sched_init();
printk("Kernel info: %u bytes, start at 0x%x0 end at 0x%x0.\n",
&__KERNEL_END__-K_START, K_START, &__KERNEL_END__);
sti();
// calibrate delay
calibrate_delay();
// floppy driver initialization
floppy_init();
// switch in user mode
move_to_user_mode();
// for a process for each console and execute the program PRGi
for (i=0; i<N_CONSOLES; ++i) {
// spawn process i and run PRG1
pid = fork();
if (pid == 0) {
exec(names[i]);
} else if (pid < 0) {
print("idle: cannot duplicate myself.\n");
}
}
print("Idle: ok!\n");
// idle loop
while(1);
}
int main(void)
{
navilnux_init();
navilnux_user();
if( sched_init() < 0 )
{
printf("Kernel Pannic!\n");
return -1;
}
int i;
for(i = 0 ; i <= taskmng.max_task_id ; i++)
{
printf("TCB : TASK%d - init PC(%p) \t init SP(%p)\n", i+1,
taskmng.free_task_pool[i].context_pc,
taskmng.free_task_pool[i].context_sp);
}
printf("REAL func TASK1 : %p\n", user_task_1);
printf("REAL func TASK2 : %p\n", user_task_2);
printf("REAL func TASK3 : %p\n", user_task_3);
irq_enable();
while( 1 )
{
msleep(1000);
}
return 0;
//2684387328 2684402240
#if 0
int i = 0;
while( 1 )
{
GPIO_SetLED( i, LED_OFF );
__asm("swi 77");
msleep( 1000 );
GPIO_SetLED( i, LED_ON );
i++;
if( i >= 4 ) i = 0;
}
return 0;
#endif
}
void main(void) /* This really IS void, no error here. */
{ /* The startup routine assumes (well, ...) this */
/*
* Interrupts are still disabled. Do necessary setups, then
* enable them
*/
ROOT_DEV = ORIG_ROOT_DEV;
drive_info = DRIVE_INFO;
memory_end = (1<<20) + (EXT_MEM_K<<10);
memory_end &= 0xfffff000;
if (memory_end > 16*1024*1024)
memory_end = 16*1024*1024;
if (memory_end > 12*1024*1024)
buffer_memory_end = 4*1024*1024;
else if (memory_end > 6*1024*1024)
buffer_memory_end = 2*1024*1024;
else
buffer_memory_end = 1*1024*1024;
main_memory_start = buffer_memory_end;
#ifdef RAMDISK
main_memory_start += rd_init(main_memory_start, RAMDISK*1024);
#endif
mem_init(main_memory_start,memory_end);
trap_init(); /* set the IDT in 0x00080000~0x000807ff(4KB)*/
blk_dev_init();
chr_dev_init(); /* this function do nothing */
tty_init(); /* rs_init() and con_init() */
time_init();
sched_init();
buffer_init(buffer_memory_end);
hd_init();
floppy_init();
sti();
move_to_user_mode();
if (!fork()) { /* we count on this going ok */
init();
}
/*
* NOTE!! For any other task 'pause()' would mean we have to get a
* signal to awaken, but task0 is the sole exception (see 'schedule()')
* as task 0 gets activated at every idle moment (when no other tasks
* can run). For task0 'pause()' just means we go check if some other
* task can run, and if not we return here.
*/
for(;;) pause();
}
