示例#1
0
// Starts the kernel's idle process. This process has kernel permissions.
int idle_main(int argc, char ** params) {
	
	int i = 0;
	char a[] = { ' ', 0x07 };
	
	for(; i < 2000; ++i)	{
		memcpy((char*)0xb8000 + i * 2, a, 2);
	}
	
	// The funny message, windows says starting windows... why shouldn't we? D:
	char start_msg[][2] =	{ 
		{ 'S', 0x07 },
		{ 't', 0x08 },
		{ 'a', 0x09 },
		{ 'r', 0x0a },
		{ 't', 0x0b },
		{ 'i', 0x0c },
		{ 'n', 0x0d },
		{ 'g', 0x0e },
		{ ' ', 0x0f },
		{ 'M', 0x02 },
		{ 'o', 0x03 },
		{ 'n', 0x04 },
		{ 'i', 0x05 },
		{ 'x', 0x06 },
		{ ' ', 0x0f },
		{ '\001', 0x5f },
	};
	
	i = 0;
	for(; i < 16; ++i)	{
		memcpy((char*)0xb8000 + i * 2, start_msg[i], 2);
		_setCursor(i);
	}
	
	Cli();
	make_atomic();

	mount();					// Mount or start the FS

	tty_init(0);				// Load up the TTY's
	tty_init(1);
	tty_init(2);
	tty_init(3);
	tty_init(4);
	tty_init(5);		
	
	setready(); 				// Set the kernel as ready and the FS as loaded
	users_init();				// Init the users
	
	fs_finish();

	release_atomic();	
	Sti();


	while(1) {
		_Halt(); // Now set to idle.
	}
}
示例#2
0
文件: timer.cpp 项目: kkk669/Cloumo
void Timer::set(unsigned int newTimeout) {
	int e = LoadEflags();
	Cli();
	if (!running) {
		Timer *timer0, *timer1;
		timeout = newTimeout + TimerController::count; // 絶対時間に変換
		running = true;
		timer0 = TimerController::t0;
	
		if (timeout <= timer0->timeout) {
			// 先頭に入る
			TimerController::t0 = this;
			next = timer0;
			TimerController::next = timeout;
		} else {
			// this が入る位置を決める
			do {
				timer1 = timer0;
				timer0 = timer0->next;
			} while (timeout > timer0->timeout);
			timer1->next = this;
			next = timer0;
		}
	}
	StoreEflags(e);
}
示例#3
0
文件: sysinfo.cpp 项目: kkk669/Cloumo
void SysinfoMain(Tab *tab) {
	Task *task = TaskSwitcher::getNowTask();
	int count = 0, count0 = 0;
	Sheet *sht = tab->sheet;
	
	// タイマー作成
	Timer *timer = new Timer(task->queue);
	// タブが閉じられた時消えるように
	tab->timer = timer;
	// タイマーセット (1s)
	timer->set(100);
	
	showSysInfo(sht, 0);
	
	for (;;) {
		++count;
		Cli();
		if (task->queue->isempty()) {
			//task->sleep(); ベンチマーク測定のため
			Sti();
		} else {
			int data = task->queue->pop();
			Sti();
			if (data == timer->data) {
				showSysInfo(sht, count - count0);
				count0 = count;
				timer->set(100);
			}
		}
	}
}
示例#4
0
void __showerror(char *format, const IPTR *args)
{
    struct IntuitionBase *IntuitionBase;
    struct DosLibrary *DOSBase = NULL;
    const char *name = FindTask(NULL)->tc_Node.ln_Name;

    if
    (
        !__forceerrorrequester                                                 &&
        (DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 0)) != NULL &&
	Cli() != NULL
    )
    {
        if (name)
	{
            PutStr(name);
            PutStr(": ");
	}

        if (args)
            VPrintf(format, args);
        else
            PutStr(format);
            
        PutStr("\n");
    }
    else
    if ((IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 0)))
    {
        struct EasyStruct es =
    	{
	    sizeof(struct EasyStruct),
	    0,
	    name,
	    format,
	    "Exit"
	};

	EasyRequestArgs(NULL, &es, NULL, args);

	CloseLibrary((struct Library *)IntuitionBase);
    }
    else
    {
        if (name)
            kprintf("%s: ", name);

        if (args) {
            vkprintf(format, args);
            kprintf("\n");
        }
        else
            kprintf("%s\n", format);
    }

    if (DOSBase != NULL)
        CloseLibrary((struct Library *)DOSBase);
    
}
示例#5
0
//Proceso Top
int Tope(int argc, char* argv[])
{
	char* video= (char*)0xb8000;
	int proce[65];
	char Mensaje [10];
	int salto;
	int i;
	char a;
	k_clear_screen();
	message("Top V1.0: Procesos y porcentaje de CPU utilizada",0,10);
	message("PID          CPU%         TTY          NAME",2,0);
	Sti();
	while(a!=68)
	{
		a=GetKey();
		salto=3;
		for(i=0;i<65;i++)
		{
			proce[i]=0;
			
		}
		for(i=0;i<100;i++)
		{	
			proce[last100[i]]++;
		}
		Cli();
			
			
			for(i=0;i<65;i++)
			{
				PROCESS* p=GetProcessByPID(i);
				if(p->free==0)
				{
					itoa2(i,Mensaje);
					message(Mensaje,salto,0);
					itoa2(proce[i],Mensaje);
					message(Mensaje,salto,28);
					itoa2(p->tty,Mensaje);
					message(Mensaje,salto,56);
					message(p->name,salto,78);
					salto=salto+1;

					
				}
				message("                                                                         ",salto,0);
			}
			if (argc>1)
				i=atoi2(argv[1]);
			else
				i=0;
		Sti();
		

		Sleep(i);
	}
	return 0;
}
示例#6
0
//Funcion a donde van a parar las funciones que terminan.
void Cleaner(void)
{
	char Men[10];
	Cli();
	Destroy(CurrentPID);
	k_clear_screen();
	mess("==>");
	Sti();
	while(1);
	
}
void __initdetach(void)
{ struct Library *DOSBase,*SysBase = *(struct Library **)4;
  struct SignalSemaphore *sema;

  if (_WBenchMsg)
    return;

  if ((sema=sem)) {        /* I must be the child process */
    ObtainSemaphore(sema); /* Assert that my parent is already dead */
    ReleaseSemaphore(sema);
    FreeMem(sema,sizeof(*sema));
    return;
  }
                          /* I must be the parent */
  if ((sem=sema=(struct SignalSemaphore *)AllocMem(sizeof(*sema),MEMF_PUBLIC|MEMF_CLEAR))) {

    InitSemaphore(sema);

    if ((DOSBase=OpenLibrary(__dosname,30))) {

      struct CommandLineInterface *cli = Cli();
      APTR pr,stack = __SaveSP;

      ObtainSemaphore(sema); /* Assert that my child is suspended until I'm finished */

      pr = CreateNewProcTags(NP_Seglist,cli->cli_Module, /* child process gets my seglist */
                             NP_FreeSeglist,1,           /* and must free it */
                             NP_Cli,1,                   /* it must be a CLI process */
                             NP_StackSize,__stack,       /* it gets a stack */
                             NP_Name,(ULONG)__procname,  /* a name */
                             NP_Priority,__priority,     /* a priority */
                             NP_Arguments,(ULONG)__commandline,/* and my commandline Arguments */
                             TAG_END);
      CloseLibrary(DOSBase);

      if (pr) {

        cli->cli_Module = 0; /* I'm no longer owner of this */

        /* Adjust stack, release semaphore and return 0 in one.
         * Maybe the 3 movel are a bit too cautious, but they ARE working
         */
        asm("movel %0,sp;movel %1,a6;movel %2,a0;moveql #0,d0;jmp a6@(-570)"::
            "r"(stack),"r"(SysBase),"r"(sema):"sp","a6","a0");
      }

      ReleaseSemaphore(sema); /* Again only caution - you never know */
    }
    FreeMem(sema,sizeof(*sema)); /* Couldn't start child :( */
  }
示例#8
0
static int WBOpen(LIBBASETYPEPTR LIBBASE)
{
    ObtainSemaphore(&(WorkbenchBase->wb_InitializationSemaphore));

    if (!(WorkbenchBase->wb_Initialized))
    {
        struct CommandLineInterface *cli;
        
        /* Duplicate the search path ---------------------------------------*/
        if ((cli = Cli()) != NULL)
        {
            WorkbenchBase->wb_SearchPath = DuplicateSearchPath
            (
                cli->cli_CommandDir
            );
        }
    
        const struct TagItem 	     tags[]=
        {
            {NP_Entry    , (IPTR)WorkbenchHandler      },
            {NP_Name     , (IPTR)"Workbench Handler"   },
			{NP_UserData , (IPTR)WorkbenchBase      },
			{NP_StackSize, 8129 			           },
            {TAG_DONE    , 0     	    	    	   }
        };
        
        /* Start workbench handler -----------------------------------------*/
        if ((CreateNewProc(tags)) != NULL)
        {
            /* Prevent expunging while the handler is running */
            AROS_ATOMIC_INC(WorkbenchBase->LibNode.lib_OpenCnt);
        }
        else
        {
            // FIXME: free resources
            return FALSE;
        }
        
        WorkbenchBase->wb_Initialized = TRUE;
    }

    ReleaseSemaphore(&(WorkbenchBase->wb_InitializationSemaphore));

    return TRUE;
} /* L_OpenLib */
示例#9
0
int _dfill (int argc, char ** argv)
{
	int j = 0;
	
	for(j = 0; j < 1000; ++j)
	{
		int count = 384;
		int bytes = 65536;
		int sector = 1 + j * 128;
		if(argc > 1)
		{
			int i;
			sector = atoi(argv[1]);
			for(i = 0; i < 65536; ++i)	{
				ans[i] = '0' + (i / 512) % 10;
			}
			int offset = 0;
			int ata = ATA0;
	
			Cli();
			_disk_write(ata, ans, count, sector);
			for(i = 0; i < 65536; ++i)	{
				ans[i] = 0;
			}
			// _disk_read(ata, ans, count, sector);
			Sti();
			
				printf("%d\n", j);
			
	
			// for(i = 0; i < count; ++i)	{
			// 	if(ans[i * 512] != i % 10 + '0')	{
			// 		printf("Err %d %d %d %d\n", i % 10 + '0', ans[i * 512], i, j);
			// 		getC();
			// 		break;
			// 	}
			// }
	
		}
	}
	return 0;
}
示例#10
0
文件: timer.cpp 项目: kkk669/Cloumo
bool Timer::cancel() {
	int e = LoadEflags();
	Cli();
	if (running) {
		if (this == TimerController::t0) {
			// 先頭だった場合
			TimerController::t0 = next;
			TimerController::next = next->timeout;
		} else {
			// 1つ前と1つ後をつなげる
			Timer *timer = TimerController::t0;
			while (timer->next != this) {
				timer = timer->next;
			}
			timer->next = next;
		}
		running = false;
		StoreEflags(e);
		return true;
	}
	StoreEflags(e);
	return false;
}
示例#11
0
/**********************************************
 kmain()
 Punto de entrada de código C.
 *************************************************/
kmain() {
	int i, num;
	// Paging.start(0x200000);
	// init_malloc();
	
	initialize_pics(0x20,0x70);
	setup_IDT_entry(&idt[0x70], 0x08, (dword) & _rtc, ACS_INT, 0);

	_cache_init();
	hdd_init();
	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE IRQ0    */
	
	setup_IDT_entry (&idt[0x00], 0x08, (dword)&_int_00_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x01], 0x08, (dword)&_int_01_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x02], 0x08, (dword)&_int_02_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x03], 0x08, (dword)&_int_03_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x04], 0x08, (dword)&_int_04_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x05], 0x08, (dword)&_int_05_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x06], 0x08, (dword)&_int_06_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x07], 0x08, (dword)&_int_07_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x08], 0x08, (dword)&_int_08_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x09], 0x08, (dword)&_int_09_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x0A], 0x08, (dword)&_int_0A_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x0B], 0x08, (dword)&_int_0B_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x0C], 0x08, (dword)&_int_0C_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x0D], 0x08, (dword)&_int_0D_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x0E], 0x08, (dword)&_int_0E_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x0F], 0x08, (dword)&_int_0F_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x10], 0x08, (dword)&_int_10_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x11], 0x08, (dword)&_int_11_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x12], 0x08, (dword)&_int_12_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x13], 0x08, (dword)&_int_13_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x14], 0x08, (dword)&_int_14_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x15], 0x08, (dword)&_int_15_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x16], 0x08, (dword)&_int_16_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x17], 0x08, (dword)&_int_17_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x18], 0x08, (dword)&_int_18_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x19], 0x08, (dword)&_int_19_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x1A], 0x08, (dword)&_int_1A_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x1B], 0x08, (dword)&_int_1B_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x1C], 0x08, (dword)&_int_1C_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x1D], 0x08, (dword)&_int_1D_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x1E], 0x08, (dword)&_int_1E_hand, ACS_INT, 0);
	setup_IDT_entry (&idt[0x1F], 0x08, (dword)&_int_1F_hand, ACS_INT, 0);
	// setup_IDT_entry (&idt[0x20], 0x08, (dword)&_int_20_hand, ACS_INT, 0);
	// setup_IDT_entry (&idt[0x21], 0x08, (dword)&_int_21_hand, ACS_INT, 0);

	setup_IDT_entry(&idt[0x20], 0x08, (dword) & _timer_tick_hand, ACS_INT, 0);

	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE IRQ1    */

	setup_IDT_entry(&idt[0x21], 0x08, (dword) & _KB_hand, ACS_INT, 0);

	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE int80h    */

	setup_IDT_entry(&idt[0x80], 0x08, (dword) & _int_80_hand, ACS_INT, 0);
	
	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE int79h    */

	setup_IDT_entry(&idt[0x79], 0x08, (dword) & _int_79_hand, ACS_INT, 0);

	/* Carga de IDTR */

	idtr.base = 0;
	idtr.base += (dword) & idt;
	idtr.limit = sizeof(idt) - 1;

	_lidt(&idtr);	
	
	
	Cli();
	int rate = 0x06;
	_outb(0x70, 0x0A); //set index to register A
	char prev=_inb(0x71); //get initial value of register A
	_outb(0x70, 0x0A); //reset index to A
	_outb(0x71, (prev & 0xF0) | rate); //write only our rate to A. Note, rate is the bottom 4 bits.
	
		
		init_paging();
	scheduler_init();



	/* Habilito interrupcion de timer tick*/
	_mascaraPIC1(0xFC);
	_mascaraPIC2(0xFE);
	
	_outb(0x70, 0x0B); //set the index to register B
	prev= _inb(0x71); //read the current value of register B
	_outb(0x70, 0x0B); //set the index again(a read will reset the index to register D)
	_outb(0x71, prev | 0x40); //write the previous value or'd with 0x40. This turns on bit 6 of register B

	Sti();




	idle = create_process("idle", idle_main, 0, 0, 0, 0, 0, 0, 0, NULL, 0);
	
	

	// We soon exit out of here :)
	while (1);

}
示例#12
0
文件: kernel.c 项目: kshmir/so-2011-2
/**********************************************
 kmain()
 Punto de entrada de código C.
 *************************************************/
