void bob::io::base::detail::TensorFileHeader::read(std::istream& str) {
// Start reading at the beginning of the stream
str.seekg(std::ios_base::beg);
int val;
str.read( reinterpret_cast<char*>(&val), sizeof(int));
m_tensor_type = (bob::io::base::TensorType)val;
m_type.dtype = bob::io::base::tensorTypeToArrayType(m_tensor_type);
str.read( reinterpret_cast<char*>(&val), sizeof(int));
m_n_samples = (size_t)val;
int nd;
str.read(reinterpret_cast<char*>(&nd), sizeof(int));
int shape[BOB_MAX_DIM];
str.read( reinterpret_cast<char*>(&val), sizeof(int));
shape[0] = (size_t)val;
str.read( reinterpret_cast<char*>(&val), sizeof(int));
shape[1] = (size_t)val;
str.read( reinterpret_cast<char*>(&val), sizeof(int));
shape[2] = (size_t)val;
str.read( reinterpret_cast<char*>(&val), sizeof(int));
shape[3] = (size_t)val;
m_type.set_shape(nd, shape);
header_ok();
}
arg_t _execve(void)
{
/* We aren't re-entrant where this matters */
uint8_t hdr[16];
staticfast inoptr ino;
char **nargv; /* In user space */
char **nenvp; /* In user space */
struct s_argblk *abuf, *ebuf;
int argc;
uint16_t progptr;
uint16_t progload;
staticfast uint16_t top;
uint16_t bin_size; /* Will need to be bigger on some cpus */
uint16_t bss;
top = ramtop;
if (!(ino = n_open_lock(name, NULLINOPTR)))
return (-1);
if (!((getperm(ino) & OTH_EX) &&
(ino->c_node.i_mode & F_REG) &&
(ino->c_node.i_mode & (OWN_EX | OTH_EX | GRP_EX)))) {
udata.u_error = EACCES;
goto nogood;
}
setftime(ino, A_TIME);
udata.u_offset = 0;
udata.u_count = 16;
udata.u_base = hdr;
udata.u_sysio = true;
readi(ino, 0);
if (udata.u_done != 16) {
udata.u_error = ENOEXEC;
goto nogood;
}
if (!header_ok(hdr)) {
udata.u_error = ENOEXEC;
goto nogood2;
}
progload = hdr[7] << 8;
if (progload == 0)
progload = PROGLOAD;
top = *(uint16_t *)(hdr + 8);
if (top == 0) /* Legacy 'all space' binary */
top = ramtop;
else /* Requested an amount, so adjust for the base */
top += progload;
bss = *(uint16_t *)(hdr + 14);
/* Binary doesn't fit */
/* FIXME: review overflows */
bin_size = ino->c_node.i_size;
progptr = bin_size + 1024 + bss;
if (progload < PROGLOAD || top - progload < progptr || progptr < bin_size) {
udata.u_error = ENOMEM;
goto nogood2;
}
udata.u_ptab->p_status = P_NOSLEEP;
/* If we made pagemap_realloc keep hold of some defined area we
could in theory just move the arguments up or down as part of
the process - that would save us all this hassle but replace it
with new hassle */
/* Gather the arguments, and put them in temporary buffers. */
abuf = (struct s_argblk *) tmpbuf();
/* Put environment in another buffer. */
ebuf = (struct s_argblk *) tmpbuf();
/* Read args and environment from process memory */
if (rargs(argv, abuf) || rargs(envp, ebuf))
goto nogood3; /* SN */
/* This must be the last test as it makes changes if it works */
/* FIXME: once we sort out chmem we can make stack and data
two elements. We never allocate 'code' as there is no split I/D */
/* This is only safe from deadlocks providing pagemap_realloc doesn't
sleep */
if (pagemap_realloc(0, top - MAPBASE, 0))
goto nogood3;
/* From this point on we are commmited to the exec() completing */
/* Core dump and ptrace permission logic */
#ifdef CONFIG_LEVEL_2
/* Q: should uid == 0 mean we always allow core */
if ((!(getperm(ino) & OTH_RD)) ||
(ino->c_node.i_mode & (SET_UID | SET_GID)))
udata.u_flags |= U_FLAG_NOCORE;
else
udata.u_flags &= ~U_FLAG_NOCORE;
#endif
udata.u_top = top;
udata.u_ptab->p_top = top;
/* setuid, setgid if executable requires it */
if (ino->c_node.i_mode & SET_UID)
udata.u_euid = ino->c_node.i_uid;
if (ino->c_node.i_mode & SET_GID)
udata.u_egid = ino->c_node.i_gid;
/* FIXME: In the execve case we may on some platforms have space
below PROGLOAD to clear... */
/* We are definitely going to succeed with the exec,
* so we can start writing over the old program
*/
uput(hdr, (uint8_t *)progload, 16);
/* At this point, we are committed to reading in and
* executing the program. This call must not block. */
close_on_exec();
/*
* Read in the rest of the program, block by block. We rely upon
* the optimization path in readi to spot this is a big move to user
* space and move it directly.
*/
progptr = progload + 16;
if (bin_size > 16) {
bin_size -= 16;
udata.u_base = (uint8_t *)progptr; /* We copied the first block already */
udata.u_count = bin_size;
udata.u_sysio = false;
readi(ino, 0);
if (udata.u_done != bin_size)
goto nogood4;
progptr += bin_size;
}
/* Wipe the memory in the BSS. We don't wipe the memory above
that on 8bit boxes, but defer it to brk/sbrk() */
uzero((uint8_t *)progptr, bss);
/* Set initial break for program */
udata.u_break = (int)ALIGNUP(progptr + bss);
/* Turn off caught signals */
memset(udata.u_sigvec, 0, sizeof(udata.u_sigvec));
// place the arguments, environment and stack at the top of userspace memory,
// Write back the arguments and the environment
nargv = wargs(((char *) top - 2), abuf, &argc);
nenvp = wargs((char *) (nargv), ebuf, NULL);
// Fill in udata.u_name with program invocation name
uget((void *) ugetw(nargv), udata.u_name, 8);
memcpy(udata.u_ptab->p_name, udata.u_name, 8);
tmpfree(abuf);
tmpfree(ebuf);
i_deref(ino);
/* Shove argc and the address of argv just below envp
FIXME: should flip them in crt0.S of app for R2L setups
so we can get rid of the ifdefs */
#ifdef CONFIG_CALL_R2L /* Arguments are stacked the 'wrong' way around */
uputw((uint16_t) nargv, nenvp - 2);
uputw((uint16_t) argc, nenvp - 1);
#else
uputw((uint16_t) nargv, nenvp - 1);
uputw((uint16_t) argc, nenvp - 2);
#endif
/* Set stack pointer for the program */
udata.u_isp = nenvp - 2;
/* Start execution (never returns) */
udata.u_ptab->p_status = P_RUNNING;
doexec(progload);
/* tidy up in various failure modes */
nogood4:
/* Must not run userspace */
ssig(udata.u_ptab, SIGKILL);
nogood3:
udata.u_ptab->p_status = P_RUNNING;
tmpfree(abuf);
tmpfree(ebuf);
nogood2:
nogood:
i_unlock_deref(ino);
return (-1);
}
