hmn
/
orca
5
Fork 2
Code Issues 21 Pull Requests 1 Packages Projects Releases Wiki Activity

[io] Store last error in file handle, lockdown on fatal error

This commit is contained in:
Martin Fouilleul 2023-05-10 18:41:30 +02:00
parent 25f66b3954
commit e82225116b
2 changed files with 305 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/io_common.h
View File

@ -69,12 +69,22 @@ typedef struct io_req
typedef i32 io_error; typedef i32 io_error;
enum { enum {
IO_OK = 0, IO_OK = 0,
IO_ERR_INVALID, // invalid argument or argument combination IO_ERR_UNKNOWN,
IO_ERR_PERM, // access denied IO_ERR_OP, // unsupported operation
IO_ERR_PATH, // path does not exist
IO_ERR_EXISTS, // file already exists
IO_ERR_HANDLE, // invalid handle IO_ERR_HANDLE, // invalid handle
IO_ERR_MAX_FILES, IO_ERR_PREV, // previously had a fatal error (last error stored on handle)
IO_ERR_ARG, // invalid argument or argument combination
IO_ERR_PERM, // access denied
IO_ERR_SPACE, // no space left
IO_ERR_NO_FILE, // file does not exist
IO_ERR_EXISTS, // file already exists
IO_ERR_MAX_FILES, // max open files reached
IO_ERR_PATH_LENGTH, // path too long
IO_ERR_FILE_SIZE, // file too big
IO_ERR_OVERFLOW, // offset too big
IO_ERR_NOT_READY, // no data ready to be read/written
IO_ERR_MEM, // failed to allocate memory
//... //...
}; };

275
src/io_impl.c
View File

