kernel.c

一个小型的操作系统,采用gcc进行开发,几千行的代码,方便初学者学习

	pos = 0xb8000 + x * 80 * 2 + y * 2;
	memcpy(savescr, (char *) pos, strlen(savescr));
	memcpy((char *) pos, scrtime, strlen(scrtime));
	cmosDelay(1);
	memcpy((char *) pos, savescr, strlen(savescr));
#else
	cmosDelay(2);
	VGAPrintStr_8x16(25, 68, rotation[k = (k--) % 4], 0);	/* rotation on 25,68 */
#endif
    }
}

void banner()
{
#define WHITE_TXT 0x07		/* white on black text */
#define FORWARD 1
#define BACKWARD -1
    int row = 1;
    int i = 31 * 2;
    char chs = 'A';
    char *vidmem = (char *) 0xb8000;
    int lr = FORWARD;
    unsigned short int k = 0;
    char *rotation[] = {
	"-", "\\", "|", "/",
    };

    while (1) {
#ifndef VIDEO_GRAPH_640X480
	if (i < 160 * row && lr == FORWARD) {
	    if (i == 49 * 2 * row)
		lr = BACKWARD;
	    vidmem[i] = '>';	/* chs; */
	    vidmem[i + 1] = WHITE_TXT;
	    cmosDelay(1);
	    vidmem[i + 1] = 00;
	    i += 2;
	} else if (i >= 160 * (row - 1) && lr == BACKWARD) {
	    if (i == 31 * 2 * row)
		lr = FORWARD;
	    i -= 2;
	    vidmem[i] = '<';	/* chs; */
	    vidmem[i + 1] = WHITE_TXT;
	    cmosDelay(1);
	    vidmem[i + 1] = 00;
	}
#else
	VGAPrintStr_8x16(25, 66, rotation[k = (k++) % 4], 1);	/* rotation on 25,66 */
	cmosDelay(1);
#endif
    }
}

#define RUNNABLE 1

void newTask(unsigned int taskEntrance, char *taskname)
{
#define TASKSTACK 0X9FFF0
    static unsigned int taskcnt = 0;
    taskData *taskP;
    taskP = (taskData *) malloc(sizeof(taskData));
    taskcnt++;

    taskP->cs = 0x08;
    taskP->ip = (unsigned int) taskEntrance;
    taskP->flag = 0x200;	/* interrupt enabled */
    taskP->state = RUNNABLE;
    taskP->ksts = 0;
    taskP->sp = TASKSTACK - (taskcnt - 1) * 0x1000;	/* 0x1000(4K) bytes/stack/task */
    taskP->bp = TASKSTACK - (taskcnt - 1) * 0x1000;
    taskP->pid = taskcnt;	/* task id */
    strncpy(taskP->taskName, taskname, 9);

    taskP->nextTaskLink = taskTail->nextTaskLink;
    taskTail->nextTaskLink = taskP;
    taskTail = taskP;
}

void initTask()
{				/* init a dummy task structure */
    task = (taskData *) malloc(sizeof(taskData));
    task->cs = 0x08;
    task->ip = (unsigned int) 0x00;	/* any integer */
    task->flag = 0x200;
    task->state = 0;		/* may not set task0's state RUNNABLE!! */
    task->ksts = 0;
    task->sp = (unsigned int) 0;	/* dummy spaceholder */
    task->bp = (unsigned int) 0;	/* dummy spaceholder */
    task->pid = (unsigned int) 0;
    strcpy(task->taskName, "dummy");
    task->nextTaskLink = task;
    taskTail = task;
    curTask = task;
}

