rubenwardy
/
rubix_kernel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add non-blocking file descriptors, increase max resources

master
rubenwardy 2017-03-30 14:47:26 +01:00
parent 392ea4c284
commit f394c1c979
9 changed files with 84 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
image.ld
View File

@ -16,6 +16,6 @@ SECTIONS {
. = . + 0x00001000;
tos_svc = .;
/* allocate stack for processes */
. = . + 0x0010000;
. = . + 0x0100000;
tos_UserSpace = .;
}

5
kernel/fides.c
View File

@ -1,7 +1,7 @@
#include "fides.h"
#include "utils.h"
#define MAX_INODES 100
#define MAX_INODES 1000
FiDes fidess[MAX_INODES];
@ -22,6 +22,7 @@ FiDes *fides_create(pid_t pid, u32 fid) {
fidess[ptr].pid = pid;
fidess[ptr].id = fid;
fidess[ptr].is_blocking = true;
kprint("Created fides id=");
printNum(fidess[ptr].id);
@ -34,6 +35,7 @@ FiDes *fides_create(pid_t pid, u32 fid) {
void fides_duplicate(pid_t pid, FiDes *old) {
FiDes *fides = fides_create(pid, old->id);
fides->is_blocking = old->is_blocking;
fides->data = old->data;
fides->write = old->write;
fides->read = old->read;
@ -48,6 +50,7 @@ void fides_duplicateAlias(pid_t pid, u32 old, u32 new) {
FiDes *fides = fides_get(pid, old);
FiDes *fides_new = fides_create(pid, new);
fides_new->data = fides->data;
fides_new->is_blocking = fides->is_blocking;
fides_new->write = fides->write;
fides_new->read = fides->read;
fides_new->grab = fides->grab;

2
kernel/fides.h
View File

@ -8,6 +8,8 @@ struct FiDes {
int refs;
int data; // Used to store pipe id or inode id
bool is_blocking;
size_t (*read) (struct FiDes *node, char *data, size_t max);
size_t (*write) (struct FiDes *node, const char *data, size_t len);

2
kernel/fides_pipe.c
View File

@ -3,7 +3,7 @@
#include "utils.h"
#define PIPE_MAX_BUFFER 0x400
#define MAX_PIPES 3
#define MAX_PIPES 1000
typedef struct {
size_t refs_read;

64
kernel/hilevel.c
View File

@ -11,10 +11,13 @@ extern void main_console();
extern void main_P3();
extern void main_P4();
extern void main_P5();
extern void main_philo();
u32 getProgramInstAddress(const char *name) {
if (strcmp(name, "console") == 0) {
return (u32)&main_console;
} else if (strcmp(name, "philo") == 0) {
return (u32)&main_philo;
} else if (strcmp(name, "p3") == 0) {
return (u32)&main_P3;
} else if (strcmp(name, "p4") == 0) {
@ -193,12 +196,17 @@ u32 svc_handle_read(ctx_t *ctx, pcb_t *current) {
if (node->read) {
size_t res = node->read(node, x, n);
if (res == SIZE_MAX) {
printLine(" - blocked");
scheduler_remove(current->pid);
current->blocked = BLOCKED_FILE;
blockedqueue_addFileRead(current->pid, fd, x, n);
processes_runScheduler(ctx);
return ctx->gpr[0];
if (node->is_blocking) {
printLine(" - blocked");
scheduler_remove(current->pid);
current->blocked = BLOCKED_FILE;
blockedqueue_addFileRead(current->pid, fd, x, n);
processes_runScheduler(ctx);
return ctx->gpr[0];
} else {
printLine(" - nothing read, but non-blocking");
return -1;
}
} else {
return res;
}
@ -400,20 +408,39 @@ u32 svc_handle_dup2(ctx_t *ctx, pcb_t *current) {
return new;
}
u32 svc_handle_fd_setblock(ctx_t *ctx, pcb_t *current) {
printLine(" - fd_setblock");
int fd = (int)(ctx->gpr[0]);
bool is_blocking = (int)(ctx->gpr[1]);
printNum(fd);
kprint("\n");
FiDes *fides = fides_get(current->pid, fd);
if (fides) {
fides->is_blocking = is_blocking;
return 0;
} else {
return -1;
}
}
//
// Handle system calls
//
#define SYS_YIELD ( 0x00 )
#define SYS_WRITE ( 0x01 )
#define SYS_READ ( 0x02 )
#define SYS_FORK ( 0x03 )
#define SYS_EXIT ( 0x04 )
#define SYS_EXEC ( 0x05 )
#define SYS_KILL ( 0x06 )
#define SYS_WAIT ( 0x07 )
#define SYS_PIPE ( 0x08 )
#define SYS_CLOSE ( 0x09 )
#define SYS_DUP2 ( 0x10 )
#define SYS_YIELD ( 0x00 )
#define SYS_WRITE ( 0x01 )
#define SYS_READ ( 0x02 )
#define SYS_FORK ( 0x03 )
#define SYS_EXIT ( 0x04 )
#define SYS_EXEC ( 0x05 )
#define SYS_KILL ( 0x06 )
#define SYS_WAIT ( 0x07 )
#define SYS_PIPE ( 0x08 )
#define SYS_CLOSE ( 0x09 )
#define SYS_DUP2 ( 0x10 )
#define SYS_FD_SETBLOCK ( 0x11 )
void hilevel_handler_svc(ctx_t *ctx, u32 id) {
printLine("SVC");
@ -464,6 +491,9 @@ void hilevel_handler_svc(ctx_t *ctx, u32 id) {
case SYS_DUP2:
ctx->gpr[0] = svc_handle_dup2(ctx, current);
break;
case SYS_FD_SETBLOCK:
ctx->gpr[0] = svc_handle_fd_setblock(ctx, current);
break;
case SYS_KILL:
ctx->gpr[0] = svc_handle_kill(ctx, current);
break;

2
kernel/processes.c
View File

@ -123,7 +123,7 @@ typedef struct {
extern u32 tos_UserSpace;
#define PAGE_SIZE 4096
#define MAX_PAGES 0x0010000 / PAGE_SIZE
#define MAX_PAGES 0x0100000 / PAGE_SIZE
Page pages[MAX_PAGES];
u32 processes_allocateStack(pid_t pid) {

2
kernel/processes.h
View File

@ -19,7 +19,7 @@ typedef enum {
} BlockedReason;
#define MAX_PROCESSES 10
#define MAX_PROCESSES 50
// ^ Linux is 31,000 per user
typedef struct {

13
user/libc.c
View File

@ -206,6 +206,19 @@ int close(int fd) {
return r;
}
int fd_setblock(int fd, int isblocking) {
int r;
asm volatile( "mov r0, %2 \n" // assign r0 = pid
"mov r1, %3 \n" // assign r0 = pid
"svc %1 \n" // make system call SYS_CLOSE
"mov %0, r0 \n" // assign r = r0
: "=r" (r)
: "I" (SYS_FD_SETBLOCK), "r" (fd), "r" (isblocking)
: "r0" );
return r;
}
int kill( int pid, int x ) {
int r;

25
user/libc.h
View File

@ -23,17 +23,18 @@ typedef int pid_t;
* to act as a limited model of similar concepts.
*/
#define SYS_YIELD ( 0x00 )
#define SYS_WRITE ( 0x01 )
#define SYS_READ ( 0x02 )
#define SYS_FORK ( 0x03 )
#define SYS_EXIT ( 0x04 )
#define SYS_EXEC ( 0x05 )
#define SYS_KILL ( 0x06 )
#define SYS_WAIT ( 0x07 )
#define SYS_PIPE ( 0x08 )
#define SYS_CLOSE ( 0x09 )
#define SYS_DUP2 ( 0x10 )
#define SYS_YIELD ( 0x00 )
#define SYS_WRITE ( 0x01 )
#define SYS_READ ( 0x02 )
#define SYS_FORK ( 0x03 )
#define SYS_EXIT ( 0x04 )
#define SYS_EXEC ( 0x05 )
#define SYS_KILL ( 0x06 )
#define SYS_WAIT ( 0x07 )
#define SYS_PIPE ( 0x08 )
#define SYS_CLOSE ( 0x09 )
#define SYS_DUP2 ( 0x10 )
#define SYS_FD_SETBLOCK ( 0x11 )
#define SIG_TERM ( 0x00 )
#define SIG_QUIT ( 0x01 )
@ -76,6 +77,8 @@ extern int dup2(int old, int new);
extern int close(int fd);
extern int fd_setblock(int fd, int isblocking);
// signal process identified by pid with signal x
extern int kill( pid_t pid, int x );