[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[tyndur-devel] [PATCH 6/6] libc: LIOv2-Clientunterstützung



+ libc: Die stdio-Funktionen können jetzt sowohl mit LIOv1- als auch
  LIOv2-Dateien umgehen. Ein gegen diese libc-Version gebautes Programm
  kann also unter einem LIOv2-fähigen Kernel auf alle Dateien zugreifen.
  Mit dem aktuellen Kernel bleibt die Erweiterung wirkungslos, auf
  älteren Kerneln wird das Programm mit einem unbekannten Syscall
  abstürzen.

Signed-off-by: Kevin Wolf <kevin@xxxxxxxxxx>
---
 src/include/syscall_structs.h        |   45 ++++++++++++++
 src/modules/include/dir.h            |    4 +
 src/modules/include/io_struct.h      |    3 +
 src/modules/include/lostio.h         |   11 +++-
 src/modules/lib/lostio/client/file.c |  103 +++++++++++++++++++++++++++++++-
 src/modules/lib/lostio/client/seek.c |   19 ++++++
 src/modules/lib/stdlibc/directory.c  |  112 +++++++++++++++++++++++++++++++++-
 src/modules/lib/stdlibc/file.c       |   36 +++++++++--
 8 files changed, 323 insertions(+), 10 deletions(-)

diff --git a/src/include/syscall_structs.h b/src/include/syscall_structs.h
index c23d39e..3b129dc 100644
--- a/src/include/syscall_structs.h
+++ b/src/include/syscall_structs.h
@@ -83,6 +83,51 @@ typedef int64_t lio_usp_stream_t;
 typedef int64_t lio_usp_resource_t;
 
 /**
+ * Beschreibt als Bitmaske den Modus, in dem ein Stream arbeiten soll.
+ */
+enum lio_flags {
+    /**
+     * Die Ressource soll beim Öffnen auf Größe 0 gekürzt werden. Nur
+     * gültig, wenn die Datei auch zum Schreiben geöffnet wird.
+     */
+    LIO_TRUNC       =   1,
+
+    /** Die Ressource soll zum Lesen geöffnet werden */
+    LIO_READ        =   2,
+
+    /** Die Ressource soll zum Schreiben geöffnet werden */
+    LIO_WRITE       =   4,
+
+    /**
+     * Die Ressource soll im Writethrough-Modus geöffnet werden, d.h. alle
+     * Änderungen werden sofort persistent gemacht.
+     */
+    /* TODO LIO_WRTHROUGH   =  32, */
+
+    /** Der Cache soll nicht benutzt werden */
+    /* TODO LIO_NOCACHE     =  64, */
+
+    /**
+     * Wenn auf die Ressource geschrieben oder von ihr gelesen werden soll, sie
+     * aber nicht bereit ist, soll die Anfrage blockieren anstatt einen Fehler
+     * zurückzugeben.
+     *
+     * TODO Short Reads/Writes möglich?
+     */
+    /* TODO LIO_BLOCKING    = 128, */
+
+    /**
+     * Der Inhalt der Ressource ist nicht reproduzierbar (z.B. Netzwerk).
+     * Er muss im Cache behalten werden, solange er benutzt wird.
+     */
+    /* TODO LIO_VOLATILE    = 256, */
+
+    /** Symlinks nicht folgen, sondern den Link selbst öffnen */
+    LIO_SYMLINK     = 512,
+};
+
+
+/**
  * Gibt an, realtiv zu welcher Position in der Datei das lio_seek-Offset
  * zu interpretieren ist.
  */
diff --git a/src/modules/include/dir.h b/src/modules/include/dir.h
index 3056c0d..4fbf63a 100644
--- a/src/modules/include/dir.h
+++ b/src/modules/include/dir.h
@@ -31,9 +31,13 @@
 #include "types.h"
 #include "stdio.h"
 #include "io.h"
+#include <dirent.h>
 
 struct dir_handle {
+    bool old;
     io_resource_t* lio1_handle;
+    lio_resource_t new_res;
+    size_t offset;
 };
 
 struct dir_handle* directory_open(const char* dirname);
diff --git a/src/modules/include/io_struct.h b/src/modules/include/io_struct.h
index 665ab38..e2500a2 100644
--- a/src/modules/include/io_struct.h
+++ b/src/modules/include/io_struct.h
@@ -29,6 +29,7 @@
 #define _IO_STRUCT_H_
 #include <stdint.h>
 #include <sys/types.h>
+#include <syscall.h>
 
 #define MAX_FILENAME_LEN 255
 #define IO_DIRENTRY_FILE 1
@@ -52,6 +53,8 @@ typedef struct
     pid_t               pid;
     io_resource_id_t    resid;
 
+    lio_stream_t        lio2_stream;
+    lio_resource_t      lio2_res;
 } __attribute__ ((packed)) io_resource_t;
 #endif //ifndef _IO_STRUCT_H_
 
