自学教程：C++ Halt函数代码示例

void TestMemory(){        register unsigned char* i;	PutString("TESTING MEMORY A", 1, 1);        _SimUnprotect(0x4000, 0x5fff);        for(i=(char*)0x4000; i<(char*)0xEEEA; i++) {                *i=0xAA;        }	for(i=(char*)0x4000; i<(char*)0xEEEA; i++) {		if(*i!=0xAA) {			PutString("BAD MEMORY", 1, 1);			Halt("BAD MEMORY");		}	}        PutString("TESTING MEMORY B", 2, 1);        _SimUnprotect(0x4000, 0x5fff);        for(i=(char*)0x4000; i<(char*)0xEEEA; i++) {                *i=(~0xAA);        }        for(i=(char*)0x4000; i<(char*)0xEEEA; i++) {                if(*i!=(~0xAA)) Halt("BAD MEMORY");        }        PutString("MEMORY TEST COMPLETE", 3, 1);        _SimUnprotect(0x4000, 0x5fff);        for(i=(char*)0x4000; i<(char*)0xEEEA; i++) {                *i=0;        }	_SimPrintString("Memory test completed/n");}

intmain(){  SpaceId kid;  int joinval;  char *args[1];  args[0] = (char *)0;  print("PARENT exists/n");  if ((kid=Fork()) == 0) {    Exec("deepkid1", args);    print("ERROR: exec failed/n");    Halt();  }  if(kid==-1){Halt();}  print("PARENT after fork/exec; kid pid is "); printd((int)kid, ConsoleOutput);  print("/n");  print("PARENT about to Join kid/n");  joinval = Join(kid);  print(">>PARENT off Join with value of ");  printd(joinval, ConsoleOutput);  print("/n");  Exit(10);  Halt();  /* not reached */}

// This is our PRAM program// After each case x label, you can put an instructionvoid step(int pc, int i, int * x, int * y, int * z){    int debug=0;    int writecount=0;//    printf("%d %d %d %d %d/n",pc, i, *x, *y, *z);	// i is the processor number	// *x, *y and *z are temporary registers	switch(pc)	{	case 0: *z = 0;	break;    // Init N <= g < 2N-1 and 2N <= p < 3N - 1 and 3N <= z <= 4N-1	case 1: *y = Read(i+N);	break;	case 2: *x = Read(i);	break;	case 3: *x = *x + *y;	break;	case 4: Write(i,((*x)%10));	break;	case 5: Write(i+N,((*x)>9));	break;	case 6: Write(i+2*N,(*x==9)); // p	break;	case 7: Write(3*N+i, 0);	break;    // Prefix sum the g	case 8: JumpIf(13,i<(int)pow(2,Read(3*N+i)));	break;	case 9: *x = Read(i+N) /* g */ || ( Read(i+2*N) /* p */ && Read(i+N-(int)pow(2,Read(3*N+i))) /*g' */ );	break;	case 10: Write(i+N,*x); //g	break;	case 11: *x = Read(i+2*N) && Read(i+2*N-(int)pow(2,Read(3*N+i)));	break;	case 12: Write(i+2*N,*x);	break;	case 13: Write(3*N+i,Read(3*N+i)+1); // step increment	break;	case 14: JumpIf(8,Read(3*N+i)<(int)log2(N)) ;	break;    // Sum	case 15: JumpIf(19,i==0);	break;	case 16: *x = Read(i);	break;	case 17: *y = Read(i+N-1) || Read(i+2*N-1);    break;	case 18: Write(i,(*x + *y)%10);	break;	case 19: Halt();	break;	default: Halt();	}}

void _InterruptService() {        register short i;        ExchangeRegs();        GetStackPointerASM(_UserSP);        SaveIndexes();	if(ControlRequests<0) Halt("NEGATIVE CONTROLREQUESTS");        if(!IsMultitasking()) Halt("INTERRUPT IN KERNEL MODE");	ControlRequests++;        Tick();        for(i=0; i<InterruptVectorCount; i++) {                (InterruptVector[i])();        }        Scheduler(UserSP);        Halt("OUT OF REACH");}

