/// Execute a guest command without expecting the output /// Return AGENT_RET_SUCCESS if succeed or AGENT_RET_EFAIL if fail static MBA_AGENT_RETURN _MOCKABLE(execute_guest_cmd_noreturn)( void ) { char cmd_emit[SZ_MAX_COMMAND]; int n_wbytes; const char* cmdline = ac->act.cmdline; // construct the final command for agent server bzero( cmd_emit, SZ_MAX_COMMAND ); snprintf( cmd_emit, SZ_MAX_COMMAND, "invo %s", cmdline ); // emit command n_wbytes = as_write( ac->sock, cmd_emit, SZ_MAX_COMMAND ); if( n_wbytes != SZ_MAX_COMMAND ) { agent_printf( "Failed to emit command '%s'\n", cmd_emit ); return AGENT_RET_EFAIL; } if ( !ecm_read() ) { agent_printf("Error occurs when server creating process.\n"); return AGENT_RET_EFAIL; } return AGENT_RET_SUCCESS; }
void test_write() { asm_p as = &(asm_t){ 0 }; as_new(as); as_write(as, "0000 1111"); st_check( code_cmp(as, (uint8_t[]){ 0x0f }, 1) ); as_clear(as); as_write(as, "0000 1111 : 1000 1111"); st_check( code_cmp(as, (uint8_t[]){ 0x0f, 0x8f }, 2) ); as_clear(as); as_write(as, "0100 WRXB", 0, 1, 0, 1); st_check( code_cmp(as, (uint8_t[]){ 0b01000101 }, 1) ); as_clear(as); as_write(as, "mm rrr bbb", 0b00, 0b111, 0b110); st_check( code_cmp(as, (uint8_t[]){ 0b00111110 }, 1) ); as_clear(as); as_write(as, "xxxx xxxx", 0b10110001); st_check( code_cmp(as, (uint8_t[]){ 0b10110001 }, 1) ); as_clear(as); as_write(as, "0000 1111 : xxxx 1111", 0b1010); st_check( code_cmp(as, (uint8_t[]){ 0x0f, 0b10101111 }, 2) ); as_clear(as); as_write(as, "1000 0001 : %32d", 0xaabbccdd); st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0xdd, 0xcc, 0xbb, 0xaa }, 5) ); as_clear(as); as_destroy(as); }
void test_write() { asm_p as = &(asm_t){ 0 }; as_write(as, "0000 1111"); st_check( code_cmp(as, (uint8_t[]){ 0x0f }, 1) ); as_free(as); as_write(as, "0000 1111 : 1000 1111"); st_check( code_cmp(as, (uint8_t[]){ 0x0f, 0x8f }, 2) ); as_free(as); as_write(as, "0100 WRXB", 0, 1, 0, 1); st_check( code_cmp(as, (uint8_t[]){ 0b01000101 }, 1) ); as_free(as); as_write(as, "mm rrr bbb", 0b00, 0b111, 0b110); st_check( code_cmp(as, (uint8_t[]){ 0b00111110 }, 1) ); as_free(as); as_write(as, "xxxx xxxx", 0b10110001); st_check( code_cmp(as, (uint8_t[]){ 0b10110001 }, 1) ); as_free(as); as_write(as, "0000 1111 : xxxx 1111", 0b1010); st_check( code_cmp(as, (uint8_t[]){ 0x0f, 0b10101111 }, 2) ); as_free(as); as_write(as, "1000 0001 : %8d", 0xab); st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0xab }, 2) ); as_free(as); // Remember, integers are little-endian in memory as_write(as, "1000 0001 : %16d", 0xaabb); st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0xbb, 0xaa }, 3) ); as_free(as); as_write(as, "1000 0001 : %32d", 0xaabbccdd); st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0xdd, 0xcc, 0xbb, 0xaa }, 5) ); as_free(as); as_write(as, "1000 0001 : %64d", 0xaabbccdd11223344); st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0x44, 0x33, 0x22, 0x11, 0xdd, 0xcc, 0xbb, 0xaa }, 9) ); as_free(as); }
/// (E)rror (C)heck (M)essage write /// A wrapper of sending error check messages. /// /// \param suc_or_fail Determinator for error check message, TRUE for MSG_REC_SUCCESS and FALSE for MSG_REC_FAIL /// /// Return none static void _MOCKABLE(ecm_write)( bool suc_or_fail ) { char errorbuf[sizeof(MSG_REC_SUCCESS)]; if ( suc_or_fail ) { // --------construct the result to the server-------- // bzero( errorbuf, sizeof(MSG_REC_SUCCESS) ); snprintf( errorbuf, sizeof(MSG_REC_SUCCESS), MSG_REC_SUCCESS ); // --------send the result to the server-------- // as_write( ac->sock, errorbuf, sizeof(MSG_REC_SUCCESS) ); } else { // --------construct the result to the server-------- // bzero( errorbuf, sizeof(MSG_REC_FAIL) ); snprintf( errorbuf, sizeof(MSG_REC_FAIL), MSG_REC_FAIL ); // --------send the result to the server-------- // as_write( ac->sock, errorbuf, sizeof(MSG_REC_FAIL) ); } }
void agent_handle_exec_command( const char* cmdline ) { char cmd_emit[SZ_MAX_COMMAND]; if( !agent_is_ready() || !agent_is_exec() ) return; bzero( cmd_emit, SZ_MAX_COMMAND ); strncpy( cmd_emit, cmdline, SZ_MAX_COMMAND - 1 ); // append the newline character strcat( cmd_emit, "\n" ); // forward execute command to agent server as_write( ac->sock, cmd_emit, SZ_MAX_COMMAND ); }
void test_write_elf() { asm_p as = &(asm_t){ 0 }; size_t code_vaddr = 4 * 1024 * 1024; size_t data_vaddr = 512 * 1024 * 1024; const char* text_ptr = "Hello World!\n"; size_t text_len = strlen(text_ptr); size_t text_offset = as_data(as, text_ptr, text_len); // mov RAX, 1 // write syscall as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b000, 1); // mov RDI, 1 // stdout, RDI = R7 = 0b0111 as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b111, 1); // mov RSI, text_vaddr // text_ptr, RSI = R6 = 0b0110 as_write(as, "0100 000B : 1011 wrrr : %32d", 0, 1, 0b110, data_vaddr + text_offset); // mov RDX, text_len // text len, RDX = R2 = 0b0010 as_write(as, "0100 000B : 1011 wrrr : %32d", 0, 1, 0b010, text_len); // syscall as_write(as, "0000 1111 : 0000 0101"); // mov RAX, 60 // exit syscall as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b000, 60); // mov RDI, 1 // exit code, RDI = R7 = 0b0111 as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b111, 1); // syscall as_write(as, "0000 1111 : 0000 0101"); as_save_elf(as, code_vaddr, data_vaddr, "test_write_elf.elf"); as_free(as); char* output = NULL; int status_code = run_and_delete("test_write_elf.elf", "./test_write_elf.elf", &output); st_check_int(status_code, 1); st_check_str(output, text_ptr); free(output); }
/// Flush the information in cache into disk. /// Return AGENT_RET_SUCCESS if succeed or AGENT_RET_EFAIL if fail static MBA_AGENT_RETURN _MOCKABLE(sync_cache)( void ) { char cmd_emit[SZ_MAX_COMMAND] = "sync" ; int n_wbytes; // emit command n_wbytes = as_write( ac->sock, cmd_emit, SZ_MAX_COMMAND ); if( n_wbytes != SZ_MAX_COMMAND ) { agent_printf( "Failed to emit command '%s'\n", cmd_emit ); goto sync_fail; } // --------Check if server is able to open file-------- // if ( !ecm_read() ) { agent_printf("Error occurs when server flushing file buffer.\n"); goto sync_fail; } return AGENT_RET_SUCCESS; sync_fail: return AGENT_RET_EFAIL; }
int main (int argc, char* argv[]) { /* --- main function */ int i, k = 0; /* loop variables, buffer */ char *s; /* to traverse options */ char **optarg = NULL; /* option argument */ char *fn_bc = NULL; /* name of classifier file */ char *fn_out = NULL; /* name of output file */ char *blank = NULL; /* blank */ char *fldsep = NULL; /* field separator */ char *recsep = NULL; /* record separator */ int flags = AS_ATT; /* table file write flags */ double lcorr = -DBL_MAX; /* Laplace correction value */ int dwnull = 0; /* distribute weight of null values */ int maxllh = 0; /* max. likelihood est. of variance */ int tplcnt = 1000; /* number of tuples to generate */ long seed; /* seed for random number generator */ int mode; /* classifier setup mode */ prgname = argv[0]; /* get program name for error msgs. */ seed = (long)time(NULL); /* and get a default seed value */ /* --- print startup/usage message --- */ if (argc > 1) { /* if arguments are given */ fprintf(stderr, "%s - %s\n", argv[0], DESCRIPTION); fprintf(stderr, VERSION); } /* print a startup message */ else { /* if no argument given */ printf("usage: %s [options] bcfile " "[-d|-h hdrfile] tabfile\n", argv[0]); printf("%s\n", DESCRIPTION); printf("%s\n", VERSION); printf("-n# number of tuples to generate " "(default: %d)\n", tplcnt); printf("-s# seed for random number generator " "(default: time)\n"); printf("-L# Laplace correction " "(default: as specified in classifier)\n"); printf("-v/V (do not) distribute tuple weight " "for null values\n"); printf("-m/M (do not) use maximum likelihood estimate " "for the variance\n"); printf("-a align fields (default: do not align)\n"); printf("-w do not write field names to the output file\n"); printf("-b/f/r# blank character, field and record separator\n" " (default: \" \", \" \", \"\\n\")\n"); printf("bcfile file containing classifier description\n"); printf("tabfile table file to write\n"); return 0; /* print a usage message */ } /* and abort the program */ /* --- evaluate arguments --- */ for (i = 1; i < argc; i++) { /* traverse arguments */ s = argv[i]; /* get option argument */ if (optarg) { *optarg = s; optarg = NULL; continue; } if ((*s == '-') && *++s) { /* -- if argument is an option */ while (*s) { /* traverse options */ switch (*s++) { /* evaluate option */ case 'n': tplcnt = (int)strtol(s, &s, 0); break; case 's': seed = strtol(s, &s, 0); break; case 'L': lcorr = strtod(s, &s); break; case 'v': dwnull = NBC_ALL; break; case 'V': dwnull |= NBC_DWNULL|NBC_ALL; break; case 'm': maxllh = NBC_ALL; break; case 'M': maxllh |= NBC_MAXLLH|NBC_ALL; break; case 'a': flags |= AS_ALIGN; break; case 'w': flags &= ~AS_ATT; break; case 'b': optarg = ␣ break; case 'f': optarg = &fldsep; break; case 'r': optarg = &recsep; break; default : error(E_OPTION, *--s); break; } /* set option variables */ if (!*s) break; /* if at end of string, abort loop */ if (optarg) { *optarg = s; optarg = NULL; break; } } } /* get option argument */ else { /* if argument is no option */ switch (k++) { /* evaluate non-option */ case 0: fn_bc = s; break; case 1: fn_out = s; break; default: error(E_ARGCNT); break; } /* note filenames */ } } if (optarg) error(E_OPTARG); /* check the option argument */ if (k != 2) error(E_ARGCNT); /* and the number of arguments */ if ((lcorr < 0) && (lcorr > -DBL_MAX)) error(E_NEGLC); /* check the Laplace correction */ if ((flags & AS_ATT) && (flags & AS_ALIGN)) flags |= AS_ALNHDR; /* set align to header flag */ /* --- read Bayes classifier --- */ scan = sc_create(fn_bc); /* create a scanner */ if (!scan) error((!fn_bc || !*fn_bc) ? E_NOMEM : E_FOPEN, fn_bc); attset = as_create("domains", att_delete); if (!attset) error(E_NOMEM); /* create an attribute set */ fprintf(stderr, "\nreading %s ... ", sc_fname(scan)); if ((sc_nexter(scan) < 0) /* start scanning (get first token) */ || (as_parse(attset, scan, AT_ALL) != 0) || (as_attcnt(attset) <= 0)) /* parse attribute set */ error(E_PARSE, sc_fname(scan)); if ((sc_token(scan) == T_ID) /* determine classifier type */ && (strcmp(sc_value(scan), "fbc") == 0)) fbc = fbc_parse(attset, scan); else nbc = nbc_parse(attset, scan); if ((!fbc && !nbc) /* parse the Bayes classifier */ || !sc_eof(scan)) /* and check for end of file */ error(E_PARSE, sc_fname(scan)); sc_delete(scan); scan = NULL; /* delete the scanner */ fprintf(stderr, "[%d attribute(s)] done.\n", as_attcnt(attset)); if ((lcorr >= 0) || dwnull || maxllh) { if (lcorr < 0) /* get the classifier's parameters */ lcorr = (fbc) ? fbc_lcorr(fbc) : nbc_lcorr(nbc); mode = (fbc) ? fbc_mode(fbc) : nbc_mode(nbc); if (dwnull) mode = (mode & ~NBC_DWNULL) | dwnull; if (maxllh) mode = (mode & ~NBC_MAXLLH) | maxllh; /* adapt the estimation parameters */ if (fbc) fbc_setup(fbc, mode, lcorr); else nbc_setup(nbc, mode, lcorr); } /* set up the classifier anew */ /* --- generate database --- */ if (fn_out && *fn_out) /* if an output file name is given, */ out = fopen(fn_out, "w"); /* open output file for writing */ else { /* if no output file name is given, */ out = stdout; fn_out = "<stdout>"; } /* write to std. output */ fprintf(stderr, "writing %s ... ", fn_out); if (!out) error(E_FOPEN, fn_out); if ((flags & AS_ATT) /* if to write a table header */ && (as_write(attset, out, flags) != 0)) error(E_FWRITE, fn_out); /* write the attributes names */ flags = AS_INST | (flags & ~AS_ATT); dseed(seed); /* init. random number generator */ for (i = tplcnt; --i >= 0;) { /* generate random tuples */ if (fbc) fbc_rand(fbc, drand); /* instantiate the */ else nbc_rand(nbc, drand); /* attribute set */ if (as_write(attset, out, flags) != 0) error(E_FWRITE,fn_out); /* write the generated tuple */ } /* to the output file */ if (out != stdout) { /* if not written to stdout */ i = fclose(out); out = NULL;/* close the output file */ if (i != 0) error(E_FWRITE, fn_out); } /* print a success message */ fprintf(stderr, "[%d tuple(s)] done.\n", tplcnt); /* --- clean up --- */ #ifndef NDEBUG if (fbc) fbc_delete(fbc, 1); /* delete full Bayes classifier */ if (nbc) nbc_delete(nbc, 1); /* or naive Bayes classifier */ #endif /* and underlying attribute set */ #ifdef STORAGE showmem("at end of program"); /* check memory usage */ #endif return 0; /* return 'ok' */ } /* main() */
/// Export the agent server log to host /// Return AGENT_RET_SUCCESS if succeed or AGENT_RET_EFAIL if fail static MBA_AGENT_RETURN _MOCKABLE(export_agent_log)( void ) { char cmd_emit[SZ_MAX_COMMAND]; uint64_t fsize; char fbuf[SZ_MAX_FILECHUNK]; char* fptr; int fd = -1; int n_rbytes; int n_wbytes; const char* dst_path = ac->act.dst_path; // construct the final command for agent server bzero( cmd_emit, SZ_MAX_COMMAND ); snprintf( cmd_emit, SZ_MAX_COMMAND, "logf" ); // emit command n_wbytes = as_write( ac->sock, cmd_emit, SZ_MAX_COMMAND ); if( n_wbytes != SZ_MAX_COMMAND ) { agent_printf( "Failed to emit command '%s'\n", cmd_emit ); return AGENT_RET_EFAIL; } // --------Check if server is able to duplicate log handle, set file pointer and read filesize-------- // if ( !ecm_read() ) { agent_printf("Error occurs when server duplicate log handle, set file pointer or read filesize.\n"); return AGENT_RET_EFAIL; } // receive log file size n_rbytes = as_read( ac->sock, &fsize, sizeof(uint64_t) ); if( n_rbytes != sizeof(uint64_t) ) { agent_printf( "Failed to receive log file size\n" ); return AGENT_RET_EFAIL; } // open destination file to store the log fd = open( dst_path, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ); if( fd == -1 ) { agent_printf( "Failed to open '%s' for agent log export\n", dst_path ); ecm_write( FALSE ); return AGENT_RET_EFAIL; } ecm_write( TRUE ); // receive & store file content while( fsize ) { // measure the maximum bytes should be read n_rbytes = (fsize < SZ_MAX_FILECHUNK) ? fsize : SZ_MAX_FILECHUNK; // --------Check if server is able to read file-------- // if ( !ecm_read() ) { agent_printf("Error occurs when server reading file.\n"); close(fd); return AGENT_RET_EFAIL; } // receive file content from agent server n_rbytes = as_read( ac->sock, fbuf, n_rbytes ); if( n_rbytes <= 0 ) { agent_printf( "Failed to receive file content\n" ); close(fd); return AGENT_RET_EFAIL; } fsize -= n_rbytes; // store to local file fptr = fbuf; while( n_rbytes ) { n_wbytes = write( fd, fptr, n_rbytes ); if( n_wbytes == -1 ) { agent_printf( "Failed to store file content\n" ); ecm_write( FALSE ); close(fd); return AGENT_RET_EFAIL; } ecm_write( TRUE ); n_rbytes -= n_wbytes; fptr += n_wbytes; } } close( fd ); return AGENT_RET_SUCCESS; }
/// Execute a guest command and perform interactive stdin/stdout /// Return AGENT_RET_SUCCESS if succeed or AGENT_RET_EFAIL if fail static MBA_AGENT_RETURN _MOCKABLE(execute_guest_cmd_return)( void ) { char cmd_emit[SZ_MAX_COMMAND]; uint32_t msize; char msg_chunk[4096]; int n_rbytes; int n_wbytes; const char* cmdline = ac->act.cmdline; int i; // construct the final command for agent server bzero( cmd_emit, SZ_MAX_COMMAND ); snprintf( cmd_emit, SZ_MAX_COMMAND, "exec %s", cmdline ); // emit command n_wbytes = as_write( ac->sock, cmd_emit, SZ_MAX_COMMAND ); if( n_wbytes != SZ_MAX_COMMAND ) { agent_printf( "Failed to emit command '%s'\n", cmd_emit ); return AGENT_RET_EFAIL; } // Check if server has finished all the preparations if ( !ecm_read() ) { agent_printf("Error occurs when server does preparations for w_exec.\n"); return AGENT_RET_EFAIL; } // infinite loop to receive guest output msize = 0; while( true ) { // get output message size n_rbytes = as_read( ac->sock, &msize, sizeof(uint32_t) ); if( n_rbytes != sizeof(uint32_t) ) return AGENT_RET_EFAIL; if( msize == 0 ) break; // get & print message(may not be null-terminated) content while( msize ) { // measure the maximum bytes should be read n_rbytes = (msize < sizeof(msg_chunk)) ? msize : sizeof(msg_chunk); // read output message n_rbytes = as_read( ac->sock, msg_chunk, n_rbytes ); if( n_rbytes <= 0 ) { agent_printf( "Failed to revceive agent exec output\n" ); return AGENT_RET_EFAIL; } for( i = 0; i < n_rbytes; ++i ) agent_printf( "%c", msg_chunk[i] ); msize -= n_rbytes; } } if ( !ecm_read() ) { agent_printf("Agent Server do not finish closing handles after w_exec"); return AGENT_RET_EFAIL; } return AGENT_RET_SUCCESS; }
/// Import a host file into guest /// /// Return AGENT_RET_SUCCESS if succeed or AGENT_RET_EFAIL if fail static MBA_AGENT_RETURN _MOCKABLE(import_host_file)( void ) { int fd = -1; struct stat fstat; uint64_t fsize; char fbuf[SZ_MAX_FILECHUNK]; char* fptr; char cmd_emit[SZ_MAX_COMMAND]; int n_rbytes; int n_wbytes; const char* dst_path = ac->act.dst_path; const char* src_path = ac->act.src_path; // Open the target file fd = open( src_path, O_RDONLY ); if( fd == -1 ) { agent_printf( "Failed to open '%s' for file import\n", src_path ); return AGENT_RET_EFAIL; } // get file size if( stat(src_path, &fstat) == -1 ) { agent_printf( "Failed to get the file status of '%s'\n", src_path ); close( fd ); return AGENT_RET_EFAIL; } fsize = fstat.st_size; // construct the final command for agent server bzero( cmd_emit, SZ_MAX_COMMAND ); snprintf( cmd_emit, SZ_MAX_COMMAND, "impo %s", dst_path ); // emit command n_wbytes = as_write( ac->sock, cmd_emit, SZ_MAX_COMMAND ); if( n_wbytes != SZ_MAX_COMMAND ) { agent_printf( "Failed to emit command '%s'\n", cmd_emit ); close( fd ); return AGENT_RET_EFAIL; } // send file size n_wbytes = as_write( ac->sock, &fsize, sizeof(uint64_t) ); if( n_wbytes != sizeof(uint64_t) ) { agent_printf( "Failed to send file size: %u\n", fsize ); close( fd ); return AGENT_RET_EFAIL; } // --------Check if server is able to open file-------- // if ( !ecm_read() ) { agent_printf("Error occurs when server opens file.\n"); close( fd ); return AGENT_RET_EFAIL; } // read & send file content to server while( fsize ) { // read local file n_rbytes = read( fd, fbuf, SZ_MAX_FILECHUNK ); if( n_rbytes == -1 ) { agent_printf( "Failed to read content of '%s'\n", src_path ); ecm_write( FALSE ); close( fd ); return AGENT_RET_EFAIL; } ecm_write( TRUE ); fsize -= n_rbytes; // send to agent server fptr = fbuf; while( n_rbytes ) { n_wbytes = as_write( ac->sock, fptr, n_rbytes ); if( n_wbytes <= 0 ) { agent_printf( "Failed to send file content\n" ); close( fd ); return AGENT_RET_EFAIL; } // --------Check if server can write file successfully-------- // if ( !ecm_read() ) { agent_printf("Error occurs when server writes file.\n"); close( fd ); return AGENT_RET_EFAIL; } if ( n_rbytes < SZ_MAX_FILECHUNK ) // --------Check if server set file pointer successfully-------- // if ( !ecm_read() ) { agent_printf("Error occurs when server sets file pointer.\n"); close( fd ); return AGENT_RET_EFAIL; } n_rbytes -= n_wbytes; fptr += n_wbytes; } } close( fd ); return AGENT_RET_SUCCESS; }
void test_core_as_copy_01(void) { i_task task1; i_task task2; i_as as1; i_as as2; i_segment seg1; i_segment seg2; i_segment seg3; i_segment seg4; i_segment seg5; i_segment seg6; i_segment useless; i_region reg; t_uint32 i; t_uint8 buff[4 * ___kaneton$pagesz]; TEST_ENTER(); /* * first address space */ if (task_reserve(TASK_CLASS_GUEST, TASK_BEHAVIOUR_INTERACTIVE, TASK_PRIORITY_INTERACTIVE, &task1) != STATUS_OK) TEST_ERROR("[task_reserve] error"); if (as_reserve(task1, &as1) != STATUS_OK) TEST_ERROR("[as_reserve] error"); if (segment_reserve(as1, 2 * ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &seg1) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as1, ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &useless) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as1, 4 * ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &seg2) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as1, ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &useless) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as1, 2 * ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &seg3) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (region_reserve(as1, seg1, ___kaneton$pagesz, REGION_OPTION_FORCE, 0x20000000, ___kaneton$pagesz, ®) != STATUS_OK) TEST_ERROR("[region_reserve] error"); if (region_reserve(as1, seg2, ___kaneton$pagesz, REGION_OPTION_FORCE, 0x20001000, 2 * ___kaneton$pagesz, ®) != STATUS_OK) TEST_ERROR("[region_reserve] error"); if (region_reserve(as1, seg3, 0, REGION_OPTION_FORCE, 0x20003000, ___kaneton$pagesz, ®) != STATUS_OK) TEST_ERROR("[region_reserve] error"); /* * second address space */ if (task_reserve(TASK_CLASS_GUEST, TASK_BEHAVIOUR_INTERACTIVE, TASK_PRIORITY_INTERACTIVE, &task2) != STATUS_OK) TEST_ERROR("[task_reserve] error"); if (as_reserve(task2, &as2) != STATUS_OK) TEST_ERROR("[as_reserve] error"); if (segment_reserve(as2, 2 * ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &seg4) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as2, ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &useless) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as2, 4 * ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &seg5) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as2, ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &useless) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (segment_reserve(as2, 2 * ___kaneton$pagesz, PERMISSION_READ | PERMISSION_WRITE, SEGMENT_OPTION_NONE, &seg6) != STATUS_OK) TEST_ERROR("[segment_reserve] error"); if (region_reserve(as2, seg4, 0, REGION_OPTION_FORCE, 0x40000000, ___kaneton$pagesz, ®) != STATUS_OK) TEST_ERROR("[region_reserve] error"); if (region_reserve(as2, seg5, 2 * ___kaneton$pagesz, REGION_OPTION_FORCE, 0x40001000, ___kaneton$pagesz, ®) != STATUS_OK) TEST_ERROR("[region_reserve] error"); if (region_reserve(as2, seg6, 0, REGION_OPTION_FORCE, 0x40002000, 2 * ___kaneton$pagesz, ®) != STATUS_OK) TEST_ERROR("[region_reserve] error"); /* * operations */ for (i = 0; i < 4 * ___kaneton$pagesz; i++) buff[i] = (i * 2 + 4) % 256; if (as_write(as1, buff, 4 * ___kaneton$pagesz, 0x20000000) != STATUS_OK) TEST_ERROR("[as_write] error"); for (i = 0; i < 4 * ___kaneton$pagesz; i++) buff[i] = 0; if (as_copy(as1, 0x20000000, as2, 0x40000000, 4 * ___kaneton$pagesz) != STATUS_OK) TEST_ERROR("[as_copy] error"); if (as_read(as2, 0x40000000, 4 * ___kaneton$pagesz, buff) != STATUS_OK) TEST_ERROR("[as_read] error"); for (i = 0; i < 4 * ___kaneton$pagesz; i++) if (buff[i] != (i * 2 + 4) % 256) TEST_ERROR("the data appears invalid once read from the " "address space\n"); TEST_SIGNATURE(rr3fiw3w20aafi9gre9g); TEST_LEAVE(); }