void scheduler()
{
    /* Save state of running task in a task table slot */
    curTask->ax = eax_reg;
    curTask->bx = ebx_reg;
    curTask->cx = ecx_reg;
    curTask->dx = edx_reg;
    curTask->si = esi_reg;
    curTask->di = edi_reg;
    curTask->sp = esp_reg;
    curTask->bp = ebp_reg;
    curTask->flag = eflag_reg;
    curTask->cs = cs_reg;
    curTask->ip = eip_reg;
    curTask->ksts = 0;

    /* Choose the next task */
    while ((curTask->nextTaskLink)->state == 0)
	curTask = curTask->nextTaskLink;
    curTask = curTask->nextTaskLink;

    /* Restore new task state */
    eax_reg = curTask->ax;
    ebx_reg = curTask->bx;
    ecx_reg = curTask->cx;
    edx_reg = curTask->dx;
    esi_reg = curTask->si;
    edi_reg = curTask->di;
    esp_reg = curTask->sp;
    ebp_reg = curTask->bp;
    eflag_reg = curTask->flag;
    cs_reg = curTask->cs;
    eip_reg = curTask->ip;
    curTask->ksts = 1;
}

int rand()
{
    return tickcount % 100;
}

/* return PIT tickcount */
int get_count()
{
    return tickcount;
}

#define SIZE 20
/* insert sorting */
void insertSort()
{
//    char *buf;
//    int i, j, k;
//    buf = (char *) malloc(sizeof(char) * SIZE);
//    buf[0] = 0;
//    printf("insert sorting for the following\n");
//    /* produce random data whose value <100 */
//    for (i = 1; i < SIZE; i++) {
//      buf[i] = rand() % 100;
//      delayMS(100);
//      printf("%2d ", buf[i]);
//    }
//    printf("\nsorting in progress ...");
//    for (i = 2; i < SIZE; i++) {
//      if (buf[i] < buf[i - 1]) {
//          buf[0] = buf[i];
//          for (j = i - 1; buf[j] > buf[0]; j--) {
//              buf[j + 1] = buf[j];
//          }
//          buf[j + 1] = buf[0];
//      }
//      printf("\n");
//      for (k = 0; k < SIZE; k++) {
//          printf("%s%2d%s ", k == 0 ? "(" : "", buf[k],
//                 k == 0 ? ")" : "");
//      }
//    }
//    printf("\nsorting done\n");
//    for (i = 1; i < SIZE; i++) {
//      printf("%2d ", buf[i]);
//    }
//    printf("\n");
//    free(buf);
}

/* binary insert sorting, a improvement of the above insort() */
void binsort()
{
//    char *buf;
//    int i, j, k, low, high, mid, pos;
//    buf = (char *) malloc(sizeof(char) * SIZE);
//    buf[0] = 0;
//
//    printf("binary insert sorting for the following\n");
//    /* produce random data which value <100 */
//    for (i = 1; i < SIZE; i++) {
//      buf[i] = rand() % 100;
//      delayMS(100);
//      printf("%2d ", buf[i]);
//    }
//    printf("\nsorting in progress ...");
//    for (i = 2; i < SIZE; i++) {
//      if (buf[i] < buf[i - 1]) {
//          buf[0] = buf[i];
//
//          low = 1;
//          high = i - 1;
//          mid = (low + high) / 2;
//          while (low <= high && buf[mid] != buf[0]) {
//              if (buf[mid] < buf[0])
//                  low = mid + 1;
//              else
//                  high = mid - 1;
//              mid = (low + high) / 2;
//          }
//          if (buf[mid] == buf[0])
//              pos = mid;
//          else
//              pos = high + 1;
//          printf("[%2d] ", pos);
//
//          for (j = i - 1; j >= pos; j--) {
//              buf[j + 1] = buf[j];
//          }
//          buf[j + 1] = buf[0];
//      }
//      printf("\n");
//      for (k = 0; k < SIZE; k++) {
//          printf("%s%2d%s ", k == 0 ? "(" : "", buf[k],
//                 k == 0 ? ")" : "");
//      }
//    }
//    printf("\nsorting done\n");
//    for (i = 1; i < SIZE; i++) {
//      printf("%2d ", buf[i]);
//    }
//    free(buf);
//    printf("\n");
}

long int factors(int i)
{
    if (i == 0)
	return 1;
    else
	return (i * factors(i - 1));
}

/* hanoi(): recursive prog demo */
void hanoi(int n, char from, char via, char to)
{
    if (n == 1)
	printf("%d,%c->%c\n", n, from, to);
    else {
	hanoi(n - 1, from, to, via);
	printf("%d,%c->%c\n", n, from, to);
	hanoi(n - 1, via, from, to);
    }
}