int main(){  int i;  OpenFileId f0, f1;  Create( "test1_f0" );  Create( "test1_f1" );    f0 = Open( "test1_f0" );      f1 = Open( "test1_f1" );    Write( "Test1: This is file 0/n", 22, f0 );  Write( "Test1: This is file 1/n", 22, f1 );  for( i = 0; i < 256; ++i ) usr_buffer_0[i] = 'A';      Write( usr_buffer_0, 128, f0 );    /* reset file pointer of f0 to the starting position */  Close( f0 );  f0 = Open( "test1_f0" );  Read( usr_buffer_1, 128, f0 );  Write( usr_buffer_1, 128, 1 );    // adding this allows the second write to work  Write( usr_buffer_1, 128, f1 );  Close( f0 );  Close( f1 );    Halt(0);}

int main(){	// Escribimos un texto indicativo sobre la consola.	char *writeStr = "Ingrese un texto:/n";	Write(writeStr, 18, ConsoleOutput);	// Leemos caracteres desde la consola hasta encontrar el "/n".	char readStr[1024], tmpChar;	int i = 0;	do {		Read(&tmpChar, 1, ConsoleInput);		readStr[i] = tmpChar;		i++;	} while (tmpChar != '/n');	// Escribimos los caracteres ingresados en la consola.	writeStr = "Usted ingreso:/n";	Write(writeStr, 16, ConsoleOutput);	Write(readStr, i, ConsoleOutput);	// Realizamos una llamada a halt para finalizar Nachos.	Halt();}

void CTestSignals::KeyComplete(TKeyCode aKey)	{	switch (aKey)		{	case EKeyEscape:		Halt();		break;	default:		switch (iState)			{		case EAllOff:			DoSignals(ERtsOn);			break;		case ERtsOn:			DoSignals(EDtrOn);			break;		case EDtrOn:			DoSignals(EAllOn);			break;		case EAllOn:			DoSignals(EAllOff);			break;		default:			break;			}		}	}

intmain(){  Halt();  /* not reached */}

/* A kernel magic function that is only used for getting kernel context for newbie */KernelContext *init_newbie_kernel(KernelContext *kernel_context, void *_prev_pcb, void *_next_pcb){    pcb_t *next_proc = (pcb_t *) _next_pcb;    //log_info("First time to init PID(%d) kernel stack!", next_proc->pid);       if(next_proc->kernel_stack_pages == NULL) {        log_err("Init kernel stack fail, pcb->kernel_stack_pages not malloc yet");        Halt();    }    next_proc->kernel_context = *kernel_context;    int rc = alloc_frame_and_copy(next_proc->kernel_stack_pages,                                 kernel_page_table,                                 GET_PAGE_NUMBER(KERNEL_STACK_BASE),                                 GET_PAGE_NUMBER(KERNEL_STACK_LIMIT),                                 kernel_memory.swap_addr);    if(rc) {        log_err("PID(%d) kernel stack cannot init", next_proc->pid);        return NULL;    }    next_proc->init_done = 1;    //print_page_table(kernel_page_table, 120, GET_PAGE_NUMBER(VMEM_0_LIMIT));    //print_page_table(next_proc->kernel_stack_pages, 0, 2);    //log_info("First time to init PID(%d) kernel stack done", next_proc->pid);    return kernel_context;}

intmain(){  SpaceId kid;  int joinval;  char *args[2];  args[0] = "huge";  args[1] = (char *)0;  if ((kid = Fork()) == 0)    Exec("huge",args);    prints("PARENT after foprk/exec; kid pid is ", ConsoleOutput);  printd((int)kid, ConsoleOutput);  prints("/n", ConsoleOutput);  prints("PARENT about to Join kid/n", ConsoleOutput);  joinval = Join(kid);  prints("PARENT off Join with value of ", ConsoleOutput);  printd(joinval, ConsoleOutput);  prints("/n", ConsoleOutput);  Halt();  /* not reached */}

// Begin executing the specified proc.// NOTE: place the current proc into the correct queue before callingvoid SwitchToProc(PCB *next_proc, UserContext *user_context) {    TracePrintf(TRACE_LEVEL_FUNCTION_INFO, ">>> SwitchToProc()/n");    assert(user_context);    assert(next_proc);    // Save current user state    current_proc->user_context = *user_context;    TracePrintf(TRACE_LEVEL_DETAIL_INFO, "Loading next proc context into %p/n", user_context);    TracePrintf(TRACE_LEVEL_DETAIL_INFO, "Loading next proc PID: %d/n", next_proc->pid);    *user_context = next_proc->user_context;    // Set the TLB registers for the region 1 page table.    WriteRegister(REG_PTBR1, (unsigned int) next_proc->region_1_page_table);    WriteRegister(REG_TLB_FLUSH, TLB_FLUSH_1);    PCB *old_proc = current_proc;    current_proc = next_proc;    int rc = KernelContextSwitch(&SaveKernelContextAndSwitch, old_proc, next_proc);    if (SUCCESS == rc) {        TracePrintf(TRACE_LEVEL_DETAIL_INFO, "Succesfully switched kernel context!/n");    } else {        TracePrintf(TRACE_LEVEL_NON_TERMINAL_PROBLEM, "Failed to save kernel context!/n");        char *err_str = calloc(TERMINAL_MAX_LINE, sizeof(char));        sprintf(err_str, "KernelContextSwitch failed!!! HALTING!!!/n", current_proc->pid);        KernelTtyWriteInternal(0, err_str, strnlen(err_str, TERMINAL_MAX_LINE), user_context);        free(err_str);        Halt();    }    // Restore user state of new current process    *user_context = current_proc->user_context;    TracePrintf(TRACE_LEVEL_FUNCTION_INFO, "<<< SwitchToProc()/n");}

   Nav2::~Nav2(){      coretracefunc();            Halt();      WaitNavigate2();      coreprintln("Halt and WaitNavigate2 completed..");            delete[] m_globalData->m_writable_files_path;      delete[] m_globalData->m_readonly_files_path;      delete m_errorTable;      delete mainlog;      delete m_globalData->m_logmaster;      delete m_globalData;#ifdef __SYMBIAN32__      delete m_archGlobalData->m_timerThread;      if(m_archGlobalData->m_socketServ){         m_archGlobalData->m_socketServ->Close();         delete m_archGlobalData->m_socketServ;         m_archGlobalData->m_socketServ=NULL;      }      delete m_archGlobalData;      deleteTlsGlobalData(m_tlsGlobalData, m_tlsGlobalDataId);#endif            //delete m_audioSyntax;   - owned by AudioCtrl...   }

void NewContext(int* SP) {	// SP for next task to go (arg #1) goes into HL	SP; FunctionArgToReg(H, L);		// Restores usermode status        SetStackPointerASM(_OldSP);	ExchangeRegs();	ReloadIndexes();		SaveContext();	// Switches to the process with stack in SP	ExchangeRegs();	GetStackPointerASM(_TempSP);	SetStackPointerREG(HL);        *CurrentSP=TempSP;	ExchangeRegs();		LoadContext();	if(ControlRequests==0) Halt("ISR IN USER MODE");	ControlRequests--;	IntsOn();	ImmediateReturn();}

intmain(int argc, char **argv){  int i, joinval, tmp;  SpaceId kid;  char *args[1];  args[0] = (char *)0;  for (i=0; i<100000; i++) tmp++;  /* loop to delay kid initially */  if ((kid=Fork()) == 0) {      Exec("deepkid2", args);      print("ERROR: exec failed in kid/n");      Exit(100);  }  print("KID1 after exec; kid1 pid is ");  printd((int)kid, ConsoleOutput);  print("/n");  print("KID1 about to Join kid2/n");  joinval = Join(kid);  print("KID1 off Join with value of ");  printd(joinval, ConsoleOutput);  print("/n");  Exit(1);  /* Should not get past here */  print("ERROR: KID1 after Exit()/n");  Halt();    /* not reached */}

intmain(){  SpaceId kid;  int joinval;  prints("PARENT exists/n", ConsoleOutput);  kid = Fork();  if (kid != 0) {    prints("PARENT after fork; kid pid is ", ConsoleOutput);    printd((int)kid, ConsoleOutput);    prints("/n", ConsoleOutput);        joinval = Join(kid);        prints("PARENT off Join with value of ", ConsoleOutput);    printd(joinval, ConsoleOutput);    prints("/n", ConsoleOutput);    Halt();  /* not reached */  } else     Exec("kid");}

intmain(){  SpaceId kid;  int joinval;  prints("PARENT exists/n", ConsoleOutput);  kid = Fork();  if (kid != 0) {    prints("PARENT after fork; kid pid is ", ConsoleOutput);    printd((int)kid, ConsoleOutput);    prints("/n", ConsoleOutput);        joinval = Join(kid);        prints("PARENT off Join with value of ", ConsoleOutput);    printd(joinval, ConsoleOutput);    prints("/n", ConsoleOutput);    Exit(56);    Halt();  /* not reached */  } else {    prints("KID running, about to Exit()/n", ConsoleOutput);    /* You may want to put some real code here */    Exit(17);  }}

static voidExit(void){   if (!Halt()) {      CommOS_StopIO();   }}

intmain(){    int i, j, k;    prints("Starting matmult/n", ConsoleOutput);    for (i = 0; i < Dim; i++)		/* first initialize the matrices */	for (j = 0; j < Dim; j++) {	     A[i][j] = i;	     B[i][j] = j;	     C[i][j] = 0;	}    prints("Initialization Complete/n", ConsoleOutput);    for (i = 0; i < Dim; i++) {		/* then multiply them together */        prints("i = ", ConsoleOutput); printd(i, ConsoleOutput); prints("/n", ConsoleOutput);	for (j = 0; j < Dim; j++)            for (k = 0; k < Dim; k++)		 C[i][j] += A[i][k] * B[k][j];    }    prints("C[", ConsoleOutput); printd(Dim-1, ConsoleOutput);    prints(",", ConsoleOutput); printd(Dim-1, ConsoleOutput);    prints("] = ", ConsoleOutput); printd(C[Dim-1][Dim-1], ConsoleOutput);    prints("/n", ConsoleOutput);    Exit(1);    Halt();		/* and then we're done */}

int main(){	PutString("Files opened.../n");	ForkExec("userpages1");	PutChar('/n');	ForkExec("userpages2");	PutChar('/n');	ForkExec("userpages1");	PutChar('/n');	ForkExec("userpages2");	PutChar('/n');	ForkExec("userpages1");	PutChar('/n');	ForkExec("userpages2");	PutChar('/n');	ForkExec("userpages1");	PutChar('/n');	ForkExec("userpages2");	PutChar('/n');	ForkExec("userpages1");	PutChar('/n');	ForkExec("userpages2");	PutChar('/n');	ForkExec("userpages1");	PutChar('/n');	ForkExec("userpages2");	PutChar('/n');	PutString("/nExiting.../n");Halt();}

/* Wrapper of kernel context switch * * @param next_proc: the process to be switched in * @param user_context: current user context */void context_switch_to(pcb_t *next_proc, UserContext *user_context) {    int rc = 0;    rc = KernelContextSwitch(&kernel_context_switch, running_proc, next_proc);    if(rc) {        log_err("Failed to execute magic function!");        Halt();    }}

intmain (){    Halt ();     /* not reached */    return 0;}

void Task2() {        while(1) {                if(!IsMultitasking()) {			Halt("INTS DISABLED PRC2");		}                ConsoleWrite("2");		_SimPrintString("2");        }}

void Resume() {        if(ControlRequests>0) {	        ControlRequests--;                if(ControlRequests==0) {			UserMode();		}        } else {		Halt("RESUME WITHOUT PAUSE");	}}

/* Used for special processes that is not forked to init kernel context, * meaning this process is manually created by Yalnix */void init_process_kernel(pcb_t *proc) {    int rc = 0;        rc = KernelContextSwitch(&init_newbie_kernel, proc, proc);    if(rc) {        log_err("Failed to execute magic function!");        Halt();    }    //log_info("Init PID(%d) kernel stack done", proc->pid);}

intmain(){  int result;    result = Add(42, 23);  Halt();  /* not reached */}

intmain(){	void (*func)();	func = &printfork;    Fork(func);    Sleep(10000000);    /*Exit(0);*/    Halt();}

/* * write.c * *  Created on: 2012-11-18 *      Author: rye */int main() {	//Test Create		int fd;		int readSize;		Create("TestSysCall");		fd = Open("TestSysCall");		Write("Test my system call.",21,fd);		Close(fd);		Halt();}