int segm_fault () { #if TEST == 1 printf ( "\nInterrupt test >>>\n" ); arch_register_interrupt_handler ( SOFTWARE_INTERRUPT, test1 ); arch_register_interrupt_handler ( SOFTWARE_INTERRUPT, test1 ); raise_interrupt ( SOFTWARE_INTERRUPT ); printf ( "Interrupt test <<<\n\n" ); #else unsigned int *p; unsigned int i, j=0; printf ( "Example program: [%s:%s]\n%s\n\n", __FILE__, __FUNCTION__, segm_fault_PROG_HELP ); printf ( "Before segmentation fault\n" ); for ( i = 16; i < 32; i++ ) { p = (unsigned int *) (1 << i); printf ( "[%x]=%d\n", p, *p ); j+= *p; } printf ( "After expected segmentation fault, j=%d\n", j ); #endif return 0; }
/*! * First kernel function (after boot loader loads it to memory) */ void k_startup () { extern console_t K_INITIAL_STDOUT, K_STDOUT; extern console_t *k_stdout; /* console for kernel messages */ /* set initial stdout */ k_stdout = &K_INITIAL_STDOUT; k_stdout->init (0); /* initialize memory subsystem (needed for boot) */ k_memory_init (); /*! start with regular initialization */ /* interrupts */ arch_init_interrupts (); /* detect memory faults (qemu do not detect segment violations!) */ arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault ); arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault ); /* switch to default 'stdout' for kernel */ k_stdout = &K_STDOUT; k_stdout->init (0); kprintf ( "%s\n", system_info ); /* enable interrupts */ enable_interrupts (); stdio_init (); /* initialize standard output devices */ /* start desired program(s) */ hello_world (); segm_fault (); #if ( TURN_OFF == 0 ) kprintf ( "\nSystem halted!\n" ); #ifdef PL190 /* testing uart (arm) interrupts */ void uart0_echo_test_start (); uart0_echo_test_start (); suspend(); #endif halt (); #else /* power off (if supported, or just stop if not) */ kprintf ( "Powering off\n\n" ); power_off (); #endif }
static void test_interrupts () { /* processor interrupts are usualy fatal - can't recover easy! */ arch_register_interrupt_handler ( 0, processor_irq_handler ); arch_register_interrupt_handler ( 5, processor_irq_handler ); arch_register_interrupt_handler ( 10, processor_irq_handler ); arch_register_interrupt_handler ( 15, processor_irq_handler ); /* interrupts generated outside processor */ arch_register_interrupt_handler ( 32, device_irq_handler ); arch_register_interrupt_handler ( 35, device_irq_handler ); arch_register_interrupt_handler ( 37, device_irq_handler ); arch_register_interrupt_handler ( 39, device_irq_handler ); /* irq number outside allowed range */ //arch_register_interrupt_handler ( 60, device_irq_handler ); /* raise a few interrupts (comment/uncomment for testing) */ //raise_interrupt ( 0 ); //raise_interrupt ( 1 ); //raise_interrupt ( 5 ); //raise_interrupt ( 7 ); //raise_interrupt ( 10 ); //raise_interrupt ( 20 ); raise_interrupt ( 32 ); raise_interrupt ( 35 ); raise_interrupt ( 38 ); }
/*! * First kernel function (after boot loader loads it to memory) */ void k_startup () { extern void *k_stdout; /* console for kernel messages */ /* set initial stdout */ kdevice_set_initial_stdout (); /* initialize memory subsystem (needed for boot) */ k_memory_init (); /*! start with regular initialization */ /* interrupts */ arch_init_interrupts (); /* detect memory faults (qemu do not detect segment violations!) */ arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault, NULL ); arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault, NULL ); /* timer subsystem */ k_time_init (); /* devices */ k_devices_init (); /* switch to default 'stdout' for kernel */ k_stdout = k_device_open ( K_STDOUT, O_WRONLY ); kprintf ( "%s\n", system_info ); /* enable interrupts */ enable_interrupts (); stdio_init (); /* initialize standard input & output devices */ /* start desired program(s) */ hello_world (); keyboard (); timer (); /* segm_fault (); */ #if ( TURN_OFF == 0 ) kprintf ( "\nSystem halted!\n" ); halt (); #else /* power off (if supported, or just stop if not) */ kprintf ( "Powering off\n\n" ); power_off (); #endif }
/*! * First kernel function (after boot loader loads it to memory) */ void k_startup () { extern void *k_stdout; /* console for kernel messages */ extern prog_info_t pi; /* set initial stdout */ kdevice_set_initial_stdout (); /* initialize memory subsystem (needed for boot) */ k_memory_init (); /*! start with regular initialization */ /* interrupts */ arch_init_interrupts (); /* detect memory faults (qemu do not detect segment violations!) */ arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault, NULL ); arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault, NULL ); /* timer subsystem */ k_time_init (); /* devices */ k_devices_init (); /* switch to default 'stdout' for kernel */ k_stdout = k_device_open ( K_STDOUT, O_WRONLY ); kprintf ( "%s\n", system_info ); pi.heap = kmalloc ( PROG_HEAP_SIZE ); pi.heap_size = PROG_HEAP_SIZE; /* enable interrupts */ enable_interrupts (); /* starting program routine */ prog_init ( NULL ); #if ( TURN_OFF == 0 ) kprintf ( "\nSystem halted!\n" ); halt (); #else /* power off (if supported, or just stop if not) */ kprintf ( "Powering off\n\n" ); power_off (); #endif }
/*! Initialize device (and call its initializer, if set) */ int k_device_init ( kdevice_t *kdev, int flags, void *params, void *callback ) { int retval = 0; ASSERT ( kdev ); if ( flags ) kdev->dev.flags = flags; if ( params ) kdev->dev.params = params; if ( kdev->dev.init ) retval = kdev->dev.init ( flags, params, &kdev->dev ); if ( !retval && kdev->dev.irq_handler ) { (void) arch_register_interrupt_handler ( kdev->dev.irq_num, kdev->dev.irq_handler, &kdev->dev ); arch_irq_enable ( kdev->dev.irq_num ); } if ( callback ) kdev->dev.callback = callback; return retval; }
/*! Init console with interrupt enable */ void uart0_echo_test_start () { volatile unsigned int *uart_imsc = (unsigned int *) UART0_IMSC; /* enable RXIM interrupt (interrupt on data receive) */ *uart_imsc = 1 << 4; /* register UART interrupt */ arch_register_interrupt_handler ( IRQ_OFFSET + UART0IRQL, uart_echo, NULL ); /* enable UART interrupt in VIC */ arch_irq_enable ( IRQ_OFFSET + UART0IRQL ); }