void time(int *tm)
{
    *tm = (int) tickcount;
}

char *exceptionMesg[] = {
    /* Int 00 */ "Divide By Zero",
    /* Int 01 */ "Debug Trap",
    /* Int 02 */ "NMI Interrupt",
    /* Int 03 */ "Breakpoint",
    /* Int 04 */ "Overflow",
    /* Int 05 */ "BOUND Range Exceeded",
    /* Int 06 */ "Invalid Opcode",
    /* Int 07 */ "Device Not Available",
    /* Int 08 */ "Double Fault",
    /* Int 09 */ "Coprocessor Segment Overrun",
    /* Int 0A */ "Invalid TSS",
    /* Int 0B */ "Segment Not Present",
    /* Int 0C */ "Stack-Segment Fault",
    /* Int 0D */ "General Protection Fault",
    /* Int 0E */ "Page Fault",
    /* Int 0F */ "U/A",
    /* Int 10 */
    "Floating Point Error (Math Fault)",
    /* Int 11 */ "Alignment Check",
    /* Int 12 */ "Machine Check",
    /* Int 13 */ "Streaming SIMD Extensions",
    /* Int 14 */ "U/A",
    /* Int 15 */ "U/A",
    /* Int 16 */ "U/A",
    /* Int 17 */ "U/A",
    /* Int 18 */ "U/A",
    /* Int 19 */ "U/A",
    /* Int 1A */ "U/A",
    /* Int 1B */ "U/A",
    /* Int 1C */ "U/A",
    /* Int 1D */ "U/A",
    /* Int 1E */ "U/A",
    /* Int 1F */ "U/A"
};


/* 
data in stack
EFLG,ECS,EIP,||,handleID,cs,ds....esp,cr0,cr2,cr3 
*/

/*
void exceptionHandle(int esp, int ebp, int edi, int esi,
                   int edx, int ecx, int ebx, int eax, int gs, int fs,
                   int ss, int es, int ds, int cs, int handleID, int eip,
                   int ics, int eflg)
pseudo args eip,ics,eflg, which are pushed by CPU as exception occured 
*/
void exceptionHandle(int cr3, int cr2, int cr0, int esp, int ebp, int edi,
		     int esi, int edx, int ecx, int ebx, int eax, int gs,
		     int fs, int ss, int es, int ds, int cs, int handleID)
{
    unsigned char *expAddr;
    unsigned int *a = (unsigned int *) esp;	/* esp's content when exception occured */
    int eip = *a;		/* the address exception happened */
    int ics = *(a + 1);		/* the cs exception happened */
    int eflg = *(a + 2);	/* the eflg exception happened */
    int i = 0;
    printf
	("\nException Int %02x: %s\nEAX=%08X EBX=%08X ECX=%08X EDX=%08X EDI=%08X ESI=%08X\n"
	 "ESP=%08X EBP=%08X\n"
	 "CS=%08X DS=%08X ES=%08X SS=%08X FS=%08X GS=%08X\n"
	 "Stack SS:ESP [CS=%08X EIP=%08X EFLG=%08X(%b)]\n"
	 "cr0=%08x(%b) cr2=%08x cr3=%08x\n",
	 (char) handleID, exceptionMesg[handleID], eax, ebx, ecx, edx, edi,
	 esi, esp, ebp, cs, ds, es, ss, fs, gs, ics, eip, eflg, eflg, cr0,
	 cr0, cr2, cr3);
    expAddr = (unsigned char *) eip;
    for (i = 0, printf("Exp Opcodes %02X:%08X [", ics, eip); i < 16; i++) {
	printf("%02x ", *(expAddr + i));
    }
    printf("\b]\n");
    __asm__("hlt\n");		/* system halted while exception occured ! */
}

/* Exceptions */
extern unsigned int int0x0, int0x1, int0x2, int0x3,
    int0x4, int0x5, int0x6, int0x7;
extern unsigned int int0x8, int0x9, int0xA;
extern unsigned int int0xB, int0xC, int0xD, int0xE,
    int0x10, int0x11, int0x12, int0x13;