@ -21,6 +21,7 @@ typedef struct file_slot
u32 generation; u32 generation;
int fd; int fd;
io_error error; io_error error;
bool fatal;
list_elt freeListElt; list_elt freeListElt;
} file_slot; } file_slot;
@ -87,6 +88,17 @@ io_cmp io_open(io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_alloc(&__globalFileTable);
if(!slot)
{
cmp.error = IO_ERR_MAX_FILES;
cmp.result = 0;
}
else
{
file_handle handle = file_handle_from_slot(&__globalFileTable, slot);
cmp.result = handle.h;
int flags = 0; int flags = 0;
if(req->openFlags & IO_OPEN_READ) if(req->openFlags & IO_OPEN_READ)
{ {
@ -148,9 +160,6 @@ io_cmp io_open(io_req* req)
int fd = open(absCString, flags, mode); int fd = open(absCString, flags, mode);
if(fd >= 0) if(fd >= 0)
{
file_slot* slot = file_slot_alloc(&__globalFileTable);
if(slot)
{ {
slot->fd = fd; slot->fd = fd;
file_handle handle = file_handle_from_slot(&__globalFileTable, slot); file_handle handle = file_handle_from_slot(&__globalFileTable, slot);
@ -158,84 +167,121 @@ io_cmp io_open(io_req* req)
} }
else else
{ {
cmp.error = IO_ERR_MAX_FILES; slot->fd = -1;
close(fd); slot->fatal = true;
}
}
else
{
switch(errno) switch(errno)
{ {
case EACCES: case EACCES:
cmp.error = IO_ERR_PERM; case EROFS:
slot->error = IO_ERR_PERM;
break;
case EDQUOT:
case ENOSPC:
slot->error = IO_ERR_SPACE;
break;
case EEXIST:
slot->error = IO_ERR_EXISTS;
break;
case EFAULT:
case EINVAL:
case EISDIR:
slot->error = IO_ERR_ARG;
break;
case EMFILE:
case ENFILE:
slot->error = IO_ERR_MAX_FILES;
break;
case ENAMETOOLONG:
slot->error = IO_ERR_PATH_LENGTH;
break;
case ENOENT:
case ENOTDIR:
slot->error = IO_ERR_NO_FILE;
break;
case EOVERFLOW:
slot->error = IO_ERR_FILE_SIZE;
break; break;
//TODO: convert open error codes to io_error
default: default:
cmp.error = IO_ERR_INVALID; slot->error = IO_ERR_UNKNOWN;
break;
} }
cmp.error = slot->error;
} }
mem_arena_clear_to(scratch, mark); mem_arena_clear_to(scratch, mark);
}
return(cmp); return(cmp);
} }
io_cmp io_close(io_req* req) io_cmp io_close(file_slot* slot, io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_from_handle(&__globalFileTable, req->handle); if(slot->fd >= 0)
if(slot)
{ {
close(slot->fd); close(slot->fd);
}
file_slot_recycle(&__globalFileTable, slot); file_slot_recycle(&__globalFileTable, slot);
}
else
{
cmp.error = IO_ERR_HANDLE;
}
return(cmp); return(cmp);
} }
io_cmp io_size(io_req* req) io_cmp io_size(file_slot* slot, io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_from_handle(&__globalFileTable, req->handle);
if(slot)
{
struct stat s; struct stat s;
fstat(slot->fd, &s); if(fstat(slot->fd, &s))
{
slot->error = IO_ERR_UNKNOWN;
cmp.error = slot->error;
}
else
{
cmp.result = s.st_size; cmp.result = s.st_size;
} }
else
{
cmp.error = IO_ERR_HANDLE;
}
return(cmp); return(cmp);
} }
io_cmp io_pos(io_req* req) io_cmp io_pos(file_slot* slot, io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_from_handle(&__globalFileTable, req->handle);
if(slot)
{
cmp.result = lseek(slot->fd, 0, SEEK_CUR); cmp.result = lseek(slot->fd, 0, SEEK_CUR);
//TODO: check for errors if(cmp.result < 0)
}
else
{ {
cmp.error = IO_ERR_HANDLE; switch(errno)
{
case EINVAL:
slot->error = IO_ERR_ARG;
break;
case EOVERFLOW:
slot->error = IO_ERR_OVERFLOW;
break;
default:
slot->error = IO_ERR_UNKNOWN;
break;
} }
cmp.error = slot->error;
}
return(cmp); return(cmp);
} }
io_cmp io_seek(io_req* req) io_cmp io_seek(file_slot* slot, io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_from_handle(&__globalFileTable, req->handle);
if(slot)
{
int whence; int whence;
switch(req->whence) switch(req->whence)
{ {
@ -251,63 +297,113 @@ io_cmp io_seek(io_req* req)
whence = SEEK_END; whence = SEEK_END;
} }
cmp.result = lseek(slot->fd, req->size, whence); cmp.result = lseek(slot->fd, req->size, whence);
//TODO: check for errors
} if(cmp.result < 0)
else
{ {
cmp.error = IO_ERR_HANDLE; switch(errno)
{
case EINVAL:
slot->error = IO_ERR_ARG;
break;
case EOVERFLOW:
slot->error = IO_ERR_OVERFLOW;
break;
default:
slot->error = IO_ERR_UNKNOWN;
break;
} }
cmp.error = slot->error;
}
return(cmp); return(cmp);
} }
io_cmp io_read(io_req* req) io_cmp io_read(file_slot* slot, io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_from_handle(&__globalFileTable, req->handle);
if(slot)
{
cmp.result = read(slot->fd, req->buffer, req->size); cmp.result = read(slot->fd, req->buffer, req->size);
//TODO: check for errors
} if(cmp.result < 0)
else
{ {
cmp.error = IO_ERR_HANDLE; switch(errno)
{
case EAGAIN:
slot->error = IO_ERR_NOT_READY;
break;
case EFAULT:
case EINVAL:
slot->error = IO_ERR_ARG;
break;
case ENOBUFS:
case ENOMEM:
slot->error = IO_ERR_MEM;
break;
default:
slot->error = IO_ERR_UNKNOWN;
break;
} }
cmp.error = slot->error;
}
return(cmp); return(cmp);
} }
io_cmp io_write(io_req* req) io_cmp io_write(file_slot* slot, io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_from_handle(&__globalFileTable, req->handle);
if(slot)
{
cmp.result = write(slot->fd, req->buffer, req->size); cmp.result = write(slot->fd, req->buffer, req->size);
//TODO: check for errors
} if(cmp.result < 0)
else
{ {
cmp.error = IO_ERR_HANDLE; switch(errno)
{
case EDQUOT:
case ENOSPC:
slot->error = IO_ERR_SPACE;
break;
case EFAULT:
case EINVAL:
slot->error = IO_ERR_ARG;
break;
case EAGAIN:
slot->error = IO_ERR_NOT_READY;
break;
case EFBIG:
slot->error = IO_ERR_FILE_SIZE;
break;
case ENOBUFS:
case ENOMEM:
slot->error = IO_ERR_MEM;
break;
default:
slot->error = IO_ERR_UNKNOWN;
break;
} }
cmp.error = slot->error;
}
return(cmp); return(cmp);
} }
io_cmp io_get_error(io_req* req) io_cmp io_get_error(file_slot* slot, io_req* req)
{ {
io_cmp cmp = {0}; io_cmp cmp = {0};
file_slot* slot = file_slot_from_handle(&__globalFileTable, req->handle); cmp.result = slot->error;
if(slot)
{
//TODO get error from slot
}
else
{
cmp.error = IO_ERR_HANDLE;
}
return(cmp); return(cmp);
} }
io_cmp io_wait_single_req(io_req* req) io_cmp io_wait_single_req(io_req* req)
{ {
mem_arena* scratch = mem_scratch(); mem_arena* scratch = mem_scratch();
@ -332,13 +428,29 @@ io_cmp io_wait_single_req(io_req* req)
if(bufferIndex + req->size > memSize) if(bufferIndex + req->size > memSize)
{ {
cmp.error = IO_ERR_INVALID; cmp.error = IO_ERR_ARG;
} }
else else
{ {
//TODO: avoid modifying req. //TODO: avoid modifying req.
req->buffer = memory + bufferIndex; req->buffer = memory + bufferIndex;
file_slot* slot = 0;
if(req->op != IO_OP_OPEN)
{
slot = file_slot_from_handle(&__globalFileTable, req->handle);
if(!slot)
{
cmp.error = IO_ERR_HANDLE;
}
else if(slot->fatal && req->op != IO_OP_CLOSE)
{
cmp.error = IO_ERR_PREV;
}
}
if(cmp.error == IO_OK)
{
switch(req->op) switch(req->op)
{ {
case IO_OP_OPEN: case IO_OP_OPEN:
@ -346,38 +458,39 @@ io_cmp io_wait_single_req(io_req* req)
break; break;
case IO_OP_CLOSE: case IO_OP_CLOSE:
cmp = io_close(req); cmp = io_close(slot, req);
break; break;
case IO_OP_SIZE: case IO_OP_SIZE:
cmp = io_size(req); cmp = io_size(slot, req);
break; break;
case IO_OP_READ: case IO_OP_READ:
cmp = io_read(req); cmp = io_read(slot, req);
break; break;
case IO_OP_WRITE: case IO_OP_WRITE:
cmp = io_write(req); cmp = io_write(slot, req);
break; break;
case IO_OP_POS: case IO_OP_POS:
cmp = io_pos(req); cmp = io_pos(slot, req);
break; break;
case IO_OP_SEEK: case IO_OP_SEEK:
cmp = io_seek(req); cmp = io_seek(slot, req);
break; break;
case IO_OP_ERROR: case IO_OP_ERROR:
cmp = io_get_error(req); cmp = io_get_error(slot, req);
break; break;
default: default:
cmp.error = IO_ERR_INVALID; cmp.error = IO_ERR_OP;
break; break;
} }
} }
}
return(cmp); return(cmp);
} }