Merge remote-tracking branch 'origin/atlas' into naopross

16 files changed, 1002 insertions, 103 deletions

diff --git a/sw/z80/kernel/fs.c b/sw/z80/kernel/fs.c
deleted file mode 100644
index 3ce7f42..0000000
--- a/sw/z80/kernel/fs.c
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "fs.h"
-#include "users.h"
-#include "mount.h"
-
-struct fs_mount_point * mount_points[FS_MOUNT_LIMIT];
diff --git a/sw/z80/kernel/fs/fd.c b/sw/z80/kernel/fs/fd.c
new file mode 100644
index 0000000..96603ad
--- /dev/null
+++ b/sw/z80/kernel/fs/fd.c
@@ -0,0 +1,255 @@
+#include "fs/fd.h"
+#include "fs/fdop.h"
+#include "fs/fs.h"
+
+/* from fd.h */
+struct file_desc fd_table[FD_TABLE_SIZE];
+struct uint8_t  fd_bmap[FD_TABLE_SIZE / 8];
+
+/* File descriptors implementation */
+
+int8_t open(const char *path, uint8_t flags)
+{
+    // TODO
+    return 0; 
+}
+
+size_t ls(int8_t fd, struct dirent *buf, uint8_t all)
+{
+    // TODO
+    return 0; 
+}
+
+size_t find(int8_t fd, struct dirent *buf, const char *name)
+{
+    // TODO
+    return 0; 
+}
+
+int8_t mkdir(int8_t fd, const char *name)
+{
+    // TODO
+    return 0; 
+}
+
+int8_t touch(int8_t fd, const char *name)
+{
+    // TODO
+    return 0; 
+}
+
+int8_t ln(int8_t fd, const char *name)
+{
+    // TODO
+    return 0; 
+}
+
+int8_t seek(int8_t fd, fsize_t pos)
+{
+    // TODO
+    return 0; 
+}
+
+size_t readline(int8_t fd, char *buf, char term)
+{
+    // TODO
+    return 0; 
+}
+
+int8_t print(int8_t fd, const char *str)
+{
+    // TODO
+    return 0; 
+}
+
+size_t read(int8_t fd, void *buf, size_t n)
+{
+    // TODO
+    return 0; 
+}
+
+int8_t write(int8_t fd, const void *buf, size_t n)
+{
+    // TODO
+    return 0; 
+}
+
+void close(int8_t fd)
+{
+    // TODO
+    return 0; 
+}
+
+/* Set of file descriptors operations */
+/* Determines if to use the serial interface or the address space */
+
+/* Address space section */
+
+/* File functions */
+
+size_t as_readline(inode_t inode, fsize_t seek, char *buf, char term)
+{
+    // TODO
+    return 0;
+}
+
+size_t as_print(inode_t inode, fsize_t seek, const char *str)
+{
+    // TODO
+    return 0;
+}
+
+size_t as_append(inode_t inode, fsize_t *seek_ptr, const char *str)
+{
+    // TODO
+    return 0;
+}
+
+size_t as_read(inode_t inode, fsize_t seek, void *buf, size_t n)
+{
+    // TODO
+    return 0;
+}
+
+size_t as_write(inode_t inode, fsize_t seek, const void *buf, size_t n)
+{
+    // TODO
+    return 0;
+}
+
+size_t as_bin_append(inode_t inode, fsize_t *seek_ptr, const void *buf, size_t
+n)
+{
+    // TODO
+    return 0;
+}
+
+/* Directory functions */
+
+size_t as_ls(inode_t inode, struct dirent *buf, uint8_t all)
+{
+    // TODO
+    return 0;
+}
+
+size_t as_find(inode_t inode, struct dirent *buf, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t as_mkdir(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t as_rmdir(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t as_touch(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t as_rm(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t as_ln(inode_t inode, const char *path, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+/* Serial Space section */
+/* Warning, it doesn't switch to the right driver */
+
+/* File functions */
+
+size_t ss_readline(inode_t inode, fsize_t seek, char *buf, char term)
+{
+    // TODO
+    return 0;
+}
+
+size_t ss_print(inode_t inode, fsize_t seek, const char *str)
+{
+    // TODO
+    return 0;
+}
+
+size_t ss_append(inode_t inode, fsize_t *seek_ptr, const char *str)
+{
+    // TODO
+    return 0;
+}
+
+size_t ss_read(inode_t inode, fsize_t seek, void *buf, size_t n)
+{
+    // TODO
+    return 0;
+}
+
+size_t ss_write(inode_t inode, fsize_t seek, const void *buf, size_t n)
+{
+    // TODO
+    return 0;
+}
+
+size_t ss_bin_append(inode_t inode, fsize_t *seek_ptr, const void *buf, size_t
+n)
+{
+    // TODO
+    return 0;
+}
+
+/* Directory functions */
+
+size_t ss_ls(inode_t inode, struct dirent *buf, uint8_t all)
+{
+    // TODO
+    return 0;
+}
+
+size_t ss_find(inode_t inode, struct dirent *buf, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t ss_mkdir(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t ss_rmdir(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t ss_touch(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t ss_rm(inode_t inode, const char *name)
+{
+    // TODO
+    return 0;
+}
+
+int8_t ss_ln(inode_t, const char *path, const char *name)
+{
+    // TODO
+    return 0;
+}
diff --git a/sw/z80/kernel/fs/fs.c b/sw/z80/kernel/fs/fs.c
new file mode 100644
index 0000000..584f934
--- /dev/null
+++ b/sw/z80/kernel/fs/fs.c
@@ -0,0 +1,236 @@
+#include "fs/fs.h"
+#include "fs/users.h"
+#include "fs/dev.h"
+
+/* from users.h */
+struct fs_user c_user;
+
+/* from inode.h */
+inode_t c_inode;
+
+struct fs_dev devices[FS_MOUNT_LIMIT];
+
+/* filesystem basic implementation */
+
+devsize_t fs_block(blk_t block)
+{
+    // TODO
+    return 0;
+}
+
+devsize_t fs_inode(struct fs_inode *buf)
+{
+    struct fs_superblock * sb;
+    devsize_t seek;
+
+    if (FS_USE_ROM(c_inode))
+    {
+        seek = FS_ROM_SPACE;
+        sb = (struct fs_superblock*) seek; 
+
+    } else {
+
+        seek = 0;
+
+        if (c_inode.dev > 0x7)
+            panic("Invalid device");    // TODO, still to implement
+
+        sb = &devices[c_inode.dev].superblock; 
+    }
+
+    if (c_inode.inode >= sb->imap_size)
+    {
+        // TODO, set errno
+        return 0;   // inode doesn't exist
+    }
+
+    seek += sizeof(struct fs_superblock) + 
+            sizeof(struct fs_inode) * c_inode.inode;
+
+    if (FS_USE_ROM(c_inode))
+        *buf = *(struct fs_inode*)seek;
+    else
+    {
+        /* set sio port */
+        sio_port = devices[c_inode.dev].port_no;
+        sio_seek = seek;
+
+        if (sio_read((void *)buf, INODE_META_SIZE) < INODE_META_SIZE)
+        {
+            // TODO, set errno
+            return 0;   // cannot read to device
+        }
+    }
+
+    return seek + INODE_META_SIZE;
+}
+
+/* from fd.h */
+int8_t __fd_new()
+{
+    int8_t fd;
+    for (int8_t = 0; i < FD_TABLE_SIZE / 8; i++)
+    {
+        for (uint8_t bit = 0x80, j = 0; bit > 0; bit >>= 1, j++)
+        {
+            if (!(bit & fd_bmap[i]))
+                return i * 8 + j;
+        }
+    }
+
+    return -1;
+}
+
+/* from fd.h */
+int8_t __open_c_inode(uint8_t flags)
+{
+    /* read meta data */
+    struct fs_inode inode;
+
+    /* init file_desc buffer */
+    struct file_desc desc = {c_inode, 0};
+    
+    desc.begin = fs_inode(&inode);
+    
+    /* bind operations */
+
+    if (flags & OPEN_DIR)
+    {
+        /* dir handler */
+
+        if (inode.type == INODE_TYPE_DIR)
+        {
+            /* bind dir functions */
+            if (FS_USE_ROM(c_inode))
+                /* bind address space functions */
+                FD_BIND_AS_DIR(desc.opers)
+            else
+                /* bind serial space functions */
+                FD_BIND_SS_DIR(desc.opers)
+
+        } else {
+
+            // TODO, set errno
+            return -1;  // not a directory
+        }
+
+    } else if (flags & OPEN_LINK) {
+        
+        /* link handler */
+
+        if (inode.type == INODE_TYPE_LINK)
+        {
+            if (FS_USE_ROM(c_inode))
+                FD_BIND_AS_FILE(desc.opers, flags)
+            else
+                FD_BIND_SS_FILE(desc.opers, flags)
+
+            if (flags & OPEN_ERASE)
+                /* empty file content */
+                __inode_empty(desc.begin);
+
+        } else {
+            
+            // TODO, set errno
+            return -1;  // not a link
+        }
+
+    } else {
+
+        /* file */
+
+        if (inode.type == INODE_TYPE_FILE)
+            ;   // do nothing
+        else if (inode.type == INODE_TYPE_SPECIAL) {
+            
+            // TODO, bind special callbacks
+            
+        } else {
+
+            // TODO, set errno
+            return -1;
+        }
+
+        /* bind operations */
+
+        if (FS_USE_ROM(c_inode))
+        {
+            if (flags & OPEN_BIN)
+                FD_BIND_AS_BINFILE(desc.opers, flags)
+            else
+                FD_BIND_AS_FILE(desc.opers, flags) 
+
+        } else {
+            
+            if (flags & OPEN_BIN)
+                FD_BIND_SS_BINFILE(desc.opers, flags)
+            else
+                FD_BIND_SS_FILE(desc.opers, flags)
+        }
+    }
+
+    /* find a free fd space */
+    
+    int8_t fd = __fd_new();
+
+    if (fd < 0)
+    {
+        // TODO, set errno, fd not available
+
+    } else
+        fd_table[fd] = desc; // copy buffer into the table
+
+    return fd;
+}
+
+inode_t fs_rec_path(const char *path);
+
+inode_t fs_parse_path(const char *path)
+{
+    inode_t ino, cwd = c_inode;
+
+    switch (path[0])
+    {
+        case '0':
+        FS_INODE_NULL(ino)
+        return ino;
+
+        case '/':
+        FS_INODE_ROOT(ino)
+        c_inode = ino;       // set cwd to root
+        path++;
+        break;
+
+        case '~':
+
+        if (path[1] = '/')
+        {
+            c_inode.dev = FS_DEV_ROM;
+            c_inode.inode = c_user.home;  // set cwd to home
+            path += 2;
+        }
+            
+        break;
+   }
+
+   ino = fs_rec_path(path);
+   c_inode = cwd;
+   return ino;
+}
+
+inode_t fs_rec_path(const char *path)
+{
+    devsize_t inode = fs_inode(c_inode.inode); 
+    inode_t rel;
+
+    if (!inode)   // if not exists
+    {
+        FS_INODE_NULL(rel)
+        return rel;
+    }
+
+    // TODO, check if dir or file
+    // TODO, if dir, find name
+    // TODO, set fs_cwd to new inode
+    // TODO, recall fs_rec_path
+}
diff --git a/sw/z80/kernel/include/errno.h b/sw/z80/kernel/include/errno.h
new file mode 100644
index 0000000..7632269
--- /dev/null
+++ b/sw/z80/kernel/include/errno.h
@@ -0,0 +1,35 @@
+#ifndef ERRNO_H
+#define ERRNO_H
+
+extern int errno;
+
+#define EPERM       1       /* Operation not permitted */
+#define ENOENT      2       /* No such file or directory */
+#define ESRCH       3       /* No such process */
+#define EINTR       4       /* Interrupted system call */
+#define EIO         5       /* Input/output error */
+#define ENXIO       6       /* Device not configured */
+#define E2BIG       7       /* Argument list too long */
+#define ENOEXEC     8       /* Exec format error */
+#define EBADF       9       /* Bad file descriptor */
+#define ECHILD      10      /* No child processes */
+#define EDEADLK     11      /* Resource deadlock avoided */
+
+#define ENOMEM      12      /* Cannot allocate memory */
+#define EACCES      13      /* Permission denied */
+#define EFAULT      14      /* Bad address */
+
+#define ENOTBLK     15      /* Block device required */
+#define EBUSY       16      /* Device busy */
+#define EEXIST      17      /* File exists */
+
+#define EXDEV       18      /* Cross-device link */
+#define ENODEV      19      /* Operation not supported by device */
+#define ENOTDIR     20      /* Not a directory */
+#define EISDIR      21      /* Is a directory */
+#define EINVAL      22      /* Invalid argument */
+#define ENFILE      23      /* Too many open files in system */
+#define EMFILE      24      /* Too many open files */
+#define ENOTTY      25      /* Inappropriate ioctl for device */
+
+#endif
diff --git a/sw/z80/kernel/include/fs/dev.h b/sw/z80/kernel/include/fs/dev.h
new file mode 100644
index 0000000..8e550f3
--- /dev/null
+++ b/sw/z80/kernel/include/fs/dev.h
@@ -0,0 +1,29 @@
+#ifndef DEV_H
+#define DEV_H
+
+#include "types.h"
+
+#define FS_MOUNT_LIMIT 16
+
+struct fs_superblock
+{
+    uint8_t     magic;           // identifier
+
+    size_t      blk_size;           // size of a single block
+    size_t      imap_size;          // quantity of inodes
+    size_t      dmap_size;          // quantity of blocks
+};
+
+struct fs_dev
+{
+    uint                    enabled :1;     // in use
+    uint                    port_no :3;     // serial port number
+    uint                            :4; 
+    inode_t                 inode;          // dir mounted
+    struct fs_superblock    superblock;     // block informations
+};
+
+/* list of devices */ 
+extern struct fs_dev devices[FS_MOUNT_LIMIT];
+
+#endif
diff --git a/sw/z80/kernel/include/fs/dirent.h b/sw/z80/kernel/include/fs/dirent.h
index ea5699b..2fd224a 100644
--- a/sw/z80/kernel/include/fs/dirent.h
+++ b/sw/z80/kernel/include/fs/dirent.h
@@ -1,13 +1,17 @@
-#ifndef DIRENT_H
-#define DIRENT_H
+#ifndef __DIRENT_H__
+#define __DIRENT_H__
 
 #include "types.h"
 
 struct dirent
 {
-    ino_t       i_number;       // inode referred
+    ino_t       inode;       // inode referred
     uint8_t     name_size;    // size of the name
     char        name[];         // name of the referred inode
-}
+};
 
-#endif
+/* if inode is FS_INO_NULL, then the dirent is a memory leak */
+/* Warning: dirent leaks are generated by rm or rmdir operations */
+/* Filesystem must be periodically checked and cleaned */
+
+#endif  // __DIRENT_H__
diff --git a/sw/z80/kernel/include/fs/fd.h b/sw/z80/kernel/include/fs/fd.h
new file mode 100644
index 0000000..d2fea2a
--- /dev/null
+++ b/sw/z80/kernel/include/fs/fd.h
@@ -0,0 +1,102 @@
+#ifndef __FD_H__
+#define __FD_H__
+
+#include "types.h"
+
+#define FD_MAX 32
+
+#define OPEN_READ       0x1
+#define OPEN_WRITE      0x2 
+#define OPEN_BIN        0x4
+#define OPEN_APPEND     0x8
+#define OPEN_ERASE      0x10
+#define OPEN_DIR        0x20
+#define OPEN_LINK       0x40
+
+#define LS_ALL       0x1
+
+/* declare dirent, not include */
+#ifndef __DIRENT_H__
+struct dirent;
+#endif
+
+/* set of operations callback for fd */
+struct fd_operations
+{
+    size_t (*readline)(inode_t, fsize_t, char *, char term);
+    size_t (*print)(inode_t, fsize_t, const char *);
+    size_t (*append)(inode_t, fsize_t*, const char *);
+
+    size_t (*read)(inode_t, fsize_t, void *, size_t);
+    size_t (*write)(inode_t, fsize_t, const void *, size_t);
+    size_t (*bin_append)(inode_t, fsize_t*, const void *, size_t);
+
+    size_t (*ls)(inode_t, struct dirent *, uint8_t);
+    size_t (*find)(inode_t, struct dirent *, const char *);
+    int8_t (*mkdir)(inode_t, const char *);
+    int8_t (*rmdir)(inode_t, const char *);
+    int8_t (*touch)(inode_t, const char *);
+    int8_t (*rm)(inode_t, const char *);
+    int8_t (*ln)(inode_t, const char *, const char *);
+
+    int8_t (*special)(inode_t, void *, size_t);
+};
+
+/* file descriptor */
+struct file_desc
+{
+    inode_t                 inode;  // inode pointed
+    fsize_t                 seek;   // virtual seek
+    devsize_t               begin;  // beginning of blocks
+    struct fd_operations    opers;  // bound operations
+};
+
+/* bitmap of used file descriptors */
+extern struct uint8_t fd_bmap[FD_TABLE_SIZE / 8];
+
+/* table of file descriptors */
+extern struct file_desc fd_table[FD_TABLE_SIZE];
+
+/* returns a free file descriptor */
+int8_t __fd_new();
+
+/* opens a file streaming of the cwd */
+int8_t __open_c_inode(uint8_t flags);
+
+/* opens a file streaming by a path */
+int8_t open(const char *path, uint8_t flags); 
+
+/* list content of directory */
+size_t ls(int8_t fd, struct dirent *buf, uint8_t all);
+
+/* find name through the directory entries */
+size_t find(int8_t fd, struct dirent *buf, const char *name);
+
+/* creates a new directory inside fd with the specified name */
+int8_t mkdir(int8_t fd, const char *name);
+
+/* creates a new file inside fd with the specified name */
+int8_t touch(int8_t fd, const char *name);
+
+/* creates a new symlink inside fd with the specified name */
+int8_t ln(int8_t fd, const char *name);
+
+/* change virtual seek position of the fd */
+int8_t seek(int8_t fd, fsize_t pos);
+
+/* reads a string from the fd until the terminator is reached */
+size_t readline(int8_t fd, char *buf, char term);
+
+/* writes a string into the fd */
+int8_t print(int8_t fd, const char *str);
+
+/* reads n bytes from the fd */
+size_t read(int8_t fd, void *buf, size_t n);
+
+/* writes n bytes into the fd */
+int8_t write(int8_t fd, const void *buf, size_t n);
+
+/* frees fd space */
+void close(int8_t fd);
+
+#endif  // __FD_H__
diff --git a/sw/z80/kernel/include/fs/fdop.h b/sw/z80/kernel/include/fs/fdop.h
new file mode 100644
index 0000000..d4b1b77
--- /dev/null
+++ b/sw/z80/kernel/include/fs/fdop.h
@@ -0,0 +1,140 @@
+#ifndef __FDOP_H__
+#define __FDOP_H__
+
+#include "types.h"
+
+#ifndef __DIRENT_H__
+struct dirent;
+#endif
+
+/* macro for direct binding */
+
+#define FD_BIND_AS_DIR(oper)    {       \
+                                    oper.ls = &as_ls;   \
+                                    oper.find = &as_find; \
+                                    oper.mkdir = &as_mkdir; \
+                                    oper.rmdir = &as_rmdir; \
+                                    oper.touch = &as_touch; \
+                                    oper.rm = &as_rm; \
+                                    oper.ln = &as_ln; \
+                                }
+
+#define FD_BIND_SS_DIR(oper)    {       \
+                                    oper.ls = &ss_ls;   \
+                                    oper.find = &ss_find; \
+                                    oper.mkdir = &ss_mkdir; \
+                                    oper.rmdir = &ss_rmdir; \
+                                    oper.touch = &ss_touch; \
+                                    oper.rm = &ss_rm; \
+                                    oper.ln = &ss_ln; \
+                                }
+
+#define FD_BIND_AS_FILE(opers, flags) {      \
+                                    if (flags & OPEN_READ)  \
+                                        opers.readline = as_readline;   \
+                                    if (flags & OPEN_APPEND)    \
+                                        opers.append = as_append;   \
+                                    else if (flags & OPEN_WRITE)    \
+                                        opers.print = as_print;     \
+                                    }
+
+#define FD_BIND_SS_FILE(opers, flags) {      \
+                                    if (flags & OPEN_READ)  \
+                                        opers.readline = ss_readline;   \
+                                    if (flags & OPEN_APPEND)    \
+                                        opers.append = ss_append;   \
+                                    else if (flags & OPEN_WRITE)    \
+                                        opers.print = ss_print;     \
+                                     }
+
+#define FD_BIND_AS_BINFILE(opers, flags) {     \
+                                        if (flags & OPEN_READ)  \
+                                            opers.read = as_read;   \
+                                        if (flags & OPEN_APPEND)    \
+                                            opers.bin_append = as_bin_append;   \
+                                        else if (flags & OPEN_WRITE)    \
+                                            opers.write = as_write;     \
+                                        }
+
+#define FD_BIND_SS_BINFILE(opers, flags) {     \
+                                        if (flags & OPEN_READ)  \
+                                            opers.read = ss_read;   \
+                                        if (flags & OPEN_APPEND)    \
+                                            opers.bin_append = ss_bin_append;   \
+                                        else if (flags & OPEN_WRITE)    \
+                                            opers.write = ss_write;     \
+                                        }
+
+/* Set of file descriptors operations */
+/* Determines if to use the serial interface or the address space */
+
+/* Address space section */
+
+/* File functions */
+
+size_t as_readline(inode_t inode, fsize_t seek, char *buf, char term);
+
+size_t as_print(inode_t inode, fsize_t seek, const char *str);
+
+size_t as_append(inode_t inode, fsize_t *seek_ptr, const char *str);
+
+
+size_t as_read(inode_t inode, fsize_t seek, void *buf, size_t n);
+
+size_t as_write(inode_t inode, fsize_t seek, const void *buf, size_t n);
+
+size_t as_bin_append(inode_t inode, fsize_t *seek_ptr, const void *buf, size_t
+n);
+
+/* Directory functions */
+
+size_t as_ls(inode_t inode, struct dirent *buf, uint8_t all);
+
+size_t as_find(inode_t inode, struct dirent *buf, const char *name);
+
+int8_t as_mkdir(inode_t inode, const char *name);
+
+int8_t as_rmdir(inode_t inode, const char *name);
+
+int8_t as_touch(inode_t inode, const char *name);
+
+int8_t as_rm(inode_t inode, const char *name);
+
+int8_t as_ln(inode_t inode, const char *path, const char *name);
+
+/* Serial Space section */
+/* Warning, it doesn't switch to the right driver */
+
+/* File functions */
+
+size_t ss_readline(inode_t inode, fsize_t seek, char *buf, char term);
+
+size_t ss_print(inode_t inode, fsize_t seek, const char *str);
+
+size_t ss_append(inode_t inode, fsize_t *seek_ptr, const char *str);
+
+
+size_t ss_read(inode_t inode, fsize_t seek, void *buf, size_t n);
+
+size_t ss_write(inode_t inode, fsize_t seek, const void *buf, size_t n);
+
+size_t ss_bin_append(inode_t inode, fsize_t *seek_ptr, const void *buf, size_t
+n);
+
+/* Directory functions */
+
+size_t ss_ls(inode_t inode, struct dirent *buf, uint8_t all);
+
+size_t ss_find(inode_t inode, struct dirent *buf, const char *name);
+
+int8_t ss_mkdir(inode_t inode, const char *name);
+
+int8_t ss_rmdir(inode_t inode, const char *name);
+
+int8_t ss_touch(inode_t inode, const char *name);
+
+int8_t ss_rm(inode_t inode, const char *name);
+
+int8_t ss_ln(inode_t, const char *path, const char *name);
+
+#endif // __FDOP_H__
diff --git a/sw/z80/kernel/include/fs/fs.h b/sw/z80/kernel/include/fs/fs.h
index 81c86b7..ad20adb 100644
--- a/sw/z80/kernel/include/fs/fs.h
+++ b/sw/z80/kernel/include/fs/fs.h
@@ -1,5 +1,5 @@
-#ifndef INODE_H
-#define INODE_H
+#ifndef __FS_H__
+#define __FS_H__
 
 #include "types.h"
 
@@ -11,57 +11,53 @@
 
 #define INODE_TYPE_FILE   0x0
 #define INODE_TYPE_DIR    0x1
-#define INODE_TYPE_HLINK    0x2
-#define INODE_TYPE_SLINK    0x3
+#define INODE_TYPE_SLINK    0x2
+#define INODE_TYPE_SPECIAL  0x3
 
-typedef struct time_s
+#define INODE_META_SIZE 8
+
+/* inode basic structure */
+struct fs_inode
 {
-    struct
-    {
-        uint    minutes :6;
-        uint    hour    :5;
+    /* inode meta data */
 
-    } time;
+    uint        mode :3;  // chmod
+    uint        uid :3;   // chown
+    uint        type :2;  // file, dir, sym-link, special
 
-    struct
-    {
-        uint    day     :5;
-        uint    month   :4;
-        uint    year    :12;
+    time_t      ctime;          // creation time
 
-    } date;
+    uint24_t     size;              // inode size
 
-} time_t;
+    /* data storage informations */
+    /* it doesn't allocate memory, virtual size FS_BLOCKS_N */ 
+    blk_t     blocks[];
+};
 
-struct fs_superblock
-{
-    uint8_t     magic;           // identifier
+#define FS_DEV_ROM      0x7f    /* 01111111 */
+#define FS_DEV_NULL     0x80    /* 10000000 */
 
-    uint16_t    blk_size;           // size of a single block
-    uint16_t    imap_size;          // quantity of inodes
-    uint16_t    dmap_size;          // quantity of blocks
-}
+#define FS_ROM_SPACE    0x2000  // second rom 
 
-struct fs_inode
-{
-    
-    /* inode meta data */
-    uint        mode :3;  // chmod
-    uint        uid :3;   // chown
-    uint        type :2;  // file, dir, hard-link, sym-link
+#define FS_INO_ROOT   0x0       // first inode
 
-    time_t      ctime;  // creation time
+#define FS_INODE_ROOT(inode)   {inode.dev = 0xff; inode.inode = 0x0}
+#define FS_INODE_NULL(inode)   {inode.dev = 0x80; inode.inode = 0x0}
 
-    /* data storage informations */
-    uint16_t     size;
-    uint16_t     blocks[FS_BLOCKS_N];
+#define FS_USE_ROM(inode)   {inode.dev == 0x7f}
 
-}
+/* get block seek in current device */
+devsize_t fs_block(blk_t block);
 
-struct fs_inumber
-{
-    uint    dev : 4;    // device id, global in the fs
-    ino_t   rel;    // inode id relative to the volume
-}
+/* get common inode seek in current device */
+/* c_inode must be set first */
+/* returns seek at the beginning of blocks field */
+devsize_t fs_inode(struct fs_inode *buf);
+
+/* common inode for syscalls */
+extern inode_t c_inode;
+
+/* parse a path, absolute or relative to c_inode */
+inode_t fs_parse_path(const char *path);
 
-#endif
+#endif  // __FS_H__
diff --git a/sw/z80/kernel/include/fs/iter.h b/sw/z80/kernel/include/fs/iter.h
new file mode 100644
index 0000000..41f011d
--- /dev/null
+++ b/sw/z80/kernel/include/fs/iter.h
@@ -0,0 +1,17 @@
+#ifndef __ITER_H__
+#define __ITER_H__
+
+struct inode_iter
+{
+    devsize_t   dev_seek;       /* seek position in the volume */
+    devsize_t   blk_end;        /* end of the block */
+
+    int16_t     blk_index;      /* index of the block */
+
+    int8_t      blk_level;      /* recursion level, indirect blocks */
+    
+    fsize_t     fseek;          /* virtual seek in the file */
+    fsize_t     size;           /* file size */
+};
+
+#endif  // __ITER_H__
diff --git a/sw/z80/kernel/include/fs/mount.h b/sw/z80/kernel/include/fs/mount.h
deleted file mode 100644
index a0edd5d..0000000
--- a/sw/z80/kernel/include/fs/mount.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef MOUNT_H
-#define MOUNT_H
-
-#include "fs.h"
-
-#define FS_MOUNT_LIMIT 16
-
-struct fs_mount_point
-{
-    struct fs_inumber       inode;          // dir mounted
-    uint                    serial_port :4;
-    struct fs_superblock    superblock;     // block informations
-}
-
-#endif
diff --git a/sw/z80/kernel/include/fs/users.h b/sw/z80/kernel/include/fs/users.h
index 7e4016b..83980e5 100644
--- a/sw/z80/kernel/include/fs/users.h
+++ b/sw/z80/kernel/include/fs/users.h
@@ -1,6 +1,21 @@
 #ifndef USERS_H
 #define USERS_H
 
+#include "types.h"
 
+#define USERS_MAX   8
+#define USER_ROOT   0 
+
+/* current user in use */
+extern struct fs_user c_user;
+
+struct fs_user
+{
+    char        name[32];
+    ino_t       home;
+    uint8_t     perm;       // TODO, permissions 
+};
+
+/* all users are in rom device */
 
 #endif
diff --git a/sw/z80/kernel/include/sio.h b/sw/z80/kernel/include/sio.h
index 9dc47f6..276b99c 100644
--- a/sw/z80/kernel/include/sio.h
+++ b/sw/z80/kernel/include/sio.h
@@ -1,10 +1,9 @@
-#ifndef SIO_H
-#define SIO_H
+#ifndef __SIO_H__
+#define __SIO_H__
 
 #include "types.h"
 
-#define SIO_ROM 0x0
-
+#define SIO_PORT_0 0x0
 #define SIO_PORT_1 0x1
 #define SIO_PORT_2 0x2
 #define SIO_PORT_3 0x3
@@ -13,37 +12,32 @@
 #define SIO_PORT_6 0x6
 #define SIO_PORT_7 0x7
 
-/* initialize serial interface */
-void sio_init();
+/* current port in use */
+extern uint8_t      sio_port;
 
-/* return the device address in the address space */
-void * sio_dev_addr(uint8_t dev);
-/* return the driver id to be used on dev */
-uint8_t sio_dev_driver(uint8_t dev);
+/* current seek in the device */
+extern devsize_t    sio_seek;
 
-/* set current device in use */
-void sio_set_dev(uint8_t dev);
-/* get current device in use */
-uint8_t sio_cdev();
+struct dev_buffer
+{
+   // TODO, bytes needed to the device buffer interface
+};
 
-/* get pointer in given device */
-uint16_t sio_tellg(uint8_t dev);
-/* get pointer in current device */
-uint16_t sio_ctellg();
+/* points to the buffers mapped in the I/O space */
+/* to be defined precisely in assembly */
+extern volatile struct dev_buffer sio_buffers[8];
 
-/* set pointer in given device */
-int sio_seekg(uint8_t dev, uint16_t value);
-/* set pointer in current device */
-int sio_seekg(uint16_t value);
+/* initialize serial interface */
+void sio_init();
 
 /* syscall: read one byte from the current device */
 uint8_t sio_recv();
 /* syscall: write one byte into the current device */
 void sio_send(uint8_t value);
 
-/* read n bytes from the current device */
-char * sio_read(uint8_t *buffer, size_t n);
-/* write n bytes into the current device */
-int sio_write(const uint8_t *buffer, size_t n);
+/* read n bytes from the current port */
+size_t sio_read(void *buffer, size_t n);
+/* write n bytes into the current port */
+int8_t sio_write(const void *buffer, size_t n);
 
-#endif
+#endif  // __SIO_H__
diff --git a/sw/z80/kernel/include/stat.h b/sw/z80/kernel/include/stat.h
new file mode 100644
index 0000000..44c0f63
--- /dev/null
+++ b/sw/z80/kernel/include/stat.h
@@ -0,0 +1,24 @@
+#ifndef __STAT_H__
+#define __STAT_H__
+
+#include "types.h"
+
+struct stat
+{
+    inode_t     inode;      /* inode reference */
+
+    uint        mode :3;    /* mode */
+    uint        uid :3;     /* owner id */
+    uint        type :2;    /* file, dir or link */
+
+    devsize_t   size;       /* file size */
+
+    size_t      blk_size;   /* single block size */
+    size_t      blk_used;   /* blocks used by the file */
+
+    time_t      ctime;      /* creation time */
+}
+
+struct stat * stat(const char *path, struct stat *buffer);
+
+#endif  // __STAT_H__
diff --git a/sw/z80/kernel/include/types.h b/sw/z80/kernel/include/types.h
index 7f38abb..c6e620b 100644
--- a/sw/z80/kernel/include/types.h
+++ b/sw/z80/kernel/include/types.h
@@ -3,17 +3,60 @@
 
 /* only types from primitive types are defined in this file */ 
 
-#define register_t  volatile unsigned char
+typedef volatile unsigned char      register_t;
 
-#define uint 		unsigned int
+typedef unsigned int                uint;
 
-#define int8_t      char
-#define uint8_t     unsigned char
-#define int16_t     int
-#define uint16_t    unsigned int
+typedef char                        int8_t;
+typedef unsigned char               uint8_t;
+typedef int                         int16_t;
+typedef unsigned int                uint16_t;
+typedef long int                    int32_t;
+typedef unsigned long int           uint32_t;
 
-#define size_t      uint16_t
-#define pid_t 		uint8_t
-#define ino_t       uint16_t
+typedef uint16_t                    size_t;
+typedef int16_t                     ssize_t;
+
+typedef uint8_t                     pid_t;
+typedef uint16_t                    ino_t;
+
+typedef uint8_t                     dev_t;
+typedef uint32_t                    devsize_t;
+typedef uint8_t                     fd_t;
+typedef uint16_t                    blk_t;
+typedef uint8_t                     user_t;
+
+typedef struct {
+    uint8_t member[3];
+
+} uint24_t;
+
+typedef uint32_t                    fsize_t;
+
+typedef struct 
+{
+    dev_t   dev;    // device id, global in the fs
+    ino_t   inode;    // inode id relative to the volume
+
+} inode_t;
+
+typedef struct time_s
+{
+    struct
+    {
+        uint    minutes :6;
+        uint    hour    :5;
+
+    } time;
+
+    struct
+    {
+        uint    day     :5;
+        uint    month   :4;
+        uint    year    :12;
+
+    } date;
+
+} time_t;
 
 #endif
diff --git a/sw/z80/kernel/memory.c b/sw/z80/kernel/memory.c
index cfbcb81..cda62ca 100644
--- a/sw/z80/kernel/memory.c
+++ b/sw/z80/kernel/memory.c
@@ -61,3 +61,32 @@ int page_unmap(int page)
     pages_table[page].addr = 0;
     return 0;
 }
+
+/* k_malloc manager */
+/*
+struct k_buf_entry k_buf_table[K_BUF_MAX_COUNT];
+
+struct k_buf k_buffers[K_BUF_MAX_COUNT];
+
+void * k_malloc()
+{
+    for (uint8_t i = 0; i < K_BUF_TABLE_COUNT; i++)
+    {
+        for (uint8_t bit = 0x80, j = 0; j < 8; bit >>= 1, j++)
+        {
+            if (bit & k_buf_table[i])
+            {
+                k_buf_table[i] |= bit;
+                return &k_buffers[8 * i + j];
+            }
+        }
+    }
+}
+
+void k_free(void * ptr)
+{
+    uint8_t index = (ptr - &k_buffers[0]) / K_BUF_SIZE;
+
+    if (index < K_BUF_MAX_COUNT)
+        k_buf_table[index / 8] ^= 0x80 >> index % 8;
+}*/