KernReturn<uint32_t> Syscall_mmap(OS::Thread *thread, MmapArgs *arguments)
{
uintptr_t address = reinterpret_cast<uintptr_t>(arguments->address);
int flags = arguments->flags;
size_t length = arguments->length;
// Basic sanity checks
if((flags & MAP_PRIVATE) && (flags & MAP_SHARED))
return Error(KERN_INVALID_ARGUMENT);
// It's either PROT_NONE or anything else
if(flags & PROT_NONE && flags != PROT_NONE)
return Error(KERN_INVALID_ARGUMENT);
OS::Task *task = thread->GetTask();
if(flags & MAP_ANONYMOUS)
{
if((address && (address % VM_PAGE_SIZE) != 0) || (length % VM_PAGE_SIZE) != 0 || length == 0)
return Error(KERN_INVALID_ARGUMENT);
KernReturn<MmapTaskEntry *> result = mmapAnonymous(task, arguments);
if(!result.IsValid())
return result.GetError();
MmapTaskEntry *entry = result.Get();
task->Lock();
task->mmapList.push_front(entry->taskEntry);
task->Unlock();
return entry->vmaddress;
}
else
{
if((address && (address % VM_PAGE_SIZE) != 0) || (arguments->offset && (arguments->offset % VM_PAGE_SIZE) != 0) || length == 0)
return Error(KERN_INVALID_ARGUMENT);
KernReturn<MmapTaskEntry *> result = mmapFile(task, arguments);
if(!result.IsValid())
return result.GetError();
MmapTaskEntry *entry = result.Get();
task->Lock();
task->mmapList.push_front(entry->taskEntry);
task->Unlock();
return entry->vmaddress;
}
}
void WebController::HandleUploadRequest(struct mg_connection *conn){
FILE *fp = (FILE *) conn->connection_param;
if (fp != NULL) {
mg_printf(conn, "HTTP/1.1 200 OK\r\n"
"Content-Type: text/plain\r\n"
"Connection: close\r\n");
// Temp file will be destroyed after fclose(), do something with the
// data here -- for example, parse it and extract uploaded files.
// As an example, we just echo the whole POST buffer back to the client.
rewind(fp);
MappedFile mmFile;
if(mmapFile(mmFile, fp)){
debug("Failed to read setup file");
return;
}
size_t filesize=0;
const char *data;
int data_len, ofs = 0;
char var_name[100], file_name[100];
while ((ofs = mg_parse_multipart(mmFile.addr + ofs, mmFile.mapsize - ofs,
var_name, sizeof(var_name),
file_name, sizeof(file_name),
&data, &data_len)) > 0) {
FILE * pFile;
//Add one to skip first slash and make path relative
if(file_name[0] == '/'){
pFile = fopen (file_name+1, "w+");
} else {
pFile = fopen (file_name, "w+");
}
//ConsoleHandler("Writing to file");
//ConsoleHandler(file_name);
if(pFile){
size_t written = fwrite (data , sizeof(char), data_len, pFile);
if(written != data_len){
this->DoErrorMessage("Error writing to file");
//ErrMsgHandler(strerror(errno));
} else{
filesize += written;
}
if(fclose (pFile) == EOF){
this->DoErrorMessage("Error closing file");
}
} else {
this->DoErrorMessage("Error saving file");
this->DoErrorMessage(strerror(errno));
}
}
if(filesize == 0 /*filesize != tmpfilesize*/){
char msg[256];
snprintf(msg,256, "Bytes written %ld of %ld",filesize, mmFile.filesize);
this->DoErrorMessage(msg);
}
//need to send response back to client to avoid wating connection
mg_printf_data(conn,
"Written %ld bytes to file: %s\n\n",
filesize,
file_name);
} else {
mg_printf_data(conn, "%s", "Had no data to write...");
}
//MG_CLOSE event is not raised by mongoose as expected. Need to close file
OnEventClose(conn);
}
int mmapNamedFile(MappedFile& mmFile, const char * fileName){
FILE *fp = (FILE *) fopen (fileName, "r+");
int result = mmapFile(mmFile, fp);
fclose(fp);
return result;
}
/** Imagic Writer
* @ingroup Imagic
*/
int ImageBase::writeIMAGIC(size_t select_img, int mode, const String &bitDepth, CastWriteMode castMode)
{
#undef DEBUG
//#define DEBUG
#ifdef DEBUG
printf("DEBUG writeIMAGIC: Reading Imagic file\n");
#endif
IMAGIChead header;
// Cast T to datatype without convert data
DataType wDType, myTypeID = myT();
if (bitDepth == "")
{
switch(myTypeID)
{
case DT_Double:
case DT_Float:
case DT_Int:
case DT_UInt:
wDType = DT_Float;
strncpy(header.type,"REAL", sizeof(header.type));
break;
case DT_UShort:
castMode = CW_CONVERT;
/* no break */
case DT_Short:
wDType = DT_Short;
strncpy(header.type,"INTG", sizeof(header.type));
break;
case DT_SChar:
castMode = CW_CONVERT;
/* no break */
case DT_UChar:
wDType = DT_UChar;
strncpy(header.type,"PACK", sizeof(header.type));
break;
case DT_CFloat:
case DT_CDouble:
wDType = DT_CFloat;
strncpy(header.type,"COMP", sizeof(header.type));
break;
default:
wDType = DT_Unknown;
REPORT_ERROR(ERR_TYPE_INCORRECT, "ERROR: Unsupported data type by IMAGIC format.");
}
}
else //Convert to other data type
{
// Default Value
wDType = (bitDepth == "default") ? DT_Float : datatypeRAW(bitDepth);
switch (wDType)
{
case DT_UChar:
strncpy(header.type,"PACK", sizeof(header.type));
break;
case DT_Short:
strncpy(header.type,"INTG", sizeof(header.type));
break;
case DT_Float:
(strncpy)(header.type,"REAL", sizeof(header.type));
break;
case DT_CFloat:
strncpy(header.type,"COMP", sizeof(header.type));
break;
default:
REPORT_ERROR(ERR_TYPE_INCORRECT,"ERROR: incorrect IMAGIC bits depth value.");
}
}
if (mmapOnWrite)
{
MDMainHeader.setValue(MDL_DATATYPE,(int) wDType);
if (!checkMmapT(wDType))
{
if (dataMode < DATA && castMode == CW_CAST) // This means ImageGeneric wants to know which DataType must use in mapFile2Write
return 0;
else //Mapping is an extra. When not available, go on and do not report an error.
{
/* In this case we cannot map the file because required and feasible datatypes are
* not compatible. Then we denote to MapFile2Write the same incoming datatype to
* keep using this Image object as usual, without mapping on write.
*/
mmapOnWrite = false;
dataMode = DATA;
MDMainHeader.setValue(MDL_DATATYPE,(int) myTypeID);
// In case Image size great then, at least, map the multidimarray
if (mdaBase->nzyxdim*gettypesize(myTypeID) > tiff_map_min_size)
mdaBase->setMmap(true);
// Allocate memory for image data (Assume xdim, ydim, zdim and ndim are already set
//if memory already allocated use it (no resize allowed)
mdaBase->coreAllocateReuse();
return 0;
}
}
else
dataMode = DATA;
}
size_t Xdim, Ydim, Zdim, Ndim;
getDimensions(Xdim, Ydim, Zdim, Ndim);
if (Zdim > 1)
REPORT_ERROR(ERR_MULTIDIM_DIM, "writeIMAGIC: Imagic format does not support volumes.");
size_t datasize, datasize_n;
datasize_n = (size_t)Xdim*Ydim*Zdim;
datasize = datasize_n * gettypesize(wDType);
// fill in the file header
header.nhfr = 1;
header.npix2 = Xdim*Ydim;
header.npixel = header.npix2;
header.iylp = Xdim;
header.ixlp = Ydim;
time_t timer;
time ( &timer );
tm* t = localtime(&timer);
header.ndate = t->tm_mday;
header.nmonth = t->tm_mon + 1;
header.nyear = t->tm_year;
header.nhour = t->tm_hour;
header.nminut = t->tm_min;
header.nsec = t->tm_sec;
double aux;
if (!MDMainHeader.empty())
{
#define SET_MAIN_HEADER_VALUE(field, label) MDMainHeader.getValueOrDefault(label, aux, 0.); header.field = (float)aux
SET_MAIN_HEADER_VALUE(densmin, MDL_MIN);
SET_MAIN_HEADER_VALUE(densmax, MDL_MAX);
SET_MAIN_HEADER_VALUE(avdens, MDL_AVG);
SET_MAIN_HEADER_VALUE(sigma, MDL_STDDEV);
header.varian = header.sigma*header.sigma;
}
memcpy(header.lastpr, "Xmipp", 5);
memcpy(header.name, filename.c_str(), 80);
size_t imgStart = IMG_INDEX(select_img);
header.ifn = replaceNsize - 1 ;
header.imn = 1;
if ( mode == WRITE_APPEND )
{
imgStart = replaceNsize;
header.ifn = replaceNsize + Ndim - 1 ;
}
else if( mode == WRITE_REPLACE && imgStart + Ndim > replaceNsize)
header.ifn = imgStart + Ndim - 1;
else if (Ndim > replaceNsize)
header.ifn = Ndim - 1;
/*
* BLOCK HEADER IF NEEDED
*/
FileLock flockHead, flockImg;
flockHead.lock(fhed);
flockImg.lock(fimg);
if (replaceNsize == 0) // Header written first time
{
if ( swapWrite )
{
IMAGIChead headTemp = header;
swapPage((char *) &headTemp, IMAGICSIZE - 916, DT_Float);
fwrite( &headTemp, IMAGICSIZE, 1, fhed );
}
fwrite( &header, IMAGICSIZE, 1, fhed );
}
else if( header.ifn + 1 > (int)replaceNsize && imgStart > 0 ) // Update number of images when needed
{
fseek( fhed, sizeof(int), SEEK_SET);
if ( swapWrite )
{
int ifnswp = header.ifn;
swapPage((char *) &ifnswp, SIZEOF_INT, DT_Int);
fwrite(&(ifnswp),SIZEOF_INT,1,fhed);
}
else
fwrite(&(header.ifn),SIZEOF_INT,1,fhed);
}
// Jump to the selected imgStart position
fseek(fimg, datasize * imgStart, SEEK_SET);
fseek(fhed, IMAGICSIZE * imgStart, SEEK_SET);
std::vector<MDRow>::iterator it = MD.begin();
for (size_t i = 0; i < Ndim; ++i, ++it)
{
header.iyold=header.ixold=0;
header.euler_alpha=header.euler_beta=header.euler_gamma=0.;
// Write the individual image header
if (it != MD.end() && (dataMode == _HEADER_ALL || dataMode == _DATA_ALL))
{
#define SET_HEADER_VALUEInt(field, label) it->getValueOrDefault((label), (aux), 0); header.field = -(int)(aux)
#define SET_HEADER_VALUEDouble(field, label) it->getValueOrDefault((label), (aux), 0.); header.field = -(float)(aux)
SET_HEADER_VALUEInt(ixold, MDL_SHIFT_X);
SET_HEADER_VALUEInt(iyold, MDL_SHIFT_Y);
SET_HEADER_VALUEDouble(euler_alpha, MDL_ANGLE_ROT);
SET_HEADER_VALUEDouble(euler_beta, MDL_ANGLE_TILT);
SET_HEADER_VALUEDouble(euler_gamma, MDL_ANGLE_PSI);
}
// Update index number of image
header.imn = imgStart + i + 1;
if ( swapWrite )
swapPage((char *) &header, IMAGICSIZE - 916, DT_Float);
fwrite( &header, IMAGICSIZE, 1, fhed );
if (dataMode >= DATA)
{
if (mmapOnWrite && Ndim == 1) // Can map one image at a time only
{
mappedOffset = ftell(fimg);
mappedSize = mappedOffset + datasize;
fseek(fimg, datasize-1, SEEK_CUR);
fputc(0, fimg);
}
else
writeData(fimg, i*datasize_n, wDType, datasize_n, castMode);
}
else
fseek(fimg, datasize, SEEK_CUR);
}
//Unlock
flockHead.unlock();
flockImg.unlock();
if (mmapOnWrite)
mmapFile();
return(0);
}
