int cafiine_fstat(int sock, int *result, int fd, void *ptr) { while (bss.lock) GX2WaitForVsync(); bss.lock = 1; CHECK_ERROR(sock == -1); int ret; char buffer[1 + 4]; buffer[0] = BYTE_STATFILE; *(int *)(buffer + 1) = fd; ret = sendwait(sock, buffer, 1 + 4); CHECK_ERROR(ret < 0); ret = recvbyte(sock); CHECK_ERROR(ret < 0); CHECK_ERROR(ret == BYTE_NORMAL); ret = recvwait(sock, result, 4); CHECK_ERROR(ret < 0); int sz; ret = recvwait(sock, &sz, 4); CHECK_ERROR(ret < 0); if (ptr) { ret = recvwait(sock, ptr, sz); CHECK_ERROR(ret < 0); } bss.lock = 0; return 0; error: bss.lock = 0; return -1; }
int bound_mpi_int(int boundstage, int boundvartype, PFTYPE (*prim)[NSTORE2][NSTORE3][NUMPFLAGS]) { int dir; #if(USEMPI) /* These arrays contain designations that identify * each recv and send */ static MPI_Request requests[COMPDIM * 2 * 2]; // format of map for requests[dir*2+recv/send(0/1)] #endif #if(USEMPI) /////////////// // dir=1 if((boundstage==STAGE0)||(boundstage==STAGEM1)){ for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) pack_int(dir,boundvartype,prim,workbc_int); for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendrecv_int(dir,boundvartype,workbc_int,requests); } if((boundstage==STAGE1)||(boundstage==STAGEM1)){ for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) recvwait(dir,requests); for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim); for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests); } /////////////// // dir=2 if((boundstage==STAGE2)||(boundstage==STAGEM1)){ for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) pack_int(dir,boundvartype,prim,workbc_int); for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendrecv_int(dir,boundvartype,workbc_int,requests); } if((boundstage==STAGE3)||(boundstage==STAGEM1)){ for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) recvwait(dir,requests); for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim); for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests); } /////////////// // dir=3 if((boundstage==STAGE4)||(boundstage==STAGEM1)){ for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) pack_int(dir,boundvartype,prim,workbc_int); for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendrecv_int(dir,boundvartype,workbc_int,requests); } if((boundstage==STAGE5)||(boundstage==STAGEM1)){ for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) recvwait(dir,requests); for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim); for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests); } // now corner zones will be filled correctly // GODMARK: If made fixup_utoprim() and check_solution() not use corner zones could bound all directions at once -- probably not important performance hit // end if mpi #endif return(0); }
int cafiine_fgetpos(int sock, int *result, int fd, int *pos) { while (bss.lock) GX2WaitForVsync(); bss.lock = 1; CHECK_ERROR(sock == -1); int ret; char buffer[1 + 4]; buffer[0] = BYTE_GETPOS; *(int *)(buffer + 1) = fd; ret = sendwait(sock, buffer, 1 + 4); CHECK_ERROR(ret < 0); ret = recvbyte(sock); CHECK_ERROR(ret < 0); CHECK_ERROR(ret == BYTE_NORMAL); ret = recvwait(sock, result, 4); CHECK_ERROR(ret < 0); ret = recvwait(sock, pos, 4); CHECK_ERROR(ret < 0); bss.lock = 0; return 0; error: bss.lock = 0; return -1; }
int cafiine_fread(int sock, int *result, void *ptr, int size, int count, int fd) { while (bss.lock) GX2WaitForVsync(); bss.lock = 1; CHECK_ERROR(sock == -1); int ret; char buffer[1 + 12]; buffer[0] = BYTE_READ; *(int *)(buffer + 1) = size; *(int *)(buffer + 5) = count; *(int *)(buffer + 9) = fd; ret = sendwait(sock, buffer, 1 + 12); CHECK_ERROR(ret < 0); ret = recvbyte(sock); CHECK_ERROR(ret < 0); CHECK_ERROR(ret == BYTE_NORMAL); ret = recvwait(sock, result, 4); CHECK_ERROR(ret < 0); int sz; ret = recvwait(sock, &sz, 4); CHECK_ERROR(ret < 0); ret = recvwait(sock, ptr, sz); CHECK_ERROR(ret < 0); ret = sendbyte(sock, BYTE_OK); CHECK_ERROR(ret < 0); bss.lock = 0; return 0; error: bss.lock = 0; return -1; }
int bound_mpi_int(int boundstage, int prim[][N2M][N3M][NUMPFLAGS]) { int dir; #if(USEMPI) /* These arrays contain designations that identify * each recv and send */ static MPI_Request requests[COMPDIM * 2 * 2]; // format of map for requests[dir*2+recv/send(0/1)] #endif #if(USEMPI) if((boundstage==STAGE0)||(boundstage==STAGEM1)){ for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) pack_int(dir,prim,workbc_int); for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendrecv_int(dir,workbc_int,requests); } if((boundstage==STAGE1)||(boundstage==STAGEM1)){ for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) recvwait(dir,requests); for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) unpack_int(dir,workbc_int,prim); for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendwait(dir,requests); } if((boundstage==STAGE2)||(boundstage==STAGEM1)){ for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) pack_int(dir,prim,workbc_int); for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendrecv_int(dir,workbc_int,requests); } if((boundstage==STAGE3)||(boundstage==STAGEM1)){ for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) recvwait(dir,requests); for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) unpack_int(dir,workbc_int,prim); for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendwait(dir,requests); } if((boundstage==STAGE4)||(boundstage==STAGEM1)){ for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) pack_int(dir,prim,workbc_int); for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendrecv_int(dir,workbc_int,requests); } if((boundstage==STAGE5)||(boundstage==STAGEM1)){ for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) recvwait(dir,requests); for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) unpack_int(dir,workbc_int,prim); for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendwait(dir,requests); } // end if mpi #endif return(0); }
static int recvbyte(int sock) { unsigned char buffer[1]; int ret; ret = recvwait(sock, buffer, 1); if (ret < 0) return ret; return buffer[0]; }
static Result networkinstall_get_src_size(void* data, u32 handle, u64* size) { network_install_data* networkInstallData = (network_install_data*) data; u64 netSize = 0; if(recvwait(networkInstallData->clientSocket, &netSize, sizeof(netSize), 0) < 0) { return R_FBI_ERRNO; } *size = __builtin_bswap64(netSize); return 0; }
static Result networkinstall_read_src(void* data, u32 handle, u32* bytesRead, void* buffer, u64 offset, u32 size) { network_install_data* networkInstallData = (network_install_data*) data; int ret = 0; if((ret = recvwait(networkInstallData->clientSocket, buffer, size, 0)) < 0) { return R_FBI_ERRNO; } *bytesRead = (u32) ret; return 0; }
int cafiine_fopen(int sock, int *result, const char *path, const char *mode, int *handle) { while (bss.lock) GX2WaitForVsync(); bss.lock = 1; CHECK_ERROR(sock == -1); int ret; int len_path = 0; while (path[len_path++]); int len_mode = 0; while (mode[len_mode++]); { char buffer[1 + 8 + len_path + len_mode]; buffer[0] = BYTE_OPEN; *(int *)(buffer + 1) = len_path; *(int *)(buffer + 5) = len_mode; for (ret = 0; ret < len_path; ret++) buffer[9 + ret] = path[ret]; for (ret = 0; ret < len_mode; ret++) buffer[9 + len_path + ret] = mode[ret]; ret = sendwait(sock, buffer, 1 + 8 + len_path + len_mode); } CHECK_ERROR(ret < 0); ret = recvbyte(sock); CHECK_ERROR(ret < 0); CHECK_ERROR(ret == BYTE_NORMAL); ret = recvwait(sock, result, 4); CHECK_ERROR(ret < 0); ret = recvwait(sock, handle, 4); CHECK_ERROR(ret < 0); bss.lock = 0; return 0; error: bss.lock = 0; return -1; }
int bound_mpi_int_dir(int boundstage, int finalstep, int whichdir, int boundvartype, PFTYPE (*prim)[NSTORE2][NSTORE3][NUMPFLAGS]) { int dir; static MPI_Request requests[COMPDIM * 2 * 2]; static int didpostrecvs[COMPDIM*2]={0}; int dirstart,dirfinish; if(whichdir==-1 || whichdir==1){ dirstart=X1UP; dirfinish=X1DN;} if(whichdir==-2 || whichdir==2){ dirstart=X2UP; dirfinish=X2DN;} if(whichdir==-3 || whichdir==3){ dirstart=X3UP; dirfinish=X3DN;} //////////// // // pre-post recv's // // OPTMARK: Could avoid dir-dependent MPI calls in step_ch.c (currently true!) and post all recv's for all dirs at once. // OPTMARK: Or setup MPIFLOWCONTROL==2 or SUPERMPI // //////////// if(whichdir==-1 || whichdir==-2 || whichdir==-3){ if((boundstage==STAGEM1)||(boundstage==STAGE0)){ for(dir=dirstart;dir<=dirfinish;dir++){ if(dirgenset[boundvartype][dir][DIRIF]){ recvonly_int(dir,boundvartype,workbc_int,requests); didpostrecvs[dir]=1; } } } } else if(whichdir==1 || whichdir==2 || whichdir==3){ ////////////////// // // per-whichdir (1,2,3) conditionals for bounding. Assume whichdir=1 done first, then 2, then 3, so that corners are done correctly as done with normal bounds. // ////////////////// /////////////////// // // x or y or z -dir // once dir=0,1(X1UP,X1DN) is done, so can start 2,3(X2UP,X2DN) // ///////////////// if((boundstage==STAGEM1)||(boundstage==STAGE0&&whichdir==1 || boundstage==STAGE2&&whichdir==2 || boundstage==STAGE4&&whichdir==3)){ for(dir=dirstart;dir<=dirfinish;dir++){ if(dirgenset[boundvartype][dir][DIRIF]){ if(didpostrecvs[dir]==0){ dualfprintf(fail_file,"Did not post recv and tried to already pack: dir=%d\n",dir); myexit(234525155); } pack_int(dir,boundvartype,prim,workbc_int); } } for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendonly_int(dir,boundvartype,workbc_int,requests); } if((boundstage==STAGEM1)||(boundstage==STAGE1&&whichdir==1 || boundstage==STAGE3&&whichdir==2 || boundstage==STAGE5&&whichdir==3)){ for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]){ recvwait(dir,requests); didpostrecvs[dir]=0; // done with recv's } for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim); for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests); } } else{ dualfprintf(fail_file,"No such whichdir=%d in boundmpiint.c\n",whichdir); myexit(1986290387); } // now corner zones will be filled correctly // GODMARK: If made fixup_utoprim() and check_solution() not use corner zones could bound all directions at once -- probably not important performance hit return(0); }
int TcpReceiver::loadToMemory(s32 clientSocket, u32 ipAddress) { log_printf("Loading file from ip %08X\n", ipAddress); u32 fileSize = 0; u32 fileSizeUnc = 0; unsigned char haxx[8]; memset(haxx, 0, sizeof(haxx)); //skip haxx recvwait(clientSocket, haxx, sizeof(haxx)); recvwait(clientSocket, (unsigned char*)&fileSize, sizeof(fileSize)); if (haxx[4] > 0 || haxx[5] > 4) { recvwait(clientSocket, (unsigned char*)&fileSizeUnc, sizeof(fileSizeUnc)); // Compressed protocol, read another 4 bytes } u32 bytesRead = 0; struct in_addr in; in.s_addr = ipAddress; progressWindow.setTitle(StringTools::strfmt("Loading file from %s", inet_ntoa(in))); log_printf("transfer start\n"); unsigned char* loadAddress = (unsigned char*)memalign(0x40, fileSize); if(!loadAddress) { progressWindow.setTitle("Not enough memory"); os_sleep(1); return NOT_ENOUGH_MEMORY; } // Copy rpl in memory while(bytesRead < fileSize) { progressWindow.setProgress(100.0f * (f32)bytesRead / (f32)fileSize); u32 blockSize = 0x1000; if(blockSize > (fileSize - bytesRead)) blockSize = fileSize - bytesRead; int ret = recv(clientSocket, loadAddress + bytesRead, blockSize, 0); if(ret <= 0) { log_printf("Failure on reading file\n"); break; } bytesRead += ret; } progressWindow.setProgress((f32)bytesRead / (f32)fileSize); if(bytesRead != fileSize) { free(loadAddress); log_printf("File loading not finished, %i of %i bytes received\n", bytesRead, fileSize); progressWindow.setTitle("Receive incomplete"); os_sleep(1); return FILE_READ_ERROR; } int res = -1; // Do we need to unzip this thing? if (haxx[4] > 0 || haxx[5] > 4) { unsigned char* inflatedData = NULL; // We need to unzip... if (loadAddress[0] == 'P' && loadAddress[1] == 'K' && loadAddress[2] == 0x03 && loadAddress[3] == 0x04) { //! TODO: //! mhmm this is incorrect, it has to parse the zip // Section is compressed, inflate inflatedData = (unsigned char*)malloc(fileSizeUnc); if(!inflatedData) { free(loadAddress); progressWindow.setTitle("Not enough memory"); os_sleep(1); return NOT_ENOUGH_MEMORY; } int ret = 0; z_stream s; memset(&s, 0, sizeof(s)); s.zalloc = Z_NULL; s.zfree = Z_NULL; s.opaque = Z_NULL; ret = inflateInit(&s); if (ret != Z_OK) { free(loadAddress); free(inflatedData); progressWindow.setTitle("Uncompress failure"); os_sleep(1); return FILE_READ_ERROR; } s.avail_in = fileSize; s.next_in = (Bytef *)(&loadAddress[0]); s.avail_out = fileSizeUnc; s.next_out = (Bytef *)&inflatedData[0]; ret = inflate(&s, Z_FINISH); if (ret != Z_OK && ret != Z_STREAM_END) { free(loadAddress); free(inflatedData); progressWindow.setTitle("Uncompress failure"); os_sleep(1); return FILE_READ_ERROR; } inflateEnd(&s); fileSize = fileSizeUnc; } else { // Section is compressed, inflate inflatedData = (unsigned char*)malloc(fileSizeUnc); if(!inflatedData) { free(loadAddress); progressWindow.setTitle("Not enough memory"); os_sleep(1); return NOT_ENOUGH_MEMORY; } uLongf f = fileSizeUnc; int result = uncompress((Bytef*)&inflatedData[0], &f, (Bytef*)loadAddress, fileSize); if(result != Z_OK) { log_printf("uncompress failed %i\n", result); progressWindow.setTitle("Uncompress failure"); os_sleep(1); return FILE_READ_ERROR; } fileSizeUnc = f; fileSize = fileSizeUnc; } free(loadAddress); HomebrewInitMemory(); res = HomebrewCopyMemory(inflatedData, fileSize); free(inflatedData); } else { HomebrewInitMemory(); res = HomebrewCopyMemory(loadAddress, fileSize); free(loadAddress); } if(res < 0) { progressWindow.setTitle("Not enough memory"); os_sleep(1); return NOT_ENOUGH_MEMORY; } return fileSize; }