diff --git a/src/modules/include/lostio.h b/src/modules/include/lostio.h
index 5aa580c..9e5a73c 100644
--- a/src/modules/include/lostio.h
+++ b/src/modules/include/lostio.h
@@ -130,8 +130,17 @@ struct lostio_internal_file {
     size_t          buffer_pos;
     uint8_t         buffer_mode;
     bool            free_buffer;
-};
 
+    /*
+     * Achtung: os_eof ist _nicht_ der EOF-Marker aus der C-Spezifikation, der
+     * erst gesetzt wird, wenn das Programm aus dem Puffer das letzte Byte
+     * einliest, sondern das EOF, auf das beim Einlesen des Puffers gestoßen
+     * wurde!
+     */
+    bool            os_eof;
+    bool            error;
+};
+#define IS_LIO2(h) (h->lio2_res > 0)
 
 ///LostIO-Schnittstelle initialisieren
 void lostio_init(void);
diff --git a/src/modules/lib/lostio/client/file.c b/src/modules/lib/lostio/client/file.c
index 142de7d..5b3e68b 100644
--- a/src/modules/lib/lostio/client/file.c
+++ b/src/modules/lib/lostio/client/file.c
@@ -32,6 +32,7 @@
 #include <stdlib.h>
 #include <rpc.h>
 #include <syscall.h>
+#include <errno.h>
 
 static void* shm_ptr;
 static uint32_t shm_id;
@@ -54,11 +55,85 @@ static void* get_shm(size_t size)
     return shm_ptr;
 }
 
+static io_resource_t* lio2_open(const char* filename, uint8_t attr)
+{
+    char* full_path;
+    uint8_t lio2_attr = 0;
+    bool m_append = false;
+    bool m_create = false;
+
+    lio_stream_t s;
+    lio_resource_t r;
+    io_resource_t* result = NULL;
+
+    full_path = io_get_absolute_path(filename);
+    if (!full_path) {
+        return NULL;
+    }
+
+    /* Modus auswerten */
+    if (attr & ~(IO_OPEN_MODE_READ | IO_OPEN_MODE_WRITE | IO_OPEN_MODE_CREATE
+        | IO_OPEN_MODE_TRUNC | IO_OPEN_MODE_APPEND))
+    {
+        return NULL;
+    }
+
+    if (attr & IO_OPEN_MODE_READ)   lio2_attr |= LIO_READ;
+    if (attr & IO_OPEN_MODE_WRITE)  lio2_attr |= LIO_WRITE;
+    if (attr & IO_OPEN_MODE_CREATE) m_create = true;
+    if (attr & IO_OPEN_MODE_TRUNC)  lio2_attr  |= LIO_TRUNC;
+    if (attr & IO_OPEN_MODE_APPEND) m_append = true;
+
+    /* Datei erzeugen, falls nötig */
+    r = lio_resource(full_path, 1);
+    if ((r < 0) && m_create) {
+        lio_resource_t parent;
+        char* dirname = io_split_dirname(full_path);
+        char* filename = io_split_filename(full_path);
+        if ((parent = lio_resource(dirname, 1)) > 0) {
+            r = lio_mkfile(parent, filename);
+
+        }
+        free(dirname);
+        free(filename);
+    }
+
+    if (r < 0) {
+        goto out_err;
+    }
+
+    /* Datei öffnen */
+    if ((s = lio_open(r, lio2_attr)) < 0) {
+        goto out_err;
+    }
+
+    if (m_append) {
+        // FIXME lio_seek();
+    }
+
+    /* Datenstruktur anlegen */
+    result = malloc(sizeof(*result));
+    *result = (io_resource_t) {
+        .lio2_stream    =   s,
+        .lio2_res       =   r,
+    };
+
+out_err:
+    free(full_path);
+    return result;
+}
+
 io_resource_t* lio_compat_open(const char* filename, uint8_t attr)
 {
-    char* full_path = io_get_absolute_path(filename);
+    char* full_path;
     io_resource_t* result;
 
+    result = lio2_open(filename, attr);
+    if (result) {
+        return result;
+    }
+
+    full_path = io_get_absolute_path(filename);
     if (!full_path) {
         return NULL;
     }
@@ -88,9 +163,27 @@ out:
     return result;
 }
 
