void A(void) { int num; int sender_pid; while (1) { msg* p = (msg*)request_memory_block(); uart1_put_string("Waiting for KCD\r\n"); p = (msg*)(receive_message(&sender_pid)); if (p->mtext[0] == '%' && p->mtext[1] == 'Z') { uart1_put_string("Received %Z from KCD\r\n"); release_memory_block(p); break; } else { release_memory_block(p); } } num = 0; while (1) { char b[8]; msg* p = (msg*)request_memory_block(); itoa(num, b); p->mtype = 3; p->mtext = b; send_message(6,p); uart1_put_string(b); uart1_put_string("Sent Message from A to B\r\n"); num++; release_processor(); } // note that Process A does not de-allocate // any received envelopes in the second loop }
//this tests removing arbitrary blocks from used mem queue void mem_test6() { rtx_dbug_outs("Starting Memory Test 6\r\n"); //request half of the blocks void * testArray[16]; //print_availible_mem_queue(); //print_used_mem_queue(); int i; for (i = 0; i < 16; i++) { testArray[i] = request_memory_block(); } rtx_dbug_outs("Blocks requested\r\n"); //remove some from the middle release_memory_block(testArray[4]); release_memory_block(testArray[10]); //print_availible_mem_queue(); //print_used_mem_queue(); //release all memory blocks for (i = 0; i < 16; i++) { if (i != 4 && i != 10) { release_memory_block(testArray[i]); } } rtx_dbug_outs("Finished Memory Test 6\r\n"); }
void proc2(void) { if (get_process_priority(1) != LOW || get_process_priority(2) != MEDIUM || get_process_priority(3) != LOWEST || get_process_priority(4) != LOWEST || get_process_priority(5) != LOWEST || get_process_priority(6) != HIGH) { prev_success = 0; } prev_pid = 2; // TC 3b: allocate all memory blocks, free one, return release_memory_block(mem[--index]); //jumps back to proc_6 // TC 3c: with 2 procs at highest priority, block both procs, then release memory in another proc to return to proc_6 prev_pid = 2; release_memory_block(mem[--index]); //jumps to proc_3 // TC 3d: Block everything and preempt to null process after starvation if (prev_pid != 1) { prev_success = 0; } // 1: MEDIUM, blocked // 2: LOW, will be blocked // 3: HIGH, blocked // 4, 5: LOWEST // 6: HIGH, blocked prev_pid = 2; mem[index++] = request_memory_block(); }
//TC 1: Delayed message sending & no preemption void proc1(void) { MSG_BUF* envelope = NULL; char* msg = "SE 350"; uart1_put_string("\n\r"); uart1_put_string("G003_test: START\n\r"); uart1_put_string("G003_test: total "); uart1_put_char(total + 48); uart1_put_string(" tests\n\r"); prev_pid = 1; envelope = (MSG_BUF*)request_memory_block(); strcpy(envelope->mtext, msg); delayed_send(1, envelope, 5000); envelope = (MSG_BUF*)receive_message(NULL); if (strcmp(envelope->mtext, msg) == 0) { prev_success = 1; } else { prev_success = 0; } release_memory_block(envelope); if (prev_success) { uart1_put_string("G003_test: test "); uart1_put_char(1 + 48); uart1_put_string(" OK\n\r"); pass = pass + 1; } else { uart1_put_string("G003_test: test "); uart1_put_char(1 + 48); uart1_put_string(" FAIL\n\r"); } //TC 2: Blocked on receive & preemption envelope = (MSG_BUF*)receive_message(NULL); prev_success = 1; // Checks if you ever get here. release_memory_block(envelope); if (prev_success) { uart1_put_string("G003_test: test "); uart1_put_char(2 + 48); uart1_put_string(" OK\n\r"); pass = pass + 1; } else { uart1_put_string("G003_test: test "); uart1_put_char(2 + 48); uart1_put_string(" FAIL\n\r"); } while (1) { release_processor(); } }
//Second part to the test (Test 4) void mem_test5() { rtx_dbug_outs("Starting Memory Test 5\r\n"); //request 31 blocks of mem (Mem should now fill up) void * testArray[32]; //request 31 memory blocks int i; for (i = 0; i < 31; i++) { testArray[i] = request_memory_block(); } //print_availible_mem_queue(); //print_used_mem_queue(); rtx_dbug_outs("Requested 31 blocks. Requesting one more\r\n"); //this should get blocked testArray[31] = request_memory_block(); //PROC 4 SHOULD HAPPEN BEFORE THIS AND SHOULD RELEASE IT'S MEMORY rtx_dbug_outs_int("Got Block! Address is: \r\n", (int)testArray[31]); //release all memory blocks for (i = 0; i < 32; i++) { release_memory_block(testArray[i]); } //print_availible_mem_queue(); //print_used_mem_queue(); rtx_dbug_outs("Finished Memory Test 5\r\n"); }
/** * Tries to free invalid memory location */ void test_proc_p1_3() { int i = 0; int ret; int proc = 2; void* memory = 0; while (1) { //printf("Process 3\r\n"); memory = (void*) 0xDEADC0DE; ret = release_memory_block(memory); if (ret == 0) { test_results[g_test_procs[proc].pid] = 0; } if (i == 0) { if (test_results[proc] == 1) { printf("G005_test: test 3 OK\r\n"); } else { printf("G005_test: test 3 FAIL\r\n"); } } i = 1; ret = release_processor(); } }
int message_api_tests_passed(){ void * p = request_memory_block(); int i = 0; int testCases = 100; for(i = 0; i < testCases; i++){ set_sender_PID(p, i); assert(get_sender_PID(p) == i,"message api function is broken"); set_destination_PID(p, i); assert(get_destination_PID(p) == i,"message api function is broken"); set_message_type(p, i); assert(get_message_type(p) == i,"message api function is broken"); assert(get_message_data(p) != 0,"message api function is broken"); assert(get_message_data(p) != 0,"message api function is broken"); //set_message_data(p,p, 10); } release_memory_block(p); return 1; }
void uart() { struct io_message * msg = NULL; while(1) { #ifdef _IO_DEBUG rtx_dbug_outs((CHAR *) "Enter: uart - waiting for message\r\n"); #endif msg = (io_message *)receive_message(NULL); #ifdef _IO_DEBUG rtx_dbug_outs((CHAR *) "Enter: uart - received message\r\n"); #endif char_out = msg->msg[0]; release_memory_block((void *)msg); // irene said this is OK while( !(SERIAL1_UCSR & 4) ) { } // write data to port SERIAL1_WD = char_out; #ifdef _IO_DEBUG rtx_dbug_outs((CHAR *) "Writing data: "); rtx_dbug_out_char(char_out); rtx_dbug_outs((CHAR *) "\r\n"); #endif } }
//Proc 1 of a two processor test //These tests will check to see if a block due to memory is handled right void mem_test4() { rtx_dbug_outs("Starting Memory Test 4\r\n"); rtx_dbug_outs("Requesting one block\r\n"); //print_availible_mem_queue(); //print_used_mem_queue(); //request 1 memory block void * oneBlock = request_memory_block(); rtx_dbug_outs_int("Block recieved. Block address: \r\n", (int)oneBlock); rtx_dbug_outs("Releasing proccessor in Memory Test 4\r\n"); //release the processor (to the other test) release_processor(); rtx_dbug_outs("Restarting Memory Test 4\r\n"); //print_availible_mem_queue(); //print_used_mem_queue(); //release the memory block release_memory_block(oneBlock); rtx_dbug_outs("Memory Block Got Released\r\n"); rtx_dbug_outs("Finished Memory Test 4\r\n"); }
void process_priority_proc(void) { msg_buf* message; message = (msg_buf*)request_memory_block(); message->mtype = KCD_REG; copy_string("%C", message->mtext); send_message(PID_KCD, message); while (1){ int neg_1 = -1; int mtext_len; msg_buf* message = (msg_buf*) receive_message(&neg_1); if (message == NULL) { continue; } mtext_len = str_len(message->mtext); if (message->mtext[1] == 'C' && (mtext_len == 8 || mtext_len == 7)) { int p_id; int p_priority; if (mtext_len == 7) { // %C X Y p_id = message->mtext[3] - '0'; p_priority = message->mtext[5] - '0'; } else { // %C XX Y p_id = (message->mtext[3] - '0') * 10; p_id = message->mtext[4] - '0'; p_priority = message->mtext[6] - '0'; } if (set_process_priority(p_id, p_priority) == RTX_ERR) { msg_buf* err_msg = (msg_buf*)request_memory_block(); Node* msg_node = (Node*)request_memory_block(); err_msg->mtype = CRT_DISPLAY; copy_string("Invalid Command for set process priority\n\r", err_msg->mtext); //sends error to CRT msg_node->sender_id = PID_SET_PRIO; msg_node->receiving_id = PID_CRT; msg_node->data = err_msg; send_message_node(msg_node); } } else { msg_buf* err_msg = (msg_buf*)request_memory_block(); Node* msg_node = (Node*)request_memory_block(); err_msg->mtype = CRT_DISPLAY; copy_string("Invalid Format for set process priority\n\r", err_msg->mtext); //sends error to CRT msg_node->sender_id = PID_SET_PRIO; msg_node->receiving_id = PID_CRT; msg_node->data = err_msg; send_message_node(msg_node); } release_memory_block(message); } }
void set_priority_proc(void) { /*sends message to kcd to register the command types*/ ENVELOPE *msg = (ENVELOPE *)request_memory_block(); msg->message_type = MSG_COMMAND_REGISTRATION; msg->sender_pid = SET_PRIORITY_PID; msg->destination_pid = KCD_PID; set_message(msg, "%C" + '\0', 4*sizeof(char)); send_message(KCD_PID, msg); while(1){ int priority, pid; ENVELOPE * rec_msg = (ENVELOPE*) receive_message(NULL); char * char_message = (char *) rec_msg->message; if ((char_message[3] >= '1')&&(char_message[3] <= '6')&&(char_message[4] == ' ')&&(char_message[5] >= '0')&&(char_message[5] <= '3') && (char_message[6] == '\0')){ pid = char_message[3] - '0'; priority = char_message[5] - '0'; //printf("message %s", char_message); //printf("pid %d priority %d", pid, priority); set_process_priority(pid, priority); } else { ENVELOPE * error_msg = (ENVELOPE*) request_memory_block(); error_msg->sender_pid = SET_PRIORITY_PID; error_msg->destination_pid = CRT_PID; error_msg->message_type = MSG_CRT_DISPLAY; error_msg->message = error_msg + HEADER_OFFSET; sprintf(error_msg->message, "You have entered an invalid input\n\r"); send_message(CRT_PID, error_msg); } release_memory_block(rec_msg); } }
//Test 1 reciever (message can be accurately sent/recieved) void proc2(void) { int pid = 2; int sender = 1; msgbuf *msg; msg = receive_message(&sender); //check message contents if (msg->mtype == DEFAULT && msg->mtext[0] == MSG_TEXT_1){ test_status[0] = TEST_SUCCESS;//TEST 1: Message contents same as when sent } else { test_status[0] = TEST_FAILURE;//message contents incorrect } release_memory_block(msg); //Done testing set_process_priority(pid, LOWEST); #ifdef _DEBUG_HOTKEYS // Force this process to be BLOCKED_ON_RECEIVE receive_message(NULL); #endif // _DEBUG_HOTKEYS while (1) { release_processor(); } }
/* Delayed Send Test */ void test_proc_p2_1(void) { int result_pid = 0; msg_buf_t* msg_envelope = NULL; char* msg = "Hello"; msg_envelope = (msg_buf_t*)request_memory_block(); strncpy(msg_envelope->msg_data, msg, 5); delayed_send(PID_P1, msg_envelope, CLOCK_INTERVAL); msg_envelope = (msg_buf_t*)receive_message(NULL); if (strcmp(msg_envelope->msg_data, msg) == 5) { printf("G005_test: test 1 OK\r\n"); } else { printf("G005_test: test 1 FAIL\r\n"); test_results[result_pid] = 0; } release_memory_block(msg_envelope); test_ran[result_pid] = 1; set_process_priority(g_test_procs[result_pid].pid, 3); while (1) { release_processor(); } }
void kcd_proc(void) { ENVELOPE* msg; int i; while(1) { msg = (ENVELOPE*) receive_message(NULL); if (msg != NULL) { if (msg->message_type == MSG_COMMAND_REGISTRATION) { for (i = 0; i < KC_MAX_COMMANDS; i++) { if (g_kc_reg[i].pid == -1) { g_kc_reg[i].pid = msg->sender_pid; strcpy(g_kc_reg[i].command, msg->message); break; } } } else if (msg->message_type == MSG_CONSOLE_INPUT) { int i = 0; int j; char command[KC_MAX_CHAR]; char* message_curr = msg->message; while ((i < KC_MAX_CHAR)&&(message_curr[i] != ' ')&&(message_curr[i] != '\0')) { command[i] = message_curr[i]; i++; } command[i] = '\0'; // find end of message while (message_curr[i] != '\0') { i++; } for (j = 0; j < KC_MAX_COMMANDS; j++) { if ((strcmp(command,g_kc_reg[j].command) == 0)&&(g_kc_reg[j].pid != -1)) { ENVELOPE* kcd_msg = (ENVELOPE*) request_memory_block(); kcd_msg->sender_pid = KCD_PID; kcd_msg->destination_pid = g_kc_reg[j].pid; kcd_msg->nextMsg = NULL; kcd_msg->message_type = MSG_KCD_DISPATCH; kcd_msg->delay = 0; set_message(kcd_msg, message_curr, i*sizeof(char)); send_message(g_kc_reg[j].pid, kcd_msg); break; } } } } release_memory_block(msg); } }
/* Sends message to user process 2 */ void test_proc_p2_3(void) { int result_pid = 2; msg_buf_t* msg_envelope = 0; char* sent_msg = "OS"; char* received_msg = "SE350"; msg_envelope = (msg_buf_t*)request_memory_block(); strncpy(msg_envelope->msg_data, sent_msg, 2); send_message(PID_P2, msg_envelope); msg_envelope = (msg_buf_t*)receive_message(NULL); if (strcmp(msg_envelope->msg_data, received_msg) == 5) { printf("G005_test: test 3 OK\r\n"); } else { printf("G005_test: test 3 FAIL\r\n"); test_results[result_pid] = 0; } release_memory_block(msg_envelope); test_ran[result_pid] = 1; set_process_priority(g_test_procs[result_pid].pid, 3); while (1) { release_processor(); } }
/** * @brief: a process that prints five numbers * and then releases a memory block */ void proc2(void) { int i = 0; int ret_val = 20; void *p_mem_blk; p_mem_blk = request_memory_block(); set_process_priority(PID_P2, MEDIUM); while ( 1) { if ( i != 0 && i%5 == 0 ) { uart0_put_string("\n\r"); ret_val = release_memory_block(p_mem_blk); #ifdef DEBUG_0 printf("proc2: ret_val=%d\n", ret_val); #endif /* DEBUG_0 */ if ( ret_val == -1 ) { break; } } uart0_put_char('0' + i%10); i++; } uart0_put_string("proc2: end of testing\n\r"); set_process_priority(PID_P2, LOWEST); while ( 1 ) { release_processor(); } }
void kcd_proc(void) { char command_registry[NUM_PROCS]; U32 it; for(it = 0; it < NUM_PROCS; it++){ command_registry[it] = '/'; } while (true) { int sender_id = -1; msg_buf* message = (msg_buf*)receive_message(&sender_id); if (message == NULL) { continue; } if(message->mtype == KCD_REG){ command_registry[sender_id] = message->mtext[1]; release_memory_block(message); } else if(message->mtype == DEFAULT){ if(message->mtext[0] != '%'){ release_memory_block(message); } else{ //valid command int i; for (i = 0; i < NUM_PROCS; i++){ if(message->mtext[1] == command_registry[i]){ //send msg to process with associated command Node* msg_node = (Node*)request_memory_block(); msg_node->sender_id = PID_KCD; msg_node->receiving_id = i; msg_node->data = message; send_message_node(msg_node); } } if (i == NUM_PROCS){ release_memory_block(message); } } } else { release_memory_block(message); } } }
//This function requests all blocks, realeases all of them (in backwards order), //and tries to request another block (should succeed) void mem_test3 () { rtx_dbug_outs("Starting Memory Test 3\r\n"); void * testArray[32]; rtx_dbug_outs("Requesting all memory blocks\r\n"); //print_availible_mem_queue(); //print_used_mem_queue(); //request all memory blocks int i; for (i = 0; i < 32; i++) { testArray[i] = request_memory_block(); } rtx_dbug_outs("All memory blocks requested\r\n"); //print_availible_mem_queue(); //print_used_mem_queue(); //release all memory blocks for (i = 31; i >= 0; i--) { release_memory_block(testArray[i]); } rtx_dbug_outs("All blocks released\r\n"); //print_availible_mem_queue(); //print_used_mem_queue(); //request one more block void * oneMore; oneMore = request_memory_block(); rtx_dbug_outs("One more block given\r\n"); //release last one release_memory_block(oneMore); rtx_dbug_outs("Finished Memory Test 3\r\n"); }
/** * @brief: Requests memory blocks and returns */ void memory_block_test(void) { int ret_val = 60; int i = 0; int* tmp_int; char* tmp_string; while(1) { print_debug("Iterating through proc 4 with\r\n"); tmp_int = request_memory_block(); tmp_string = request_memory_block(); i++; *tmp_int = i; if (i > 1337) { i = 0; } tmp_string[0] = 'H'; tmp_string[1] = 'E'; tmp_string[2] = 'L'; tmp_string[3] = 'L'; tmp_string[4] = 'O'; tmp_string[5] = '\0'; //printf("INT! Address: 0x%x, Value: %d\r\n",tmp_int,*tmp_int); print_debug("CHAR[]!: "); print_debug(tmp_string); print_debug("\r\n"); //printf("CHAR[]! Address: 0x%x, Value: %s\r\n",&tmp_string,tmp_string); release_memory_block(tmp_int); release_memory_block(tmp_string); print_debug("Proc 4 completed!\r\n"); ret_val = release_processor(); if (ret_val == -1) { print_debug("G021_test: test 4 FAIL\r\n"); test_results[3] = 0; } else { print_debug("G021_test: test 4 OK\r\n"); } } }
void C (void) { Q_Queue local_mailbox; int sender_pid; q_init(&local_mailbox); while (1) { msg* p; if (local_mailbox.first == NULL) { p = (msg*)(receive_message(&sender_pid)); } else { p = (msg*)q_pop(&local_mailbox); } if (p->mtype == 3) { int msg_value = atoi(p->mtext); if (msg_value%20 == 0) { msg* MessageToSend = (msg*)request_memory_block(); msg* q = (msg*)request_memory_block(); MessageToSend->mtype = 2; MessageToSend->mtext = "Process C"; send_message(13, MessageToSend); q->mtype = 4; q->mtext = ""; delayed_send(7,q,10000); while (1) { msg* r; r = (msg*)(receive_message(&sender_pid)); //block and let other processes execute if (r->mtype == 4) { release_memory_block(r); break; } else { q_push(&local_mailbox, r); } } } } release_memory_block(p); release_processor(); } }
void proc2(void) { while (1) { lastMemBlock = request_memory_block(); printf("mem block: %X\n", lastMemBlock); results[2] = (lastMemBlock == 0) ? 0 : 1; release_processor(); release_memory_block(lastMemBlock); } }
//Test 4 (normal message is recieved before a delayed message) void proc4(void) { int pid = 4; msgbuf *delayed_msg; msgbuf *normal_msg; msgbuf *received_msg; //create delayed message delayed_msg = request_memory_block(); delayed_msg->mtype = DEFAULT; delayed_msg->mtext[0] = MSG_TEXT_1; //create normal message normal_msg = request_memory_block(); normal_msg->mtype = DEFAULT; normal_msg->mtext[0] = MSG_TEXT_2;//different text from the delayed message //send delayed message delayed_send(pid, delayed_msg, DELAY); //send normal message send_message(pid, normal_msg); //recieve message received_msg = receive_message(&pid); //if normal message, mark test passed if (received_msg->mtext[0] == MSG_TEXT_2){//should get the non delayed message before the delayed message even though it was sent later. test_status[3] = TEST_SUCCESS;//TEST 4: normal message is recieved before delayed message } else { test_status[3] = TEST_FAILURE; } //release message memory release_memory_block(received_msg); //recieve massage received_msg = receive_message(&pid);//reusing variable now that the test is finished. //release message memory release_memory_block(received_msg); //Done testing set_process_priority(pid, LOWEST); while (1) { release_processor(); } }
//TC 4: KCD and CRT void proc4(void) { MSG_BUF* msg = NULL; msg = (MSG_BUF*)request_memory_block(); msg->mtype = KCD_REG; msg->mtext[0] = '%'; msg->mtext[1] = 'T'; msg->mtext[2] = 'E'; msg->mtext[3] = 'S'; msg->mtext[4] = 'T'; msg->mtext[4] = '\0'; send_message(PID_KCD, msg); msg = (MSG_BUF*)request_memory_block(); msg->mtype = CRT_DISPLAY; strcpy(msg->mtext, "Input %TEST and press enter:\n\r"); send_message(PID_CRT, msg); msg = receive_message(NULL); if (strcmp(msg->mtext, "%TEST") == 0) { prev_success = 1; } else { prev_success = 0; } release_memory_block(msg); if (prev_success) { uart1_put_string("G003_test: test "); uart1_put_char(4 + 48); uart1_put_string(" OK\n\r"); pass = pass + 1; } else { uart1_put_string("G003_test: test "); uart1_put_char(4 + 48); uart1_put_string(" FAIL\n\r"); } uart1_put_string("G003_test: "); uart1_put_char(pass + 48); uart1_put_string("/"); uart1_put_char(total + 48); uart1_put_string(" tests OK\n\r"); uart1_put_string("G003_test: "); uart1_put_char((total - pass) + 48); uart1_put_string("/"); uart1_put_char(total + 48); uart1_put_string(" tests FAIL\n\r"); uart1_put_string("G003_test: END\n\r"); while (1) { release_processor(); } }
// highest priority void mem_test_blocking2() { // block this process void * msg = receive_message(NULL); void * msgBack = request_memory_block(); send_message(MEM_TEST_MASTER_PID, msgBack); release_memory_block(msg); }
void crt(){ void * msg; CHAR * s; while(1){ msg = receive_message(NULL); *s = *(read_message(msg)); uprintf(s); release_memory_block(msg); } return; }
void crt_proc(void) { Envelope *temp = NULL; uint32_t localWriter = 0; uint32_t localReader = 0; while (1) { Envelope *nextMsg = NULL; while (crt_hasFreeEnv(&(gProcInfo.crtData))) { temp = crt_getFreeEnv(&(gProcInfo.crtData)); if (temp->messageType == MT_DEBUG && temp->srcPid == CRT_PID) { // NOTE(sanjay): we DO NOT want to free this envelope, it's a // preallocated buffer stored inside a process' PCB --(gProcInfo.debugSem); continue; } else if ( temp->srcPid == CRT_PID && temp->messageType == MT_KEYBOARD ) { // NOTE(sanjay): we DO NOT want to free this envelope, it's a // preallocated buffer that echoes keyboard output gProcInfo.currentEnv = temp; continue; } release_memory_block((void*)temp); } nextMsg = (Envelope *)receive_message(NULL); if (nextMsg == NULL) { continue; } if (nextMsg->srcPid == CRT_PID && nextMsg->messageType == MT_CRT_WAKEUP) { gProcInfo.uartOutputEnv = nextMsg; } else { crt_pushProcEnv(&(gProcInfo.crtData), nextMsg); } localWriter = gProcInfo.outWriter; localReader = gProcInfo.outReader; while ( ((localWriter + 1) % OUTPUT_BUFSIZE != localReader) && (crt_hasOutByte(&(gProcInfo.crtData))) ) { gProcInfo.outputBuf[localWriter] = crt_getOutByte(&(gProcInfo.crtData)); localWriter = (localWriter + 1) % OUTPUT_BUFSIZE; } gProcInfo.outWriter = localWriter; gProcInfo.outLock = 1; uart_send_char_isr(&gProcInfo); gProcInfo.outLock = 0; } }
/** * This process will request 2 memory blocks, print their value * then release them. Finally it will output the return value; */ void test_proc_p1_2() { int ret; int i = 0; int proc = 1; void* memory1 = 0; void* memory2 = 0; while (1) { //printf("Process 2\r\n"); memory1 = request_memory_block(); memory2 = request_memory_block(); *((int*)memory1) = 0xDEAD10CC; *((int*)memory2) = 0xDEADC0DE; if (*((int*)memory1) != 0xDEAD10CC) { test_results[g_test_procs[proc].pid] = 0; } ret = release_memory_block(memory1); if (ret != 0 && i == 0) { test_results[g_test_procs[proc].pid] = 0; } if (*((int*)memory2) != 0xDEADC0DE) { test_results[g_test_procs[proc].pid] = 0; } ret = release_memory_block(memory2); if (ret != 0 && i == 0) { test_results[g_test_procs[proc].pid] = 0; } if (i == 0) { if (test_results[proc] == 1) { printf("G005_test: test 2 OK\r\n"); } else { printf("G005_test: test 2 FAIL\r\n"); } } i = 1; ret = release_processor(); } }
void uart_keyboard_proc(void) { Envelope *message = NULL; ProcId registry['z' - 'a' + 1] = {0}; ProcId destPid = 0; char c = '\0'; uint8_t reject = 1; while (1) { message = receive_message(NULL); if (message == NULL) { continue; } if (message->srcPid != KEYBOARD_PID) { c = toLowerAndIsLetter(message->messageData[0]); if ('a' <= c && c <= 'z') { registry[c - 'a'] = message->srcPid; } release_memory_block((void *)message); message = NULL; continue; } // If it is "from ourself", then we send a message to the registered processes. c = message->messageData[0]; reject = 1; if (c == '%') { c = toLowerAndIsLetter(message->messageData[1]); if (c != '\0') { destPid = registry[c - 'a']; if (destPid != 0) { reject = 0; } } } if (reject) { size_t i = 0; size_t bufLen = MESSAGEDATA_SIZE_BYTES - 1; message->messageData[i++] = FC_RED; i += write_string(message->messageData+i, bufLen-i, "No handler found for this command.\n"); message->messageData[i++] = '\0'; message->messageType = MT_UNSET; send_message(CRT_PID, message); message = NULL; } else { // Send the message to the proc that registered with this character send_message(destPid, message); message = NULL; } } }
void crt_proc(void) { while(1){ ENVELOPE* env = (ENVELOPE*) receive_message(NULL); LPC_UART_TypeDef *pUart = (LPC_UART_TypeDef *)LPC_UART0; if (env->message_type == MSG_CRT_DISPLAY){ send_message(UART_IPROC_PID, env); pUart->IER |= IER_THRE; } else { release_memory_block(env); } } }
void wall_clock_proc() { MSG_BUF *msg; void *mem; int i = 0; MSG_BUF *p_msg_env; long time = 0; // second char second[2], minute[2], hour[2]; int start = 0; while (1) { if (i==0) { i++; p_msg_env = (struct msgbuf *) request_memory_block(); p_msg_env->mtype = KCD_REG; p_msg_env->mtext[0] = '%'; p_msg_env->mtext[1] = 'W'; p_msg_env->mtext[2] = '\0'; send_message(PID_KCD, (void *)p_msg_env); } msg = receive_message((int*)PID_CLOCK); switch (msg->mtype) { case UPDATE_TIME: if (start == 1) { time ++; wall_clock_display(time); } break; default: switch (msg->mtext[2]) { case 'R': time = 0; break; case 'S': time = charToTime(msg->mtext, 4); if (start == 0) { start = 1; wall_clock_display(time); } break; case 'T': start = 0; break; default: break; } break; } release_memory_block((void*)msg); release_processor(); } }