151 lines
2.9 KiB
C
151 lines
2.9 KiB
C
#include <vfs.h>
|
|
#include <stdint.h>
|
|
#include <sync.h>
|
|
#include <mem.h>
|
|
#include <debug.h>
|
|
#include <scheduler.h>
|
|
|
|
#define PIPE_SIZE 0x1000
|
|
|
|
struct pipe_data
|
|
{
|
|
uint8_t *buffer;
|
|
lock_t lock;
|
|
uint64_t size;
|
|
uint64_t readers;
|
|
uint64_t writers;
|
|
uint64_t read_pos;
|
|
uint64_t write_pos;
|
|
file_t *reader;
|
|
file_t *writer;
|
|
};
|
|
|
|
int pipe_open(file_t *file, uint64_t flags)
|
|
{
|
|
(void) flags;
|
|
struct pipe_data *d = file->data;
|
|
spin_lock(&d->lock);
|
|
if(file == d->reader)
|
|
d->readers ++;
|
|
else
|
|
d->writers ++;
|
|
spin_unlock(&d->lock);
|
|
return 0;
|
|
}
|
|
|
|
int pipe_close(file_t *file)
|
|
{
|
|
debug("Closing pipe\n");
|
|
struct pipe_data *d = file->data;
|
|
spin_lock(&d->lock);
|
|
if(file == d->reader)
|
|
d->readers --;
|
|
else
|
|
d->writers --;
|
|
if((!d->readers) && !(d->writers))
|
|
{
|
|
debug("Freeing pipe\n");
|
|
kfree(d);
|
|
kfree(file);
|
|
} else {
|
|
spin_unlock(&d->lock);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t pipe_read(file_t *file, void *buffer, size_t nbyte, size_t offset)
|
|
{
|
|
(void) offset;
|
|
struct pipe_data *d = file->data;
|
|
uint8_t *buf = buffer;
|
|
|
|
spin_lock(&d->lock);
|
|
while(d->read_pos >= d->write_pos)
|
|
{
|
|
spin_unlock(&d->lock);
|
|
schedule();
|
|
spin_lock(&d->lock);
|
|
}
|
|
|
|
uint64_t bytes = d->write_pos - d->read_pos;
|
|
if(bytes > nbyte) bytes = nbyte;
|
|
|
|
uint64_t buf_pos = d->read_pos % d->size;
|
|
uint64_t n = d->size - buf_pos;
|
|
if(n > bytes) n = bytes;
|
|
|
|
memcpy(buf, &d->buffer[buf_pos], n);
|
|
if(bytes-n)
|
|
memcpy(&buf[n], d->buffer, bytes-n);
|
|
|
|
d->read_pos += bytes;
|
|
|
|
spin_unlock(&d->lock);
|
|
return bytes;
|
|
}
|
|
|
|
size_t pipe_write(file_t *file, void *buffer, size_t nbyte, size_t offset)
|
|
{
|
|
(void) offset;
|
|
struct pipe_data *d = file->data;
|
|
uint8_t *buf = buffer;
|
|
uint64_t written = 0;
|
|
|
|
spin_lock(&d->lock);
|
|
while(nbyte)
|
|
{
|
|
while(d->write_pos >= d->read_pos + d->size)
|
|
{
|
|
spin_unlock(&d->lock);
|
|
schedule();
|
|
spin_lock(&d->lock);
|
|
}
|
|
|
|
uint64_t bytes = d->size - (d->write_pos - d->read_pos);
|
|
if(bytes > nbyte) bytes = nbyte;
|
|
|
|
uint64_t buf_pos = d->write_pos % d->size;
|
|
uint64_t n = d->size - buf_pos;
|
|
if(n > bytes) n = bytes;
|
|
|
|
memcpy(&d->buffer[buf_pos], &buf[written], n);
|
|
if(bytes-n)
|
|
memcpy(d->buffer, &buf[written + n], bytes-n);
|
|
|
|
nbyte -= bytes;
|
|
d->write_pos += bytes;
|
|
written += bytes;
|
|
}
|
|
|
|
spin_unlock(&d->lock);
|
|
return written;
|
|
}
|
|
|
|
fs_driver_t pipe_writer = {
|
|
.open = pipe_open,
|
|
.close = pipe_close,
|
|
.write = pipe_write,
|
|
};
|
|
fs_driver_t pipe_reader = {
|
|
.open = pipe_open,
|
|
.close = pipe_close,
|
|
.read = pipe_read,
|
|
};
|
|
|
|
int pipe(file_t **r, file_t **w)
|
|
{
|
|
*r = kcalloc(1, sizeof(file_t));
|
|
*w = kcalloc(1, sizeof(file_t));
|
|
struct pipe_data *data = (*r)->data = (*w)->data = kcalloc(1, sizeof(struct pipe_data));
|
|
(*r)->driver = &pipe_reader;
|
|
(*w)->driver = &pipe_writer;
|
|
|
|
data->buffer = kcalloc(1, PIPE_SIZE);
|
|
data->size = PIPE_SIZE;
|
|
spin_unlock(&data->lock);
|
|
data->reader = *r;
|
|
data->writer = *w;
|
|
|
|
return 0;
|
|
}
|