+static int lio2_fclose(io_resource_t* stream)
+{
+    int result = 0;
+
+    if (stream->lio2_stream > 0) {
+        result = lio_close(stream->lio2_stream);
+    }
+    free(stream);
+
+    return result;
+}
+
+
 int lio_compat_close(io_resource_t* io_res)
 {
     uint32_t result;
+
+    if (IS_LIO2(io_res)) {
+        return lio2_fclose(io_res);
+    }
+
     result = rpc_get_dword(io_res->pid, "IO_CLOSE",
         sizeof(io_resource_id_t), (char*) &(io_res->id));
     free(io_res);
@@ -114,6 +207,10 @@ ssize_t lio_compat_read(void* dest, size_t blocksize, size_t blockcount,
         .blockcount = blockcount,
     };
 
+    if (IS_LIO2(io_res)) {
+        return lio_read(io_res->lio2_stream, blocksize * blockcount, dest);
+    }
+
     // Wenn mehr als 256 Bytes gelesen werden sollen, wird SHM benutzt
     if ((blocksize * blockcount) > 256) {
 
@@ -170,6 +267,10 @@ ssize_t lio_compat_write(const void* src, size_t blocksize, size_t blockcount,
     size_t data_size = blockcount * blocksize;
     size_t request_size = sizeof(io_write_request_t);
 
+    if (IS_LIO2(io_res)) {
+        return lio_write(io_res->lio2_stream, blocksize * blockcount, src);
+    }
+
     // Bei mehr als einem Kilobyte wird shared memory fuer die Daten benutzt
     if (data_size < 1024) {
         request_size += data_size;
diff --git a/src/modules/lib/lostio/client/seek.c b/src/modules/lib/lostio/client/seek.c
index 8564486..2ad7a84 100644
--- a/src/modules/lib/lostio/client/seek.c
+++ b/src/modules/lib/lostio/client/seek.c
@@ -30,6 +30,20 @@
 #include <stdio.h>
 #include <rpc.h>
 #include <stdint.h>
+#include <stdio.h>
+static bool newlio_flseek(io_resource_t* io_res, uint64_t offset, int origin)
+{
+    int whence;
+
+    switch (origin) {
+        case SEEK_SET: whence = LIO_SEEK_SET; break;
+        case SEEK_CUR: whence = LIO_SEEK_CUR; break;
+        case SEEK_END: whence = LIO_SEEK_END; break;
+        default: return false;
+    }
+
+    return lio_seek(io_res->lio2_stream, offset, whence) >= 0;
+}
 
 /**
  * Cursorposition im Dateihandle setzen
@@ -47,6 +61,11 @@ bool lio_compat_seek(io_resource_t* io_res, uint64_t offset, int origin)
 {
     io_seek_request_t seek_request;
 
+
+    if (IS_LIO2(io_res)) {
+        return newlio_flseek(io_res, offset, origin);
+    }
+
     seek_request.id = io_res->id;
     seek_request.offset = offset;
     seek_request.origin = origin;
diff --git a/src/modules/lib/stdlibc/directory.c b/src/modules/lib/stdlibc/directory.c
index 216df40..f2156d4 100644
--- a/src/modules/lib/stdlibc/directory.c
+++ b/src/modules/lib/stdlibc/directory.c
@@ -32,27 +32,67 @@
 #include "stdlib.h"
 #include "dir.h"
 #include <string.h>
+#include <lostio.h>
+
+static struct dir_handle* new_opendir(const char* path)
+{
+    struct dir_handle* handle;
+    lio_resource_t res;
+    char* abspath = io_get_absolute_path(path);
+
+    res = lio_resource(abspath, 1);
+    if (res < 0) {
+        return NULL;
+    }
+
+    /* Prüfen, ob es auch wirklich ein Verzeicnis ist */
+    if (lio_read_dir(res, 0, 0, NULL) != 0) {
+        return NULL;
+    }
+
+    handle = malloc(sizeof(*handle));
+    handle->old = false;
+    handle->new_res = res;
+    handle->offset = 0;
+
+    return handle;
+}
 
 struct dir_handle* directory_open(const char* path)
 {
     struct dir_handle* handle;
     io_resource_t* io_res;
 
+    handle = new_opendir(path);
+    if (handle) {
+        return handle;
+    }
+
     io_res = lio_compat_open(path, IO_OPEN_MODE_READ | IO_OPEN_MODE_DIRECTORY);
     if (io_res == NULL) {
         return NULL;
     }
 
     handle = malloc(sizeof(*handle));
+    handle->old = true;
     handle->lio1_handle = io_res;
 
     return handle;
 }
 
+static int new_closedir(struct dir_handle* handle)
+{
+    free(handle);
+    return 0;
+}
 int directory_close(struct dir_handle* handle)
 {
     int result = 0;
 
+    if (!handle->old) {
+        return new_closedir(handle);
+    }
+
     if (lio_compat_close(handle->lio1_handle)) {
         result = -1;
     }
@@ -61,10 +101,35 @@ int directory_close(struct dir_handle* handle)
     return result;
 }
 
+static io_direntry_t* new_directory_read(struct dir_handle* handle)
+{
+    io_direntry_t* ent = NULL;
+    struct lio_dir_entry lent;
+
+    if (lio_read_dir(handle->new_res, handle->offset, 1, &lent) == 1) {
+        ent = calloc(sizeof(*ent), 1);
+        strcpy(ent->name, lent.name);
+        ent->type =
+            (((lent.stat.flags & LIO_FLAG_READABLE) |
+                (lent.stat.flags & LIO_FLAG_WRITABLE)) ? IO_DIRENTRY_FILE : 0)|
+            ((lent.stat.flags & LIO_FLAG_BROWSABLE) ? IO_DIRENTRY_DIR : 0) |
+            ((lent.stat.flags & LIO_FLAG_RESOLVABLE) ? IO_DIRENTRY_LINK : 0);
+        ent->size = lent.stat.size;
+
+        handle->offset++;
+    }
+
+    return ent;
+}
+
 io_direntry_t* directory_read(struct dir_handle* io_res)
 {
     int ret;
 
+    if (!io_res->old) {
+        return new_directory_read(io_res);
+    }
+
     if ((io_res == NULL) || (lio_compat_eof(io_res->lio1_handle) != 0)) {
         return NULL;
     }
@@ -82,10 +147,29 @@ io_direntry_t* directory_read(struct dir_handle* io_res)
 
 int directory_seek(struct dir_handle* handle, long int offset, int origin)
 {
+    /* TODO LIOv2-Variante */
     return lio_compat_seek(handle->lio1_handle, offset, origin);
 }
 
-bool directory_create(const char* dirname)
+static bool new_directory_create(const char* path)
+{
+    char* abs = io_get_absolute_path(path);
+    char* dir = io_split_dirname(abs);
+    char* file = io_split_filename(abs);
+    bool result = false;
+    lio_resource_t parent;
+
+    printf("new_directory(%s) dir='%s' file='%s'\n", path, dir, file);
+    if ((parent = lio_resource(dir, 1)) >= 0) {
+        result = (lio_mkdir(parent, file) >= 0);
+    }
+
+    free(dir);
+    free(file);
+    return result;
+}
+
+static bool old_directory_create(const char* dirname)
 {
     io_resource_t* io_res = lio_compat_open(dirname,
         IO_OPEN_MODE_WRITE | IO_OPEN_MODE_CREATE | IO_OPEN_MODE_TRUNC |
@@ -99,9 +183,25 @@ bool directory_create(const char* dirname)
     return true;
 }
 
-bool is_directory(const char* dirname)
+bool directory_create(const char* dirname)
+{
+    return new_directory_create(dirname) || old_directory_create(dirname);
+}
+
+static bool new_is_directory(const char* path)
 {
-    struct dir_handle* dir = directory_open(dirname);
+    lio_resource_t res = lio_resource(path, 1);
+
+    if (res < 0) {
+        return false;
+    }
+
+    return (lio_read_dir(res, 0, 0, NULL) == 0);
+}
+
+static bool old_is_directory(const char* path)
+{
+    struct dir_handle* dir = directory_open(path);
     if (dir != NULL) {
         directory_close(dir);
         return true;
@@ -109,3 +209,9 @@ bool is_directory(const char* dirname)
         return false;
     }
 }
+
+bool is_directory(const char* dirname)
+{
+    return new_is_directory(dirname) || old_is_directory(dirname);
+}
+
diff --git a/src/modules/lib/stdlibc/file.c b/src/modules/lib/stdlibc/file.c
index f540bc7..3c3a09c 100644
--- a/src/modules/lib/stdlibc/file.c
+++ b/src/modules/lib/stdlibc/file.c
@@ -35,6 +35,7 @@
 #include <unistd.h>
 #include <stdint.h>
 #include <syscall.h>
+#include <errno.h>
 
 #define IO_BUFFER_MODE_NONE 0
 #define IO_BUFFER_MODE_FULL 1
@@ -42,9 +43,11 @@
 
 extern char* io_get_absolute_path(const char* path);
 
+#define IS_LIO2_FILE(f) IS_LIO2(f->res)
+
 static bool is_valid_res(FILE* io_res)
 {
-    return (io_res != NULL) && (io_res->res->pid != 0);
+    return (io_res != NULL) && (IS_LIO2(io_res->res) || io_res->res->pid != 0);
 }
 
 /**
@@ -112,6 +115,9 @@ FILE* fopen (const char* filename, const char* mode)
     setvbuf(int_res, malloc(BUFSIZ), _IOFBF, BUFSIZ);
     int_res->free_buffer = true;
 
+    int_res->error = false;
+    int_res->os_eof = false;
+
     return int_res;
 }
 
@@ -222,8 +228,14 @@ size_t fread(void* dest, size_t blocksize, size_t blockcount, FILE* io_res)
 
     ret = lio_compat_read(dest + read_bytes,
         (blocksize * blockcount) - read_bytes, 1, io_res->res);
-    if (ret < 0) {
+
+    if (ret == -EAGAIN) {
+        return 0;
+    } else if (ret < 0) {
+        io_res->error = true;
         return 0;
+    } else if (!ret) {
+        io_res->os_eof = true;
     }
 
     return (read_bytes + ret) / blocksize;
@@ -367,6 +379,7 @@ size_t fwrite(const void* data, size_t blocksize, size_t blockcount,
         case IO_BUFFER_MODE_NONE:
             ret = lio_compat_write(data, blocksize, blockcount, io_res->res);
             if (ret < 0) {
+                io_res->error = true;
                 return 0;
             } else {
                 return ret / blocksize;
@@ -389,6 +402,7 @@ size_t fwrite(const void* data, size_t blocksize, size_t blockcount,
                 }
                 ret = lio_compat_write(data, blocksize, blockcount, io_res->res);
                 if (ret < 0) {
+                    io_res->error = true;
                     return 0;
                 } else {
                     return ret / blocksize;
@@ -409,6 +423,7 @@ size_t fwrite(const void* data, size_t blocksize, size_t blockcount,
                 }
                 ret = lio_compat_write(data, blocksize, blockcount, io_res->res);
                 if (ret < 0) {
+                    io_res->error = true;
                     return 0;
                 } else {
                     return ret / blocksize;
@@ -509,6 +524,11 @@ long ftell(FILE* io_res)
         return EOF;
     }
 
+    if (IS_LIO2_FILE(io_res)) {
+        int64_t pos = lio_seek(io_res->res->lio2_stream, 0, LIO_SEEK_CUR);
+        return (pos < 0 ? -1 : pos);
+    }
+
     io_tell_request_t tell_request;
     long result;
     tell_request.id = io_res->res->id;
@@ -549,6 +569,12 @@ int feof(FILE* io_res)
         return 0;
     }
 
+    if (IS_LIO2_FILE(io_res)) {
+        // FIXME: EOF ist hier eigentlich doof, aber irgend ein Idiot hat das
+        // mal so implementiert und das wird teilweise so geprüft... ;-)
+        return (io_res->os_eof ? EOF : 0);
+    }
+
     //Auch hier könnte mit Daten im Buffer ein falsches Ergebnis rauskommen
     fflush(io_res);
 
@@ -566,8 +592,7 @@ int feof(FILE* io_res)
  */
 int ferror(FILE* io_res)
 {
-    //FIXME
-    return 0;
+    return io_res->error;
 }
 
 
@@ -578,7 +603,8 @@ int ferror(FILE* io_res)
  */
 void clearerr(FILE* io_res)
 {
-    // TODO
+    io_res->error = false;
+    io_res->os_eof = false;
 }
 
 
-- 
1.6.0.2