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