int main(struct multiboot *mboot_ptr)
{
// All our initialisation calls will go in here.
init_descriptor_tables();
monitor_clear();
initialise_paging();
// init_timer(3);
int res = 0;
monitor_clear();
monitor_write(str);
monitor_write("\n\r");
monitor_write_hex(0xbadacacd);
monitor_write_hex(0xbada0000);
monitor_write("\n\r");
monitor_write_dec(0xadacacd);
monitor_write("\n\r");
monitor_write_dec(1234567890);
//memcpy(0xb8000+80*2*5,0xb8000,80*2*5);
//memset(0xb8000,76,80*2*5);
asm volatile ("int $0x3");
//u32int *ptr = (u32int*)0x0ffffff;
//u32int do_page_fault = *ptr;
return 0;
}
static void timer_callback (registers_t *regs)
{
tick++;
monitor_write("Tick: ");
monitor_write_dec(tick);
monitor_write("\n");
}
// This gets called from our ASM interrupt handler stub.
void irq_handler(registers_t regs)
{
// Send an EOI (end of interrupt) signal to the PICs.
// If this interrupt involved the slave.
if (regs.int_no >= 40)
{
// Send reset signal to slave.
outb(0xA0, 0x20);
}
// Send reset signal to master. (As well as slave, if necessary).
outb(0x20, 0x20);
if (interrupt_handlers[regs.int_no] != 0)
{
isr_t handler = interrupt_handlers[regs.int_no];
handler(regs);
}
else
{
// Unhandled IRQ, log it !
monitor_set_forecolor(e_color_magenta);
monitor_write("IRQ");
monitor_write_hex(regs.int_no);
monitor_write(" raised!\n");
monitor_set_forecolor(e_color_white);
}
}
int main(struct multiboot *mboot_ptr)
{
monitor_clear();
monitor_write("Initializing GDT...\n");
init_descriptor_tables();
monitor_write("GDT initialized.\n");
//asm volatile("int $0x3");
//asm volatile("int $0x4");
//asm volatile("sti");
//init_timer(50);
initialise_paging();
monitor_write("Paging initialized.\n");
/*u32int *ptr = (u32int*)0xA0000000;*/
/*u32int do_page_fault = *ptr;*/
/*asm volatile ("int $0x3");*/
/*asm volatile ("int $0x4");*/
//monitor_write_dec(15);
//monitor_write_dec(-48281);
//monitor_write_dec(295180203);
/*monitor_write_hex(0xFF);*/
/*monitor_put('\n');*/
/*monitor_write_hex(0x0);*/
/*monitor_put('\n');*/
/*monitor_write_hex(0xFAFABABA);*/
/*monitor_put('\n');*/
/*monitor_write_hex(0xABA);*/
// All our initialisation calls will go in here.
return 0;
}
// C Interrupt dispatcher
void isr_handler(registers_t regs)
{
// This line is important. When the processor extends the 8-bit interrupt number
// to a 32bit value, it sign-extends, not zero extends. So if the most significant
// bit (0x80) is set, regs.int_no will be very large (about 0xffffff80).
u8int int_no = regs.int_no & 0xFF;
if (interrupt_handlers[int_no] != 0)
{
isr_t handler = interrupt_handlers[int_no];
handler(regs);
}
else
{
monitor_set_forecolor(e_color_magenta);
monitor_write("Unhandled interrupt #");
monitor_write_dec(int_no);
monitor_put('\n');
monitor_write("Message: ");
if(int_no < 32){
monitor_write(interrupt_messages[int_no - 1]);
monitor_put('\n');
}
monitor_set_forecolor(e_color_white);
// ERR!
PANIC("Unhandled interrupt");
}
}
/* All of our Exception handling Interrupt Service Routines will
* point to this function. This will tell us what exception has
* happened! Right now, we simply halt the system by hitting an
* endless loop. All ISRs disable interrupts while they are being
* serviced as a 'locking' mechanism to prevent an IRQ from
* happening and messing up kernel data structures */
static void fault_handler(unsigned int exc_no, registers_t regs, APTR Data, SysBase *SysBase)
{
if (exc_no < 32)
{
monitor_write(exception_messages[exc_no]);
monitor_write("[Exception]. System Halted!\n");
for (;;)asm volatile("hlt");
}
void isr_handler(regsiters_t regs)
{
monitor_write("recv inte");
monitor_write_dec(regs.int_no);
monitor_write("err code");
monitor_write_dec(regs.err_code);
monitor_put('\n');
}
void isr_handler(registers_t regs)
{
monitor_write("recv inte");
monitor_write_dec(regs.int_no);
monitor_write("err code");
monitor_write_dec(regs.err_code);
monitor_put('\n');
if(spec_handler[regs.int_no] != NULL){
spec_handler[regs.int_no](regs);
}
}
int main(struct multiboot *mboot_ptr)
{
// All our initialisation calls will go in here.
monitor_clear();
monitor_write("Hello world!\n");
monitor_write_hex(12345678);
monitor_write("\n");
monitor_write_dec(12345678);
monitor_write("\n");
return 0xDEADBABA;
}
void isr_handler(registers_t regs)
{
monitor_write_dec(z);
monitor_put('-');
monitor_write("recieved interrupt: ");
monitor_write_dec(regs.int_no);
monitor_write(", add: ");
monitor_write_hex(regs.cs);
monitor_put(':');
monitor_write_hex(regs.eip);
monitor_put('\n');
++z;
}
//写个struct mulitboot 省着老有警告 用的时候再改
//grub标准里有这个http://gnu.april.org/software/grub/manual/multiboot/multiboot.html
//struct multiboot{};
int kmain(struct multiboot_info* mboot_ptr)//name is mentioned in boot.s
{
init_gdt();
init_idt();
monitor_write("qhello!!@#$%^&*()[]+= bcdef:wworld! 1234");
monitor_write("\n");
monitor_write_hex(256);
monitor_write("finished");
monitor_write_dec(256);
monitor_write("done ss");
monitor_write_hex(kss);
monitor_write("done esp");
monitor_write_hex(kesp);
monitor_put('\n');
//init_gdt();
//init_idt();
asm volatile("int $0x3");
asm volatile("int $0x4");
prtf("aa bb %x %u %s 11\t \nbb\n", 10, 10, "str");
//asm volatile("sti");
//init_timer(500);
//monitor_write_hex((u32int)&end);
prtf("1\tend is at addr :%x end itself:%x kend:%x &kend:%x\n", (u32int)&end, end, kend, &kend);
/*旧的paging实现
init_paging();
prtf("paging enabled!\n");
u32int* ptr = (u32int*)0xa0000000;
*ptr = 1;
*/
//新的paging
//换了个管理物理内存的方法 这个没啥大区别
//分割物理内存管理 虚拟内存管理
//显式映射虚拟地址
//pmm里搞的都是物理地址 函数返回的也是物理地址
init_pmm ((u32int)&end, 1 << 25);//32MB
init_vmm ();
/*prtf("mboot_ptr : %x\n", mboot_ptr);//大概0x2d000 没到640k呢
prtf("mem_upper %x\n", mboot_ptr->mem_upper);*/
map(0xa0000000, 0x300000, PAGE_WRITE|PAGE_PRESENT);
prtf("mapped!\n");
u32int* ptr = (u32int*)0xa0000000;
*ptr = 1;
prtf("assigned!\n");
unmap(0xa0000000);
prtf("unmapped!\n");
*ptr = 2;
prtf("end!\n");
return 0xdeadbeef;
}
int main(struct multiboot *mboot_ptr)
{
// Initialise all the ISRs and segmentation
init_descriptor_tables();
// Initialise the screen (by clearing it)
monitor_clear();
// Find the location of our initial ramdisk.
ASSERT(mboot_ptr->mods_count > 0);
u32int initrd_location = *((u32int*)mboot_ptr->mods_addr);
u32int initrd_end = *(u32int*)(mboot_ptr->mods_addr+4);
// Don't trample our module with placement accesses, please!
placement_address = initrd_end;
// Start paging.
initialise_paging();
// Initialise the initial ramdisk, and set it as the filesystem root.
fs_root = initialise_initrd(initrd_location);
// list the contents of /
int i = 0;
struct dirent *node = 0;
while ( (node = readdir_fs(fs_root, i)) != 0)
{
monitor_write("Found file ");
monitor_write(node->name);
fs_node_t *fsnode = finddir_fs(fs_root, node->name);
if ((fsnode->flags&0x7) == FS_DIRECTORY)
{
monitor_write("\n\t(directory)\n");
}
else
{
monitor_write("\n\t contents: \"");
char buf[256];
u32int sz = read_fs(fsnode, 0, 256, buf);
int j;
for (j = 0; j < sz; j++)
monitor_put(buf[j]);
monitor_write("\"\n");
}
i++;
}
return 0;
}
u32int encode(u32int source,u32int sz)
{
//first layer
monitor_write("Version:");
monitor_write_dec(version);
monitor_put('\n');
u32int i=0;
u32int temp=0x1;
u32int result=0; // detect run by symbol 00
u8int marker=0x0;
u8int layer1[32];
while(i<32)
{ monitor_write_dec((source>>i)&0X3);
i++;
}
i=0;
while(i<32)
{ layer1[i]=0;// clearing garbage value
i++;
};
i=0;
while(i<32)
{
if(((source>>i)&0X3)==temp)
{
monitor_write("X:");
//monitor_put('\n');
monitor_write_dec(marker);
layer1[marker]=layer1[marker]+1;
monitor_write_dec(layer1[marker]);
//monitor_put('\n');
s(" ");
i++;
}
else {
temp+=1;
temp%=4;
marker++;
}
}
// This gets called from our ASM interrupt handler stub.
void isr_handler(registers_t regs)
{
if (interrupt_handlers[regs.int_no] != 0)
{
isr_t handler = interrupt_handlers[regs.int_no];
handler(regs);
}
else
{
monitor_write("UNhandled interrupt ..: %d ",regs.int_no);
newcls();
while(1);
monitor_write("\n");
}
}
void irq_handler(registers_t regs)
{
monitor_write("irq");
monitor_write_dec(regs.int_no);
monitor_write("err code");//0
monitor_write_dec(regs.err_code);
if(spec_handler[regs.int_no] != NULL){
spec_handler[regs.int_no](regs);
}
if(regs.int_no >= 40){
outb(0xa0, 0x20);
}
outb(0x20, 0x20);
}
int kmain(void* mbd, unsigned int magic)
{
// Initialise the screen (by clearing it)
monitor_clear();
// Alloc some memory
u8int mem;
memset(&mem, 32, 5);
monitor_write("Hello, world!\n");
monitor_write_bin(mem);
monitor_write("\n");
monitor_write_dec(mem);
return 0;
}
static void timer_irq_handler(registers_t regs)
{
static uint32_t tick = 0;
++tick;
monitor_write("Timer at:");
monitor_write_dec(tick);
}
int main(struct multiboot *mboot_ptr)
{
monitor_clear();
monitor_write("Hello, world");
return 0XDEADBABA;
}
/**------------------------------------------------------**/
void print_R(char* out, const char *format, ...)
{
LOG_FILETYPE stderr_f;
char buffer[64];
va_list argptr;
va_start(argptr, format);
VSNPRINTF(buffer, format, argptr);
va_end(argptr);
if(out == NULL)
{
printf_terminal(buffer);
}else
{
if(!monitor_openappend(out,&stderr_f))
{
if(!monitor_openwrite(out,&stderr_f))
{
return;
}
}
/* print to file */
(void)monitor_seek_end(&stderr_f);
(void)monitor_write(buffer,&stderr_f);
(void)monitor_close(&stderr_f);
}
}
// This gets called from our ASM interrupt handler stub.
void isr_handler(registers_t* regs)
{
monitor_write("recieved interrupt: ");
//monitor_write_dec(regs->int_no);
monitor_write_dec(5);
monitor_put('\n');
}
void isr_handler(registers_t regs)
{
monitor_write("received interrupt: ");
monitor_write_hex(regs.int_no);
monitor_put('\n');
if (interrupt_handlers[regs.int_no] != 0) {
isr_t handler = interrupt_handlers[regs.int_no];
handler(regs);
}
if (regs.int_no == 13) {
monitor_write("gp error : ");
monitor_write_hex(regs.err_code);
monitor_write("\n");
}
}
void fs_dump(int show_content)
{
int i = 0;
struct dirent *node = 0;
while ( (node = readdir_fs(fs_root, i)) != 0)
{
monitor_write("[Entity] ");
monitor_write(node->name);
fs_node_t *fsnode = finddir_fs(fs_root, node->name);
if ((fsnode->flags&0x7) == FS_DIRECTORY)
{
monitor_write("[Dir]\n");
}
else
{
monitor_write("[File]\n");
if(show_content)
{
monitor_write("\n\t Contents: \"");
char buf[256];
u32int sz = read_fs(fsnode, 0, 256, buf);
int j;
for (j = 0; j < sz; j++)
putch(buf[j]);
monitor_write("\n");
}
}
i++;
}
monitor_write("\n");
}
int main(struct multiboot *mboot_ptr)
{
// Initialise the screen (by clearing it)
monitor_clear();
// Write out a sample string
monitor_write("Hello, world!");
return 0;
}
void isr_handler(registers_t regs) {
if (interrupt_handlers[regs.int_no]) {
interrupt_handlers[regs.int_no](regs);
}
else {
monitor_write("unhandled interrupt: ");
monitor_write_dec(regs.int_no);
monitor_put('\n');
}
}
void main(struct multiboot *mboot_ptr) {
#include "common.h"
#include "monitor.h"
const char src[50] = "Hello World! Big brother is watching!";
char dest[50];
memcpy(dest, src, strlen(src));
memset(dest, 'F', strlen(dest));
monitor_clear();
monitor_write(dest);
}
void idt_handler (registers_t *regs)
{
if (interrupt_handlers [regs->int_no])
interrupt_handlers [regs->int_no] (regs);
else
{
monitor_write ("Unhandled interrupt: ");
monitor_write_dec (regs->int_no);
monitor_put ('\n');
}
}
static void timer_callback(registers_t regs)
{
regs = regs;
tick++;
if (tick % 200 == 0)
{
monitor_write("Tick: ");
monitor_write_dec(tick / 200);
monitor_put('\n');
}
}
void isr_handler(registers_t regs)
{
if (interrupt_handlers[regs.int_no] != 0) {
isr_t handler = interrupt_handlers[regs.int_no];
handler(regs);
} else {
monitor_write("received CPU interrupt: ");
monitor_write_dec(regs.int_no);
monitor_put('\n');
}
}
void isr_handler(registers_t regs){
u8int int_no = regs.int_no & 0xFF;
if(interrupt_handlers[int_no] != 0){
isr_t handler = interrupt_handlers[int_no];
handler(®s);
} else {
monitor_write("recieved interrupt: ");
monitor_write_dec(regs.int_no);
monitor_put('\n');
}
}
int main(struct multiboot *mboot_ptr)
{
// Initialise the screen (by clearing it)
init_descriptor_tables();
monitor_clear();
// Write out a sample string
// for(int i=0;i<26;i++)
monitor_write("Hello, world!\n");
asm volatile ("int $0x3");
// asm volatile ("int $0x4");
return 0;
}