kmain() {
	int i, num;

	setup_IDT_entry(&idt[0x70], 0x08, (dword) & _rtc, ACS_INT, 0);

	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE IRQ0    */

	setup_IDT_entry(&idt[0x08], 0x08, (dword) & _int_08_hand, ACS_INT, 0);

	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE IRQ1    */

	setup_IDT_entry(&idt[0x09], 0x08, (dword) & _int_09_hand, ACS_INT, 0);

	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE int80h    */

	setup_IDT_entry(&idt[0x80], 0x08, (dword) & _int_80_hand, ACS_INT, 0);
	
	/* CARGA DE IDT CON LA RUTINA DE ATENCION DE int79h    */

	setup_IDT_entry(&idt[0x79], 0x08, (dword) & _int_79_hand, ACS_INT, 0);

	/* Carga de IDTR */

	idtr.base = 0;
	idtr.base += (dword) & idt;
	idtr.limit = sizeof(idt) - 1;

	_lidt(&idtr);	
	
	Cli();
	int rate = 0x06;
	_outb(0x70, 0x0A); //set index to register A
	char prev=_inb(0x71); //get initial value of register A
	_outb(0x70, 0x0A); //reset index to A
	_outb(0x71, (prev & 0xF0) | rate); //write only our rate to A. Note, rate is the bottom 4 bits.
	

	scheduler_init();


	/* Habilito interrupcion de timer tick*/
	_mascaraPIC1(0x00);
	_mascaraPIC2(0x00);
	
	_outb(0x70, 0x0B); //set the index to register B
	prev= _inb(0x71); //read the current value of register B
	_outb(0x70, 0x0B); //set the index again(a read will reset the index to register D)
	_outb(0x71, prev | 0x40); //write the previous value or'd with 0x40. This turns on bit 6 of register B

	Sti();





	idle = create_process("idle", idle_main, 0, 0, 0, 0, 0, 0, 0, NULL, 0);
	
	

	// We soon exit out of here :)
	while (1);

}
示例#13
0
static void __startup_detach(void)
{
    struct CommandLineInterface *cli;
    struct Process              *newproc;
    BPTR                         mysegment = NULL;
    STRPTR                       detached_name;

    D(bug("Entering __startup_detach(\"%s\", %d, %x)\n", argstr, argsize, SysBase));

    cli = Cli();
    /* Without a CLI detaching makes no sense, just jump to
       the real program.  */
    if (!cli)
    {
        __startup_entries_next();
    }  
    else
    {
        mysegment = cli->cli_Module;
        cli->cli_Module = NULL;

        detached_name = __detached_name ? __detached_name : (STRPTR)FindTask(NULL)->tc_Node.ln_Name;
    
        {
            struct TagItem tags[] =
            {
                { NP_Seglist,   (IPTR)mysegment            },
                { NP_Entry,     (IPTR)&__detach_trampoline },
                { NP_Name,      (IPTR)detached_name        },
                { NP_Arguments, (IPTR)__argstr             },
                { NP_Cli,       TRUE                       },
                { TAG_DONE,     0                          }
            };

            __detacher_process = (struct Process *)FindTask(NULL);

            /* CreateNewProc() will take care of freeing the seglist */
            newproc = CreateNewProc(tags);
        }

        if (!newproc)
        {
            cli->cli_Module = mysegment;
            __detached_return_value = RETURN_ERROR;
        }
        else
            while (!__detacher_go_away) Wait(SIGF_SINGLE);

        if (__detached_return_value != RETURN_OK)
        {
            PutStr(FindTask(NULL)->tc_Node.ln_Name); PutStr(": Failed to detach.\n");
        }
    
        if (newproc)
        {
            Forbid();
            Signal(&newproc->pr_Task, SIGF_SINGLE);
        }

        __aros_startup.as_startup_error = __detached_return_value;
    }

    D(bug("Leaving __startup_detach\n"));
}