int PipeRead(struct File* file, BYTE* buffer, DWORD count)
{
DWORD size = 0, chars = 0;
int read = 0;
if (!count)
return 0;
if (file->flags & FILE_NONBLOCK)
{
if (PIPE_LOCK(file))
return 0;
// if (PIPE_EMPTY(file))
// {
/* return -EAGAIN? */
// return 0;
// }
}else{
while (PIPE_EMPTY(file) || PIPE_LOCK(file))
{
if (PIPE_EMPTY(file))
return 0;
KePrint("WAIT\n");
// WAIT_ON(&PIPE_WAIT(file), (PIPE_LOCK(file) == 0));
}
}
PIPE_LOCK(file)++;
while (count > 0 && (size = PIPE_SIZE(file)))
{
char* pipeBuf = PIPE_BUF(file) + PIPE_START(file);
chars = PIPE_MAX_RCHUNK(file);
if (chars > count)
chars = count;
if (chars > size)
chars = size;
read += chars;
PIPE_START(file) += chars;
PIPE_START(file) &= (PIPE_BUFFER_SIZE - 1);
PIPE_SIZE(file) -= chars;
count -= chars;
memcpy(buffer, pipeBuf, chars);
buffer+=chars;
}
PIPE_LOCK(file)--;
WakeUp(&PIPE_WAIT(file));
return read;
}
static ssize_t pipe_read(struct file * filp, char * buf,
size_t count, loff_t *ppos)
{
struct inode * inode = filp->f_dentry->d_inode;
ssize_t chars = 0, size = 0, read = 0;
char *pipebuf;
if (ppos != &filp->f_pos)
return -ESPIPE;
if ( !count ) return 0;
if (filp->f_flags & O_NONBLOCK) {
if (PIPE_LOCK(*inode))
return -EAGAIN;
if (PIPE_EMPTY(*inode)) {
if (PIPE_WRITERS(*inode))
return -EAGAIN;
else
return 0;
}
} else while (PIPE_EMPTY(*inode) || PIPE_LOCK(*inode)) {
if (PIPE_EMPTY(*inode)) {
if (!PIPE_WRITERS(*inode) || !count)
return 0;
}
if (signal_pending(current))
return -ERESTARTSYS;
interruptible_sleep_on(&PIPE_WAIT(*inode));
}
PIPE_LOCK(*inode)++;
while (count>0 && (size = PIPE_SIZE(*inode))) {
chars = PIPE_MAX_RCHUNK(*inode);
if (chars > count)
chars = count;
if (chars > size)
chars = size;
read += chars;
pipebuf = PIPE_BASE(*inode)+PIPE_START(*inode);
PIPE_START(*inode) += chars;
PIPE_START(*inode) &= (PIPE_BUF-1);
PIPE_LEN(*inode) -= chars;
count -= chars;
copy_to_user(buf, pipebuf, chars );
buf += chars;
}
PIPE_LOCK(*inode)--;
wake_up_interruptible(&PIPE_WAIT(*inode));
if (read) {
UPDATE_ATIME(inode);
return read;
}
if (PIPE_WRITERS(*inode))
return -EAGAIN;
return 0;
}
static ssize_t
pipe_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
struct inode *inode = filp->f_dentry->d_inode;
ssize_t size, read, ret;
/* Seeks are not allowed on pipes. */
ret = -ESPIPE;
read = 0;
if (ppos != &filp->f_pos)
goto out_nolock;
/* Always return 0 on null read. */
ret = 0;
if (count == 0)
goto out_nolock;
/* Get the pipe semaphore */
ret = -ERESTARTSYS;
if (down_interruptible(PIPE_SEM(*inode)))
goto out_nolock;
if (PIPE_EMPTY(*inode)) {
do_more_read:
ret = 0;
if (!PIPE_WRITERS(*inode))
goto out;
ret = -EAGAIN;
if (filp->f_flags & O_NONBLOCK)
goto out;
for (;;) {
PIPE_WAITING_READERS(*inode)++;
pipe_wait(inode);
PIPE_WAITING_READERS(*inode)--;
ret = -ERESTARTSYS;
if (signal_pending(current))
goto out;
ret = 0;
if (!PIPE_EMPTY(*inode))
break;
if (!PIPE_WRITERS(*inode))
goto out;
}
}
/* Read what data is available. */
ret = -EFAULT;
while (count > 0 && (size = PIPE_LEN(*inode))) {
char *pipebuf = PIPE_BASE(*inode) + PIPE_START(*inode);
ssize_t chars = PIPE_MAX_RCHUNK(*inode);
if (chars > count)
chars = count;
if (chars > size)
chars = size;
if (copy_to_user(buf, pipebuf, chars))
goto out;
read += chars;
PIPE_START(*inode) += chars;
PIPE_START(*inode) &= (PIPE_SIZE - 1);
PIPE_LEN(*inode) -= chars;
count -= chars;
buf += chars;
}
/* Cache behaviour optimization */
if (!PIPE_LEN(*inode))
PIPE_START(*inode) = 0;
if (count && PIPE_WAITING_WRITERS(*inode) && !(filp->f_flags & O_NONBLOCK)) {
/*
* We know that we are going to sleep: signal
* writers synchronously that there is more
* room.
*/
wake_up_interruptible_sync(PIPE_WAIT(*inode));
if (!PIPE_EMPTY(*inode))
BUG();
goto do_more_read;
}
/* Signal writers asynchronously that there is more room. */
wake_up_interruptible(PIPE_WAIT(*inode));
ret = read;
out:
up(PIPE_SEM(*inode));
out_nolock:
if (read)
ret = read;
UPDATE_ATIME(inode);
return ret;
}
static ssize_t
pipe_readv(struct file *filp, const struct iovec *_iov,
unsigned long nr_segs, loff_t *ppos)
{
struct inode *inode = filp->f_dentry->d_inode;
int do_wakeup;
ssize_t ret;
struct iovec *iov = (struct iovec *)_iov;
size_t total_len;
total_len = iov_length(iov, nr_segs);
/* Null read succeeds. */
if (unlikely(total_len == 0))
return 0;
do_wakeup = 0;
ret = 0;
down(PIPE_SEM(*inode));
for (;;) {
int size = PIPE_LEN(*inode);
if (size) {
char *pipebuf = PIPE_BASE(*inode) + PIPE_START(*inode);
ssize_t chars = PIPE_MAX_RCHUNK(*inode);
if (chars > total_len)
chars = total_len;
if (chars > size)
chars = size;
if (pipe_iov_copy_to_user(iov, pipebuf, chars)) {
if (!ret) ret = -EFAULT;
break;
}
ret += chars;
PIPE_START(*inode) += chars;
PIPE_START(*inode) &= (PIPE_SIZE - 1);
PIPE_LEN(*inode) -= chars;
total_len -= chars;
do_wakeup = 1;
if (!total_len)
break; /* common path: read succeeded */
}
if (PIPE_LEN(*inode)) /* test for cyclic buffers */
continue;
if (!PIPE_WRITERS(*inode))
break;
if (!PIPE_WAITING_WRITERS(*inode)) {
/* syscall merging: Usually we must not sleep
* if O_NONBLOCK is set, or if we got some data.
* But if a writer sleeps in kernel space, then
* we can wait for that data without violating POSIX.
*/
if (ret)
break;
if (filp->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
break;
}
}
if (signal_pending(current)) {
if (!ret) ret = -ERESTARTSYS;
break;
}
if (do_wakeup) {
wake_up_interruptible_sync(PIPE_WAIT(*inode));
kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
}
pipe_wait(inode);
}
up(PIPE_SEM(*inode));
/* Signal writers asynchronously that there is more room. */
if (do_wakeup) {
wake_up_interruptible(PIPE_WAIT(*inode));
kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
}
/*
* Hack: we turn off atime updates for -RT kernels.
* Who uses them on pipes anyway?
*/
#ifndef CONFIG_PREEMPT_RT
if (ret > 0)
file_accessed(filp);
#endif
return ret;
}