/* IRQs */
extern unsigned int int0x20, int0x21, int0x22,
    int0x23, int0x24, int0x25, int0x26, int0x27;
extern unsigned int int0x30, int0x31, int0x32,
    int0x33, int0x34, int0x35, int0x36, int0x37;

/* 
  Each entry is a protected mode gate descriptor: 
  byte in IDT entry    usage  
  0                    byte 0 (LSB) of handler offset (EIP 7:0)  
  1                    byte 1 of handler offset (EIP 15:8)  
  2                    LSB of handler selector (CS 7:0)  
  3                    MSB of handler selector (CS 15:8)  
  4                    (not used, set to 0)  
  5                    access byte (8Eh, 8Fh, 0EEh, or 0EFh)  
  6                    byte 2 of handler offset (EIP 23:16)  
  7                    byte 3 (MSB) of handler offset (EIP 31:24)  
*/

#define csHigh 0x00		/* code selector MSB */
#define csLow  0x08		/* code selector LSB */
#define MAXINTS 35
int *intHdlAddr[] = {
/* exceptions */
    &int0x0, &int0x1, &int0x2, &int0x3, &int0x4, &int0x5, &int0x6, &int0x7,
    &int0x8, &int0x9, &int0xA, &int0xB, &int0xC, &int0xD, &int0xE,	/* &int0xF, reserved */
    &int0x10, &int0x11, &int0x12, &int0x13,
/* IRQs */
    &int0x20, &int0x21, &int0x22, &int0x23, &int0x24, &int0x25, &int0x26,
    &int0x27, &int0x30, &int0x31, &int0x32, &int0x33, &int0x34, &int0x35,
    &int0x36, &int0x37
};

void doInitInts()
{				/* do init interrupts, be called in initInterrupts() */
    char *idtAddr = (char *) 0x1000;	/* IDT offset in GDT, GDT=0000h */
    int i, tmp, pos = 0;

    /* Exception & IRQ handler initialization for Intel X86 CPU */
    for (i = 0; i < MAXINTS; i++) {
	if (pos == 0x13)
	    pos = 0x20;		/* IRQ0~IRQ7 */

	if (pos == 0x28)
	    pos = 0x30;		/* IRQ8~IRQ15 */

	tmp = (int) intHdlAddr[i];
	tmp = tmp & 0x0000ff;	/* eip b0~b7 */
	*(idtAddr + pos * 8 + 0) = (char) tmp;

	tmp = (int) intHdlAddr[i];
	tmp = (tmp >> 8) & 0x0000ff;	/* eip b8~b15 */
	*(idtAddr + pos * 8 + 1) = (char) tmp;

	*(idtAddr + pos * 8 + 2) = csLow;	/* cs =0x08 */
	*(idtAddr + pos * 8 + 3) = csHigh;	/* cs =0x08 */
	*(idtAddr + pos * 8 + 4) = 0;	/* always reserved as 0 */
	*(idtAddr + pos * 8 + 5) = 0x8e;	/* signature 0x8E */

	tmp = (int) intHdlAddr[i];
	tmp = (tmp >> 16) & 0xff;	/* eip b16~b23 */
	*(idtAddr + pos * 8 + 6) = (char) tmp;

	tmp = (int) intHdlAddr[i];
	tmp = (tmp >> 24) & 0xff;	/* eip b24~b31 */
	*(idtAddr + pos * 8 + 7) = (char) tmp;

	pos++;
    }
}

/* reboot PC from keyboard command "reboot" */
static void reboot(void)
{
    unsigned temp;

    beep(1000);
    cli();
    do {
	temp = inb(0x64);
	if ((temp & 0x01) != 0) {
	    (void) inb(0x60);
	    continue;
	}
    }
    while ((temp & 0x02) != 0);	/* flush the keyboard controller */

    printf("rebooting...\n");

    outb(0xFE, 0x64);		/* pulse the CPU reset line */
    cmosDelay(2);

    /* ...and if that didn't take effect, just hang */
    while (1);
}

/* Press any key to continue... */
char waitAnyKey()
{
    printf("\nPress any key to continue...\n");
    return (getKey());
}