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;
}
