asmlinkage ssize_t sys_pread_wrapper(unsigned int fd, char * buf,
size_t count, long dummy, loff_t pos)
{
extern asmlinkage ssize_t sys_pread(unsigned int fd, char * buf,
size_t count, loff_t pos);
return sys_pread(fd, buf, count, pos);
}
int
svr4_sys_pread64(struct lwp *l, const struct svr4_sys_pread64_args *uap, register_t *retval)
{
struct sys_pread_args pra;
/*
* Just translate the args structure and call the NetBSD
* pread(2) system call (offset type is 64-bit in NetBSD).
*/
SCARG(&pra, fd) = SCARG(uap, fd);
SCARG(&pra, buf) = SCARG(uap, buf);
SCARG(&pra, nbyte) = SCARG(uap, nbyte);
SCARG(&pra, offset) = SCARG(uap, off);
return (sys_pread(l, &pra, retval));
}
static struct tevent_req *aio_posix_pread_send(
struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct files_struct *fsp, void *data, size_t n, off_t offset)
{
struct tevent_req *req;
struct aio_posix_state *state;
struct aiocb *a;
int ret;
req = tevent_req_create(mem_ctx, &state, struct aio_posix_state);
if (req == NULL) {
return NULL;
}
a = &state->acb;
a->aio_fildes = fsp->fh->fd;
a->aio_buf = data;
a->aio_nbytes = n;
a->aio_offset = offset;
a->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
a->aio_sigevent.sigev_signo = RT_SIGNAL_AIO;
a->aio_sigevent.sigev_value.sival_ptr = req;
ret = aio_read(a);
if (ret == 0) {
talloc_set_destructor(state, aio_posix_state_destructor);
return req;
}
if (errno == EAGAIN) {
/*
* aio overloaded, do the sync fallback
*/
state->ret = sys_pread(fsp->fh->fd, data, n, offset);
if (state->ret == -1) {
state->err = errno;
}
tevent_req_done(req);
return tevent_req_post(req, ev);
}
tevent_req_error(req, errno);
return tevent_req_post(req, ev);
}
int handle_frontend_syscall(HTIFState *htifstate, uint64_t payload) {
uint64_t mm[8];
int i;
void * base = htifstate->main_mem_ram_ptr + (uintptr_t)payload;
for (i = 0; i < 8; i++) {
mm[i] = ldq_p((void*)(base + i*8));
}
#ifdef DEBUG_FRONTEND_RISCV
for (i = 0; i < 8; i++) {
fprintf(stderr, "elem %d, val 0x%016lx\n", i, mm[i]);
}
#endif
uint64_t retval = -1;
switch(mm[0]) {
case RV_FSYSCALL_sys_openat:
retval = sys_openat(htifstate, mm[1], mm[2], mm[3], mm[4], mm[5]);
break;
case RV_FSYSCALL_sys_close:
retval = sys_close(htifstate, mm[1]);
break;
case RV_FSYSCALL_sys_write:
retval = sys_write(htifstate, mm[1], mm[2], mm[3]);
break;
case RV_FSYSCALL_sys_pread:
retval = sys_pread(htifstate, mm[1], mm[2], mm[3], mm[4]);
break;
case RV_FSYSCALL_sys_exit:
retval = sys_exit(htifstate, mm[1]);
break;
case RV_FSYSCALL_sys_getmainvars:
retval = sys_getmainvars(htifstate, mm[1], mm[2]);
break;
default:
fprintf(stderr, "FRONTEND SYSCALL %ld NOT IMPLEMENTED\n", mm[0]);
exit(1);
}
// write retval to mm
stq_p((void*)base, retval);
return 1;
}
ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data,
size_t n, SMB_OFF_T offset)
{
ssize_t result;
#if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
START_PROFILE_BYTES(syscall_pread, n);
result = sys_pread(fd, data, n, offset);
END_PROFILE(syscall_pread);
if (result == -1 && errno == ESPIPE) {
/* Maintain the fiction that pipes can be seeked (sought?) on. */
result = SMB_VFS_READ(fsp, fd, data, n);
fsp->fh->pos = 0;
}
#else /* HAVE_PREAD */
SMB_OFF_T curr;
int lerrno;
curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
if (curr == -1 && errno == ESPIPE) {
/* Maintain the fiction that pipes can be seeked (sought?) on. */
result = SMB_VFS_READ(fsp, fd, data, n);
fsp->fh->pos = 0;
return result;
}
if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
return -1;
}
errno = 0;
result = SMB_VFS_READ(fsp, fd, data, n);
lerrno = errno;
SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
errno = lerrno;
#endif /* HAVE_PREAD */
return result;
}
/*
* pread(2).
*/
int
linux_sys_pread(struct lwp *l, const struct linux_sys_pread_args *uap, register_t *retval)
{
/* {
syscallarg(int) fd;
syscallarg(void *) buf;
syscallarg(size_t) nbyte;
syscallarg(off_t) offset;
} */
struct sys_pread_args pra;
SCARG(&pra, fd) = SCARG(uap, fd);
SCARG(&pra, buf) = SCARG(uap, buf);
SCARG(&pra, nbyte) = SCARG(uap, nbyte);
SCARG(&pra, PAD) = 0;
SCARG(&pra, offset) = SCARG(uap, offset);
return sys_pread(l, &pra, retval);
}
int main() {
char* buf;
size_t buflen = 4096;
char* data = "aaaaaaaaaaaaaaaaaaaa";
int datalen = strlen(data);
int fd;
ssize_t got;
err_t err;
buf = malloc(buflen);
assert(buf);
// open file
fd = open("tmp.data", O_RDWR | O_CREAT, S_IRWXU);
assert(fd>=0);
// copy data to buf
memset(buf, 0, buflen);
memcpy(buf, data, datalen);
// write data
err = sys_pwrite(fd, buf, datalen, 0, &got);
assert(!err);
assert(got == datalen);
// clear buf
memset(buf, 0, buflen);
// read data
err = sys_pread(fd, buf, buflen, 0, &got);
assert(!err);
assert(got == datalen);
// check data
assert(0 == memcmp(data, buf, datalen));
close(fd);
unlink("tmp.data");
printf("OK\n");
return 0;
}
/* Prime the kernel buffer cache with data from the specified file. We use
* per-fsp data to make sure we only ever do this once. If pread is being
* emulated by seek/read/seek, when this will suck quite a lot.
*/
static BOOL prime_cache(
struct vfs_handle_struct * handle,
files_struct * fsp,
int fd,
SMB_OFF_T offset,
size_t count)
{
SMB_OFF_T * last;
ssize_t nread;
last = VFS_ADD_FSP_EXTENSION(handle, fsp, SMB_OFF_T);
if (!last) {
return False;
}
if (*last == -1) {
/* Readahead disabled. */
return False;
}
if ((*last + g_readsz) > (offset + count)) {
/* Skip readahead ... we've already been here. */
return False;
}
DEBUG(module_debug,
("%s: doing readahead of %lld bytes at %lld for %s\n",
MODULE, (long long)g_readsz, (long long)*last,
fsp->fsp_name));
nread = sys_pread(fd, g_readbuf, g_readsz, *last);
if (nread < 0) {
*last = -1;
return False;
}
*last += nread;
return True;
}
static void aio_worker(void *private_data)
{
struct aio_private_data *pd =
(struct aio_private_data *)private_data;
if (pd->write_command) {
pd->ret_size = sys_pwrite(pd->aiocb->aio_fildes,
(const void *)pd->aiocb->aio_buf,
pd->aiocb->aio_nbytes,
pd->aiocb->aio_offset);
if (pd->ret_size == -1 && errno == ESPIPE) {
/* Maintain the fiction that pipes can
be seeked (sought?) on. */
pd->ret_size = sys_write(pd->aiocb->aio_fildes,
(const void *)pd->aiocb->aio_buf,
pd->aiocb->aio_nbytes);
}
} else {
pd->ret_size = sys_pread(pd->aiocb->aio_fildes,
(void *)pd->aiocb->aio_buf,
pd->aiocb->aio_nbytes,
pd->aiocb->aio_offset);
if (pd->ret_size == -1 && errno == ESPIPE) {
/* Maintain the fiction that pipes can
be seeked (sought?) on. */
pd->ret_size = sys_read(pd->aiocb->aio_fildes,
(void *)pd->aiocb->aio_buf,
pd->aiocb->aio_nbytes);
}
}
if (pd->ret_size == -1) {
pd->ret_errno = errno;
} else {
pd->ret_errno = 0;
}
}
