From kevin at tyndur.org Thu Jan 1 18:17:27 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Thu, 1 Jan 2015 18:17:27 +0100 Subject: [tyndur-devel] [PATCH] libc: alloca() nur definieren wenn es fehlt Message-ID: <1420132647-7056-1-git-send-email-kevin@tyndur.org> ! libc: Wenn alloca() schon definiert ist, definieren wir es kein zweites Mal. Das fixt den binutils-Build. Signed-off-by: Kevin Wolf --- src/include/alloca.h | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-) diff --git a/src/include/alloca.h b/src/include/alloca.h index 1cafe0a..de835a5 100644 --- a/src/include/alloca.h +++ b/src/include/alloca.h @@ -29,6 +29,8 @@ #ifndef _ALLOCA_H_ #define _ALLOCA_H_ +#ifndef alloca #define alloca(n) __builtin_alloca(n) +#endif #endif -- 1.7.7 From littlefox at fsfe.org Fri Jan 9 23:14:43 2015 From: littlefox at fsfe.org (Moritz Grosch (LittleFox)) Date: Fri, 9 Jan 2015 23:14:43 +0100 Subject: [tyndur-devel] [PATCH 1/2] Copy all the Grub2 Modules! Message-ID: <1420841684-12180-1-git-send-email-littlefox@fsfe.org> From: "Moritz Grosch (LittleFox)" The old module-list seems to be outdated and didn't work. Harddisks aren't expensive anymore, so copy everything. --- build/scripts/image_hd_grub2 | 35 ++++++++++++++++++++--------------- 1 file changed, 20 insertions(+), 15 deletions(-) diff --git a/build/scripts/image_hd_grub2 b/build/scripts/image_hd_grub2 index cddc78b..3295bca 100755 --- a/build/scripts/image_hd_grub2 +++ b/build/scripts/image_hd_grub2 @@ -111,23 +111,28 @@ fi convert_menu_lst $MOUNT/boot/grub/grub.cfg + + # Grub kopieren if [ $NEW -ne 0 ]; then - xargs -isrc cp src $MOUNT/boot/grub <<-EOF - $LOST_GRUB2_MODULESDIR/boot.mod - $LOST_GRUB2_MODULESDIR/cat.mod - $LOST_GRUB2_MODULESDIR/configfile.mod - $LOST_GRUB2_MODULESDIR/crypto.mod - $LOST_GRUB2_MODULESDIR/extcmd.mod - $LOST_GRUB2_MODULESDIR/gzio.mod - $LOST_GRUB2_MODULESDIR/ls.mod - $LOST_GRUB2_MODULESDIR/mmap.mod - $LOST_GRUB2_MODULESDIR/multiboot.mod - $LOST_GRUB2_MODULESDIR/normal.mod - $LOST_GRUB2_MODULESDIR/relocator.mod - $LOST_GRUB2_MODULESDIR/terminal.mod - $LOST_GRUB2_MODULESDIR/video.mod -EOF + +cp $LOST_GRUB2_MODULESDIR/* $MOUNT/boot/grub/ + +# xargs -isrc cp src $MOUNT/boot/grub <<-EOF +# $LOST_GRUB2_MODULESDIR/boot.mod +# $LOST_GRUB2_MODULESDIR/cat.mod +# $LOST_GRUB2_MODULESDIR/configfile.mod +# $LOST_GRUB2_MODULESDIR/crypto.mod +# $LOST_GRUB2_MODULESDIR/extcmd.mod +# $LOST_GRUB2_MODULESDIR/gzio.mod +# $LOST_GRUB2_MODULESDIR/ls.mod +# $LOST_GRUB2_MODULESDIR/mmap.mod +# $LOST_GRUB2_MODULESDIR/multiboot.mod +# $LOST_GRUB2_MODULESDIR/normal.mod +# $LOST_GRUB2_MODULESDIR/relocator.mod +# $LOST_GRUB2_MODULESDIR/terminal.mod +# $LOST_GRUB2_MODULESDIR/video.mod +#EOF fi # Partition unmounten und loopback-Device freigeben -- 1.7.10.4 From littlefox at fsfe.org Fri Jan 9 23:14:44 2015 From: littlefox at fsfe.org (Moritz Grosch (LittleFox)) Date: Fri, 9 Jan 2015 23:14:44 +0100 Subject: [tyndur-devel] [PATCH 2/2] Removed commented code and copy only modules In-Reply-To: <1420841684-12180-1-git-send-email-littlefox@fsfe.org> References: <1420841684-12180-1-git-send-email-littlefox@fsfe.org> Message-ID: <1420841684-12180-2-git-send-email-littlefox@fsfe.org> From: "Moritz Grosch (LittleFox)" --- build/scripts/image_hd_grub2 | 19 +------------------ 1 file changed, 1 insertion(+), 18 deletions(-) diff --git a/build/scripts/image_hd_grub2 b/build/scripts/image_hd_grub2 index 3295bca..3d33611 100755 --- a/build/scripts/image_hd_grub2 +++ b/build/scripts/image_hd_grub2 @@ -115,24 +115,7 @@ convert_menu_lst $MOUNT/boot/grub/grub.cfg # Grub kopieren if [ $NEW -ne 0 ]; then - -cp $LOST_GRUB2_MODULESDIR/* $MOUNT/boot/grub/ - -# xargs -isrc cp src $MOUNT/boot/grub <<-EOF -# $LOST_GRUB2_MODULESDIR/boot.mod -# $LOST_GRUB2_MODULESDIR/cat.mod -# $LOST_GRUB2_MODULESDIR/configfile.mod -# $LOST_GRUB2_MODULESDIR/crypto.mod -# $LOST_GRUB2_MODULESDIR/extcmd.mod -# $LOST_GRUB2_MODULESDIR/gzio.mod -# $LOST_GRUB2_MODULESDIR/ls.mod -# $LOST_GRUB2_MODULESDIR/mmap.mod -# $LOST_GRUB2_MODULESDIR/multiboot.mod -# $LOST_GRUB2_MODULESDIR/normal.mod -# $LOST_GRUB2_MODULESDIR/relocator.mod -# $LOST_GRUB2_MODULESDIR/terminal.mod -# $LOST_GRUB2_MODULESDIR/video.mod -#EOF +cp $LOST_GRUB2_MODULESDIR/*.mod $MOUNT/boot/grub/ fi # Partition unmounten und loopback-Device freigeben -- 1.7.10.4 From kevin at tyndur.org Sun Jan 11 15:23:39 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 11 Jan 2015 15:23:39 +0100 Subject: [tyndur-devel] [PATCH 1/4] cdi/cache: Fehlerpfad gefixt In-Reply-To: <1420986222-23055-1-git-send-email-kevin@tyndur.org> References: <1420986222-23055-1-git-send-email-kevin@tyndur.org> Message-ID: <1420986222-23055-2-git-send-email-kevin@tyndur.org> ! cdi/cache: Wenn das Laden eines Cacheblocks fehlgeschlagen ist, gibt unsere CDI-Implementierung ihn wieder frei. Das ist schön, aber dann sollte man auch darauf achten, dass keine Dangling Pointers übrigbleiben. Signed-off-by: Kevin Wolf --- src/modules/cdi/lib/cache.c | 46 +++++++++++++++++++++++++++++++-------------- 1 file changed, 32 insertions(+), 14 deletions(-) diff --git a/src/modules/cdi/lib/cache.c b/src/modules/cdi/lib/cache.c index 17b88c9..af8ed4e 100644 --- a/src/modules/cdi/lib/cache.c +++ b/src/modules/cdi/lib/cache.c @@ -328,6 +328,22 @@ static inline struct block* get_hint(struct cache* cache, uint64_t block) } /** + * Hint entfernen + * + * @param b Block-Struktur, die für die alte Blocknummer ungültig wurde + */ +static inline void invalidate_hint(struct cache* cache, struct block* b) +{ + int i; + + for (i = 0; i < HINTCNT; i++) { + if (cache->hints[i] == b) { + cache->hints[i] = NULL; + } + } +} + +/** * Hint setzen * * @param block Blocknummer @@ -419,7 +435,6 @@ struct cdi_cache_block* cdi_cache_block_get(struct cdi_cache* cache, } if (!b) { - int in_tree = 0; if (c->blocks_used < c->block_count) { // Wir duerfen noch mehr neue Blocks in den Cache legen b = malloc(sizeof(*b)); @@ -436,8 +451,8 @@ struct cdi_cache_block* cdi_cache_block_get(struct cdi_cache* cache, if (!b) { return NULL; } - in_tree = 1; tree_remove(c->tree, b); + invalidate_hint(c, b); b->cdi.number = blocknum; tree_insert(c->tree, b); } @@ -446,19 +461,22 @@ struct cdi_cache_block* cdi_cache_block_get(struct cdi_cache* cache, if (!noread && !load_block(c, b)) { puts("cdi_cache: Einlesen des Blocks fehlgeschlagen."); - // Wenn der Knoten bis jetzt im Baum war, muss er rausgeworfen - // werden - if (in_tree) { - tree_remove(c->tree, b); - - // Auch aus der LRU-Liste muss der Block ggf. entfernt werden - if (b->lru_next) { - b->lru_next->lru_prev = b->lru_prev; - } - if (b->lru_prev) { - b->lru_prev->lru_next = b->lru_next; - } + tree_remove(c->tree, b); + + if (b->lru_next) { + b->lru_next->lru_prev = b->lru_prev; } + if (b->lru_prev) { + b->lru_prev->lru_next = b->lru_next; + } + if (c->lru_first == b) { + c->lru_first = b->lru_prev; + } + if (c->lru_last == b) { + c->lru_last = b->lru_next; + } + invalidate_hint(c, b); + c->blocks_used--; free(b->cdi.data); -- 2.1.2 From kevin at tyndur.org Sun Jan 11 15:23:38 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 11 Jan 2015 15:23:38 +0100 Subject: [tyndur-devel] [PATCH 0/4] cdi: Schnelleres CD-ROM und Fixes Message-ID: <1420986222-23055-1-git-send-email-kevin@tyndur.org> Cc: cdi-devel at tyndur.org Note for cdi-devel: This is a series for tyndur, with cdi-devel CCed for relevant patches, so you won't see all patches of the series. Kevin Wolf (4): cdi/cache: Fehlerpfad gefixt atapi: Support for transferring more than one sector cdi/scsi: Mehrere Sektoren auf einmal lesen atapi: Fix CDI_SCSI_WRITE src/modules/cdi/ata/atapi.c | 16 ++++++++++---- src/modules/cdi/ata/request.c | 2 +- src/modules/cdi/lib/cache.c | 46 ++++++++++++++++++++++++++++------------- src/modules/cdi/lib/scsi/disk.c | 25 ++++++++++++++-------- 4 files changed, 61 insertions(+), 28 deletions(-) -- 2.1.2 From kevin at tyndur.org Sun Jan 11 15:23:40 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 11 Jan 2015 15:23:40 +0100 Subject: [tyndur-devel] [PATCH 2/4] atapi: Support for transferring more than one sector In-Reply-To: <1420986222-23055-1-git-send-email-kevin@tyndur.org> References: <1420986222-23055-1-git-send-email-kevin@tyndur.org> Message-ID: <1420986222-23055-3-git-send-email-kevin@tyndur.org> This contains not only the modifications to actually split requests by the block size of 2048, but also included a fix to request.c, which used packet_size before it was initialised, so that always only a single block would be transferred. Cc: cdi-devel at tyndur.org Signed-off-by: Kevin Wolf --- src/modules/cdi/ata/atapi.c | 9 +++++++-- src/modules/cdi/ata/request.c | 2 +- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/modules/cdi/ata/atapi.c b/src/modules/cdi/ata/atapi.c index eaac06d..b866551 100644 --- a/src/modules/cdi/ata/atapi.c +++ b/src/modules/cdi/ata/atapi.c @@ -127,13 +127,18 @@ int atapi_request(struct cdi_scsi_device* scsi,struct cdi_scsi_packet* packet) .lba = 1, .ata = 1 }, - .block_count = 1, - .block_size = packet->bufsize, + .block_count = packet->bufsize / 2048, + .block_size = 2048, .blocks_done = 0, .buffer = packet->buffer, .error = 0 }; + if (packet->bufsize < 2048) { + rw_request.block_count = 1; + rw_request.block_size = packet->bufsize; + } + // Lesen bzw. Schreiben der Daten // TODO: DMA if (packet->direction==CDI_SCSI_READ) ata_protocol_pio_in(&rw_request); diff --git a/src/modules/cdi/ata/request.c b/src/modules/cdi/ata/request.c index ff5d479..838f83c 100644 --- a/src/modules/cdi/ata/request.c +++ b/src/modules/cdi/ata/request.c @@ -278,7 +278,7 @@ int ata_protocol_pio_in(struct ata_request* request) // Wenn alle Blocks gelesen wurden ist der Transfer // abgeschlossen. return 1; - } else if (request->flags.ata && + } else if (request->flags.ata && packet_size && request->blocks_done*request->block_size>=packet_size) { // Wenn alle Bytes des ATAPI-Paketes gelesen wurden -- 2.1.2 From kevin at tyndur.org Sun Jan 11 15:23:41 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 11 Jan 2015 15:23:41 +0100 Subject: [tyndur-devel] [PATCH 3/4] cdi/scsi: Mehrere Sektoren auf einmal lesen In-Reply-To: <1420986222-23055-1-git-send-email-kevin@tyndur.org> References: <1420986222-23055-1-git-send-email-kevin@tyndur.org> Message-ID: <1420986222-23055-4-git-send-email-kevin@tyndur.org> * cdi/scsi: Wenn man mehrere Sektoren auf einmal liest statt einen nach dem anderen, dann geht das ein bisschen schneller. Signed-off-by: Kevin Wolf --- src/modules/cdi/lib/scsi/disk.c | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/src/modules/cdi/lib/scsi/disk.c b/src/modules/cdi/lib/scsi/disk.c index 0e2534e..e34b650 100644 --- a/src/modules/cdi/lib/scsi/disk.c +++ b/src/modules/cdi/lib/scsi/disk.c @@ -73,28 +73,31 @@ union cdrom_command } __attribute__ ((packed)) ext; }; -static int cdrom_read_sector( - struct cdi_scsi_device *device, uint32_t sector, char *buffer) +static int cdrom_read_partial( + struct cdi_scsi_device *device, uint32_t sector, uint64_t nb_sectors, + char *buffer) { struct cdi_scsi_packet packet; struct cdi_scsi_driver* drv = (struct cdi_scsi_driver*) device->dev.driver; union cdrom_command* cmd = (union cdrom_command*) &packet.command; + nb_sectors = (uint32_t) nb_sectors; + memset(&packet, 0, sizeof(packet)); packet.direction = CDI_SCSI_READ; packet.buffer = buffer; - packet.bufsize = 2048; + packet.bufsize = 2048 * nb_sectors; packet.cmdsize = 12; cmd->ext.opcode = 0xA8; cmd->ext.address = big_endian_dword(sector); - cmd->ext.length = 0x01000000; + cmd->ext.length = big_endian_dword(nb_sectors); if (drv->request(device, &packet)) { return -1; } - return 0; + return nb_sectors; } static int cdrom_capacity(struct cdi_scsi_device *device, @@ -210,12 +213,16 @@ static int cdi_scsi_disk_read(struct cdi_storage_device* device, { struct cdi_scsi_device* dev = device->dev.backdev; - while (count--) { - if (cdrom_read_sector(dev, start, buffer)) { + while (count > 0) { + uint64_t ret; + + ret = cdrom_read_partial(dev, start, count, buffer); + if (ret <= 0) { return -1; } - start ++; - buffer += 2048; + start += ret; + buffer += ret; + count -= ret; } return 0; -- 2.1.2 From kevin at tyndur.org Sun Jan 11 15:23:42 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 11 Jan 2015 15:23:42 +0100 Subject: [tyndur-devel] [PATCH 4/4] atapi: Fix CDI_SCSI_WRITE In-Reply-To: <1420986222-23055-1-git-send-email-kevin@tyndur.org> References: <1420986222-23055-1-git-send-email-kevin@tyndur.org> Message-ID: <1420986222-23055-5-git-send-email-kevin@tyndur.org> This was implemented the same as CDI_SCSI_READ, but should be using the out function. Cc: cdi-devel at tyndur.org Signed-off-by: Kevin Wolf --- src/modules/cdi/ata/atapi.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/modules/cdi/ata/atapi.c b/src/modules/cdi/ata/atapi.c index b866551..31c7263 100644 --- a/src/modules/cdi/ata/atapi.c +++ b/src/modules/cdi/ata/atapi.c @@ -141,8 +141,11 @@ int atapi_request(struct cdi_scsi_device* scsi,struct cdi_scsi_packet* packet) // Lesen bzw. Schreiben der Daten // TODO: DMA - if (packet->direction==CDI_SCSI_READ) ata_protocol_pio_in(&rw_request); - else if (packet->direction==CDI_SCSI_WRITE) ata_protocol_pio_in(&rw_request); + if (packet->direction == CDI_SCSI_READ) { + ata_protocol_pio_in(&rw_request); + } else if (packet->direction == CDI_SCSI_WRITE) { + ata_protocol_pio_out(&rw_request); + } // Bei Fehler den Sense Key zurueckgeben status = ata_reg_inb(dev->controller, REG_STATUS); -- 2.1.2 From kevin at tyndur.org Mon Jan 12 22:41:06 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Mon, 12 Jan 2015 22:41:06 +0100 Subject: [tyndur-devel] =?utf-8?q?=5BPATCH_1/6=5D_kernel2=3A_Refcounting_f?= =?utf-8?q?=C3=BCr_lio=5Fstream?= In-Reply-To: <1421098871-25847-1-git-send-email-kevin@tyndur.org> References: <1421098871-25847-1-git-send-email-kevin@tyndur.org> Message-ID: <1421098871-25847-2-git-send-email-kevin@tyndur.org> + kernel2: lio_streams haben jetzt einen Refcount, so dass mehrere Userspace-IDs auf denselben Stream verweisen können. Signed-off-by: Kevin Wolf --- src/kernel2/include/lostio/core.h | 2 ++ src/kernel2/include/lostio/userspace.h | 7 +++++-- src/kernel2/src/lostio/userspace.c | 32 +++++++++++++++++++++++++++----- src/kernel2/src/syscalls/lostio.c | 22 ++++++++-------------- src/kernel2/src/tasks/pm.c | 8 ++------ 5 files changed, 44 insertions(+), 27 deletions(-) diff --git a/src/kernel2/include/lostio/core.h b/src/kernel2/include/lostio/core.h index b1183b4..3e71dc3 100644 --- a/src/kernel2/include/lostio/core.h +++ b/src/kernel2/include/lostio/core.h @@ -54,6 +54,8 @@ struct lio_stream { int flags; bool eof; + + int usp_refcount; }; struct lio_usp_stream { diff --git a/src/kernel2/include/lostio/userspace.h b/src/kernel2/include/lostio/userspace.h index a8a5cdc..cde9778 100644 --- a/src/kernel2/include/lostio/userspace.h +++ b/src/kernel2/include/lostio/userspace.h @@ -53,8 +53,11 @@ struct lio_usp_stream* lio_usp_add_stream(pm_process_t* proc, struct lio_usp_stream* lio_usp_get_stream(pm_process_t* proc, lio_usp_stream_t id); -/** Gibt die Userspace-ID des Streams wieder frei */ -void lio_usp_remove_stream(pm_process_t* proc, struct lio_usp_stream* stream); +/** + * Gibt die Userspace-ID des Streams wieder frei und schließt den Stream, wenn + * das die letzte Userspace-Referenz war. + */ +int lio_usp_unref_stream(pm_process_t* proc, struct lio_usp_stream* stream); diff --git a/src/kernel2/src/lostio/userspace.c b/src/kernel2/src/lostio/userspace.c index d6376de..76874fc 100644 --- a/src/kernel2/src/lostio/userspace.c +++ b/src/kernel2/src/lostio/userspace.c @@ -35,7 +35,9 @@ #include +#include "kernel.h" #include "lostio/core.h" +#include "lostio/client.h" #include "lostio_int.h" static tree_t* resource_tree; @@ -101,8 +103,10 @@ struct lio_usp_stream* lio_usp_add_stream(pm_process_t* proc, entry->stream = stream; entry->usp_id = new_streamid(); - tree_insert(proc->lio_streams, entry); + + stream->usp_refcount++; + return entry; } @@ -116,11 +120,29 @@ struct lio_usp_stream* lio_usp_get_stream(pm_process_t* proc, return tree_search(proc->lio_streams, id); } -/** Gibt die Userspace-ID des Streams wieder frei */ -void lio_usp_remove_stream(pm_process_t* proc, struct lio_usp_stream* stream) +/** + * Gibt die Userspace-ID des Streams wieder frei und schließt den Stream, wenn + * das die letzte Userspace-Referenz war. + */ +int lio_usp_unref_stream(pm_process_t* proc, struct lio_usp_stream* us) { - tree_remove(proc->lio_streams, stream); - free(stream); + struct lio_stream* stream = us->stream; + int ret; + + BUG_ON(stream->usp_refcount <= 0); + stream->usp_refcount--; + + if (stream->usp_refcount == 0) { + ret = lio_close(stream); + if (ret < 0) { + return ret; + } + } + + tree_remove(proc->lio_streams, us); + free(us); + + return 0; } /** Weist einem Verzeichnisbaum eine Userspace-ID zu */ diff --git a/src/kernel2/src/syscalls/lostio.c b/src/kernel2/src/syscalls/lostio.c index 1c978d4..314ca98 100644 --- a/src/kernel2/src/syscalls/lostio.c +++ b/src/kernel2/src/syscalls/lostio.c @@ -37,6 +37,7 @@ #include #include +#include "kernel.h" #include "kprintf.h" #include "syscall.h" #include @@ -107,8 +108,6 @@ void syscall_lio_open(lio_usp_resource_t* resid, int flags, int syscall_lio_close(lio_usp_stream_t* stream_id) { struct lio_usp_stream* fd; - struct lio_stream* stream; - int ret; // TODO: is_userspace fd = lio_usp_get_stream(current_process, *stream_id); @@ -116,17 +115,7 @@ int syscall_lio_close(lio_usp_stream_t* stream_id) return -EBADF; } - // lio_close gibt stream im Erfolgsfall frei, wir koennen es also nicht - // erst hinterher aus dem Baum entfernen. Falls close schiefgeht, muessen - // wir es wohl oder uebel wieder eintragen. - stream = fd->stream; - lio_usp_remove_stream(current_process, fd); - ret = lio_close(stream); - if (ret < 0) { - lio_usp_add_stream(current_process, stream); - } - - return ret; + return lio_usp_unref_stream(current_process, fd); } /// Stream an anderen Prozess weitergeben @@ -135,6 +124,7 @@ int syscall_lio_pass_fd(lio_usp_stream_t* stream_id, pid_t pid) struct lio_usp_stream* fd; struct lio_stream* stream; pm_process_t* process; + int ret; process = pm_get(pid); if (process == NULL) { @@ -148,10 +138,14 @@ int syscall_lio_pass_fd(lio_usp_stream_t* stream_id, pid_t pid) } stream = fd->stream; - lio_usp_remove_stream(current_process, fd); fd = lio_usp_add_stream(process, stream); *stream_id = fd->usp_id; + // Wir haben gerade eine zweite Referenz hinzugefügt, also kann kein + // lio_close() aufgerufen, das fehlschlagen könnte. + ret = lio_usp_unref_stream(current_process, fd); + BUG_ON(ret != 0); + return 0; } diff --git a/src/kernel2/src/tasks/pm.c b/src/kernel2/src/tasks/pm.c index 8219022..bb95923 100644 --- a/src/kernel2/src/tasks/pm.c +++ b/src/kernel2/src/tasks/pm.c @@ -192,16 +192,12 @@ void pm_prepare_destroy(pm_process_t* process) // Alle Dateien schliessen und freigeben struct lio_usp_stream* fd = NULL; struct lio_usp_stream* next = NULL; - struct lio_stream* s; fd = tree_next(process->lio_streams, NULL); while (fd != NULL) { next = tree_next(process->lio_streams, fd); - - s = fd->stream; - lio_usp_remove_stream(process, fd); - lio_close(s); - + // TODO Was machen mit Dateien, die sich nicht schließen lassen? + (void) lio_usp_unref_stream(process, fd); fd = next; } tree_destroy(process->lio_streams); -- 2.1.2 From kevin at tyndur.org Mon Jan 12 22:41:05 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Mon, 12 Jan 2015 22:41:05 +0100 Subject: [tyndur-devel] [PATCH 0/6] vterm: Nach LostIOv2 konvertieren Message-ID: <1421098871-25847-1-git-send-email-kevin@tyndur.org> Kevin Wolf (6): kernel2: Refcounting für lio_stream kernel2: Non-seekable Ressourcen nur einmal öffnen LostIOv2: close-Event an Userspace-Services weitergeben kernel2: pwrite braucht nicht immer ein RMW kernel2: EOF-Handling in pread überarbeitet vterm: Nach LostIOv2 konvertiert src/include/syscall_structs.h | 15 ++ src/kernel2/include/lostio/core.h | 2 + src/kernel2/include/lostio/userspace.h | 7 +- src/kernel2/src/lostio/client.c | 46 +++- src/kernel2/src/lostio/include/lostio_int.h | 6 + src/kernel2/src/lostio/userspace.c | 32 ++- src/kernel2/src/syscalls/lio_server.c | 20 ++ src/kernel2/src/syscalls/lostio.c | 22 +- src/kernel2/src/tasks/pm.c | 8 +- src/modules/include/lostio.h | 3 + src/modules/lib/lostio/lio_server.c | 16 ++ src/modules/vterm/include/keymap.h | 11 +- src/modules/vterm/keymap.c | 39 +--- src/modules/vterm/lostio.c | 318 +++++++++++++++++++++------- src/modules/vterm/term.c | 30 +-- src/modules/vterm/vterm.c | 8 +- src/modules/vterm/vterm.h | 27 +++ 17 files changed, 428 insertions(+), 182 deletions(-) -- 2.1.2 From kevin at tyndur.org Mon Jan 12 22:41:07 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Mon, 12 Jan 2015 22:41:07 +0100 Subject: [tyndur-devel] =?utf-8?q?=5BPATCH_2/6=5D_kernel2=3A_Non-seekable_?= =?utf-8?q?Ressourcen_nur_einmal_=C3=B6ffnen?= In-Reply-To: <1421098871-25847-1-git-send-email-kevin@tyndur.org> References: <1421098871-25847-1-git-send-email-kevin@tyndur.org> Message-ID: <1421098871-25847-3-git-send-email-kevin@tyndur.org> * kernel2: Wenn man eine non-seekable Ressource ein zweites Mal öffnet, bekommt man nur einen Alias für den existierenden Stream. Dadurch bleibt der Dateizeiger konsistent, auch wenn mehrere Programme vom selben Stream lesen. Signed-off-by: Kevin Wolf --- src/kernel2/src/lostio/client.c | 21 +++++++++++++++++++++ src/kernel2/src/lostio/include/lostio_int.h | 6 ++++++ 2 files changed, 27 insertions(+) diff --git a/src/kernel2/src/lostio/client.c b/src/kernel2/src/lostio/client.c index 3b4c2c6..46f2456 100644 --- a/src/kernel2/src/lostio/client.c +++ b/src/kernel2/src/lostio/client.c @@ -241,6 +241,16 @@ struct lio_stream* lio_open(struct lio_resource* res, int flags) return NULL; } + // Non-seekable Streams dürfen nur einmal geöffnet sein. Vorläufig den + // schon existierenden Stream zurückgeben, falls die Flags passen. + // TODO Immer Fehler zurückgeben sobald der Userspace damit klarkommt + if (res->excl_stream) { + if (res->excl_stream->flags != flags) { + return NULL; + } + return res->excl_stream; + } + // Stream anlegen und initialisieren s = calloc(1, sizeof(*s)); s->res = s->res_read = s->res_write = res; @@ -261,6 +271,11 @@ struct lio_stream* lio_open(struct lio_resource* res, int flags) } } + // Non-seekable Streams dürfen nur einmal geöffnet sein + if (!res->seekable) { + res->excl_stream = s; + } + return s; fail: @@ -569,10 +584,16 @@ int lio_truncate(struct lio_stream* s, uint64_t size) */ int lio_close(struct lio_stream* s) { + // Sicherstellen, dass lio_open() den Stream nicht rausrückt, während wir + // ihn gerade schließen + s->flags = 0; + if (s->res->tree->service->lio_ops.close) { s->res->tree->service->lio_ops.close(s); } + s->res->excl_stream = NULL; + free(s); return 0; } diff --git a/src/kernel2/src/lostio/include/lostio_int.h b/src/kernel2/src/lostio/include/lostio_int.h index a8d112a..4feb05c 100644 --- a/src/kernel2/src/lostio/include/lostio_int.h +++ b/src/kernel2/src/lostio/include/lostio_int.h @@ -186,6 +186,12 @@ struct lio_resource { /** Sortierung nach usp_id im Baum */ struct tree_item usp_item; + /** + * Falls die Ressource nur einmal geöffnet werden kann, der offene Stream, + * der sie zugreift, oder NULL, wenn sie nicht geöffnet ist. + */ + struct lio_stream* excl_stream; + /** Private Daten des Services */ void* opaque; }; -- 2.1.2 From kevin at tyndur.org Mon Jan 12 22:41:08 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Mon, 12 Jan 2015 22:41:08 +0100 Subject: [tyndur-devel] [PATCH 3/6] LostIOv2: close-Event an Userspace-Services weitergeben In-Reply-To: <1421098871-25847-1-git-send-email-kevin@tyndur.org> References: <1421098871-25847-1-git-send-email-kevin@tyndur.org> Message-ID: <1421098871-25847-4-git-send-email-kevin@tyndur.org> + LIOv2: Neue Operation close für Userspace-Services. Für die meisten Treiber ist das nicht nützlich, weil sie nichts von Streams wissen, aber non-seekable Ressourcen sind nur genau einmal geöffnet und ein close-Handler muss sie zurücksetzen, damit sie nach dem nächsten open() damit klarkommen, dass das Offset wieder bei 0 ist. Signed-off-by: Kevin Wolf --- src/include/syscall_structs.h | 15 +++++++++++++++ src/kernel2/src/syscalls/lio_server.c | 20 ++++++++++++++++++++ src/modules/include/lostio.h | 3 +++ src/modules/lib/lostio/lio_server.c | 16 ++++++++++++++++ 4 files changed, 54 insertions(+) diff --git a/src/include/syscall_structs.h b/src/include/syscall_structs.h index 060d82e..e43295b 100644 --- a/src/include/syscall_structs.h +++ b/src/include/syscall_structs.h @@ -281,6 +281,11 @@ enum lio_opcode { * Uebersetzungstabelle befuellen */ LIO_OP_MAP = 14, + + /** + * Stream der Ressource wird geschlossen + */ + LIO_OP_CLOSE = 15, }; /// Flags fuer Operationen @@ -338,6 +343,16 @@ struct lio_op_load_children { void* opaque; } __attribute__((packed)); +struct lio_op_close { + struct lio_op op; + + /// Nummer der Ressource, die geschlossen wird + lio_usp_resource_t resource; + + /// Wert des Opaque-Felds der betreffenden Ressource + void* opaque; +} __attribute__((packed)); + struct lio_op_read { struct lio_op op; diff --git a/src/kernel2/src/syscalls/lio_server.c b/src/kernel2/src/syscalls/lio_server.c index 5a7e6a9..0ead479 100644 --- a/src/kernel2/src/syscalls/lio_server.c +++ b/src/kernel2/src/syscalls/lio_server.c @@ -54,6 +54,7 @@ struct cache_block_handle { static struct lio_resource* load_root(struct lio_tree* tree); static int load_children(struct lio_resource* res); +static void close(struct lio_stream* stream); static int read(struct lio_resource* res, uint64_t offset, size_t bytes, void* buf); static int write(struct lio_resource* res, uint64_t offset, @@ -137,6 +138,7 @@ int syscall_lio_srv_service_register(const char* name, size_t name_len, service->name = strdup(name); service->lio_ops.load_root = load_root; service->lio_ops.load_children = load_children; + service->lio_ops.close = close; service->lio_ops.read = read; service->lio_ops.write = write; service->lio_ops.make_file = make_file; @@ -563,6 +565,24 @@ static int load_children(struct lio_resource* res) return result; } +static void close(struct lio_stream* stream) +{ + struct lio_resource* res = stream->res; + struct lio_op_close* oc; + + oc = (struct lio_op_close*) alloc_op(res, sizeof(*oc)); + if (oc == NULL) { + return; + } + + oc->op.opcode = LIO_OP_CLOSE; + oc->resource = res->usp_id; + oc->opaque = res->opaque; + oc->op.flags |= LIO_OPFL_USP; + + commit_op(res, &oc->op, NULL); +} + static int read(struct lio_resource* res, uint64_t offset, size_t bytes, void* buf) { diff --git a/src/modules/include/lostio.h b/src/modules/include/lostio.h index 1357ca3..5846be6 100644 --- a/src/modules/include/lostio.h +++ b/src/modules/include/lostio.h @@ -257,6 +257,9 @@ struct lio_driver { /// Kindressoucren einer Ressource laden int (*load_children)(struct lio_resource* res); + /// Stream der Ressource wurde geschlossen + void (*close)(struct lio_resource* res); + /// Daten aus einer Ressource in den Cache laden int (*read)(struct lio_resource* res, uint64_t offset, size_t bytes, void* buf); diff --git a/src/modules/lib/lostio/lio_server.c b/src/modules/lib/lostio/lio_server.c index e1b919a..64206f5 100644 --- a/src/modules/lib/lostio/lio_server.c +++ b/src/modules/lib/lostio/lio_server.c @@ -52,6 +52,7 @@ static void process_op(struct lio_service* service, struct lio_op* op); // Operationen static void op_load_root(struct lio_service* service, struct lio_op* op); static void op_load_children(struct lio_service* service, struct lio_op* op); +static void op_close(struct lio_service* service, struct lio_op* op); static void op_read(struct lio_service* service, struct lio_op* op); static void op_write(struct lio_service* service, struct lio_op* op); static void op_make_file(struct lio_service* service, struct lio_op* op); @@ -144,6 +145,10 @@ static void process_op(struct lio_service* service, struct lio_op* op) op_load_children(service, op); break; + case LIO_OP_CLOSE: + op_close(service, op); + break; + case LIO_OP_READ: op_read(service, op); break; @@ -242,6 +247,17 @@ static void op_load_children(struct lio_service* service, struct lio_op* op) lio_srv_op_done(op, ret, 0); } +static void op_close(struct lio_service* service, struct lio_op* op) +{ + struct lio_op_close* oc = (struct lio_op_close*) op; + struct lio_resource* res = (struct lio_resource*) oc->opaque; + + if (service->lio_ops.close) { + service->lio_ops.close(res); + } + lio_srv_op_done(op, 0, 0); +} + static void op_read(struct lio_service* service, struct lio_op* op) { struct lio_op_read* or = (struct lio_op_read*) op; -- 2.1.2 From kevin at tyndur.org Mon Jan 12 22:41:09 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Mon, 12 Jan 2015 22:41:09 +0100 Subject: [tyndur-devel] [PATCH 4/6] kernel2: pwrite braucht nicht immer ein RMW In-Reply-To: <1421098871-25847-1-git-send-email-kevin@tyndur.org> References: <1421098871-25847-1-git-send-email-kevin@tyndur.org> Message-ID: <1421098871-25847-5-git-send-email-kevin@tyndur.org> ! kernel2: Wenn das Alignment vom Request schon passt, dann gibt es keinen Grund, die Daten erst einmal einzulesen. Besonders wenn die Ressource write-only ist (z.B. vterm:/.../out) ist das hilfreich, sonst geht das Schreiben immer schief. Für alle anderen tut es vermutlich nur der Performance gut. Signed-off-by: Kevin Wolf --- src/kernel2/src/lostio/client.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/kernel2/src/lostio/client.c b/src/kernel2/src/lostio/client.c index 46f2456..b2922eb 100644 --- a/src/kernel2/src/lostio/client.c +++ b/src/kernel2/src/lostio/client.c @@ -418,10 +418,13 @@ ssize_t lio_pwrite(struct lio_stream* s, uint64_t offset, size_t bytes, uint64_t curoffset = offset_aligned; int old_flags; - old_flags = s->flags; - s->flags |= LIO_READ; - ret = lio_pread(s, offset_aligned, bytes_aligned, bounce); - s->flags = old_flags; + if (offset != offset_aligned || bytes != bytes_aligned) { + old_flags = s->flags; + // FIXME Wenn das mal nicht racy ist... + s->flags |= LIO_READ; + ret = lio_pread(s, offset_aligned, bytes_aligned, bounce); + s->flags = old_flags; + } if (ret < 0) { goto out; -- 2.1.2 From kevin at tyndur.org Mon Jan 12 22:41:10 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Mon, 12 Jan 2015 22:41:10 +0100 Subject: [tyndur-devel] =?utf-8?q?=5BPATCH_5/6=5D_kernel2=3A_EOF-Handling_?= =?utf-8?q?in_pread_=C3=BCberarbeitet?= In-Reply-To: <1421098871-25847-1-git-send-email-kevin@tyndur.org> References: <1421098871-25847-1-git-send-email-kevin@tyndur.org> Message-ID: <1421098871-25847-6-git-send-email-kevin@tyndur.org> * kernel2: Ein Terminal kann zwischendurch mal ein EOF senden wollen, anschließend aber wieder tadellos weiterarbeiten. Das ging mit dem alten Code nicht. Dafür ist es wichtig, dass erstens der Service überhaupt aufgerufen wird, damit er mitbekommt, dass sein EOF gelesen wurde und er im Programm weitermachen kann, und dass er zweitens bei einem Aufruf auch ein EOF anzeigen kann. Das geht jetzt durch die Rückgabe von -EAGAIN bei gelöschtem res->moredata. Signed-off-by: Kevin Wolf --- src/kernel2/src/lostio/client.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/kernel2/src/lostio/client.c b/src/kernel2/src/lostio/client.c index b2922eb..db98df1 100644 --- a/src/kernel2/src/lostio/client.c +++ b/src/kernel2/src/lostio/client.c @@ -324,7 +324,9 @@ ssize_t lio_pread(struct lio_stream* s, uint64_t offset, size_t bytes, if (res->moredata) { return -EAGAIN; } - return 0; + if (offset > res->size) { + return 0; + } } // Abschneiden, wenn ueber das Dateiende hinausgelesen wird @@ -344,8 +346,14 @@ ssize_t lio_pread(struct lio_stream* s, uint64_t offset, size_t bytes, ret = drv->read(res, curoffset, bytes_aligned, p); if (ret >= 0) { - ret = bytes; - memcpy(buf, bounce + (offset - offset_aligned), ret); + if (bytes == 0 && res->moredata) { + ret = -EAGAIN; + } else { + ret = bytes; + memcpy(buf, bounce + (offset - offset_aligned), ret); + } + } else if (ret == -EAGAIN && !res->moredata) { + ret = 0; } free(bounce); -- 2.1.2 From kevin at tyndur.org Mon Jan 12 22:41:11 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Mon, 12 Jan 2015 22:41:11 +0100 Subject: [tyndur-devel] [PATCH 6/6] vterm: Nach LostIOv2 konvertiert In-Reply-To: <1421098871-25847-1-git-send-email-kevin@tyndur.org> References: <1421098871-25847-1-git-send-email-kevin@tyndur.org> Message-ID: <1421098871-25847-7-git-send-email-kevin@tyndur.org> * vterm: Der Stand nach diesem Commit ist, dass hoffentlich alles noch genausoo funktioniert wie davor. Spannend wird die Konvertierung dann, wenn der Kernel lernt, was blockierende Reads sind. Dann dürften wir nämlich die 100% CPU fürs Pollen des Terminals endlich los werden. Signed-off-by: Kevin Wolf --- src/modules/vterm/include/keymap.h | 11 +- src/modules/vterm/keymap.c | 39 ++--- src/modules/vterm/lostio.c | 318 +++++++++++++++++++++++++++---------- src/modules/vterm/term.c | 30 +--- src/modules/vterm/vterm.c | 8 +- src/modules/vterm/vterm.h | 27 ++++ 6 files changed, 285 insertions(+), 148 deletions(-) diff --git a/src/modules/vterm/include/keymap.h b/src/modules/vterm/include/keymap.h index 604080d..9c6ff9f 100644 --- a/src/modules/vterm/include/keymap.h +++ b/src/modules/vterm/include/keymap.h @@ -61,21 +61,14 @@ extern keymap_entry_t keymap[128]; keymap_entry_t* keymap_get(uint8_t keycode); /** - * Legt die vterm:/keymap im Verzeichnisbaum an - */ -void keymap_init(void); - -/** * LostIO-Handller um die Tastaturbelegung zu lesen */ -size_t keymap_read(lostio_filehandle_t* file, void* buf, - size_t blocksize, size_t blockcount); +int keymap_read(uint64_t offset, size_t bytes, void* buf); /** * LostIO-Handler um die Tastaturbelegung zu aendern */ -size_t keymap_write(lostio_filehandle_t* file, size_t blocksize, - size_t blockcount, void* data); +int keymap_write(uint64_t offset, size_t bytes, void* buf); #endif // ifndef _KEYMAP_H_ diff --git a/src/modules/vterm/keymap.c b/src/modules/vterm/keymap.c index 72715e6..28b4905 100644 --- a/src/modules/vterm/keymap.c +++ b/src/modules/vterm/keymap.c @@ -35,6 +35,7 @@ #include #include +#include #include "vterm.h" #include "keymap.h" @@ -50,47 +51,29 @@ keymap_entry_t* keymap_get(uint8_t keycode) } /** - * Legt die vterm:/keymap im Verzeichnisbaum an - */ -void keymap_init(void) -{ - vfstree_create_node("/keymap", LOSTIO_TYPES_KEYMAP, 0, NULL, 0); -} - -/** * LostIO-Handller um die Tastaturbelegung zu lesen */ -size_t keymap_read(lostio_filehandle_t* file, void* buf, - size_t blocksize, size_t blockcount) +int keymap_read(uint64_t offset, size_t bytes, void* buf) { - size_t size = blocksize * blockcount; - - if (file->pos + size >= sizeof(keymap)) { - size = sizeof(keymap) - file->pos; - file->flags |= LOSTIO_FLAG_EOF; + if (offset > sizeof(keymap) || bytes > sizeof(keymap) - offset) { + return -EINVAL; } - memcpy(buf, ((uint8_t*) keymap) + file->pos, size); - file->pos += size; + memcpy(buf, ((uint8_t*) keymap) + offset, bytes); - return size; + return 0; } /** * LostIO-Handler um die Tastaturbelegung zu aendern */ -size_t keymap_write(lostio_filehandle_t* file, size_t blocksize, - size_t blockcount, void* buf) +int keymap_write(uint64_t offset, size_t bytes, void* buf) { - size_t size = blocksize * blockcount; - - if (file->pos + size >= sizeof(keymap)) { - size = sizeof(keymap) - file->pos; - file->flags |= LOSTIO_FLAG_EOF; + if (offset > sizeof(keymap) || bytes > sizeof(keymap) - offset) { + return -ENOSPC; } - memcpy(((uint8_t*) keymap) + file->pos, buf, size); - file->pos += size; + memcpy(((uint8_t*) keymap) + offset, buf, bytes); - return size; + return 0; } diff --git a/src/modules/vterm/lostio.c b/src/modules/vterm/lostio.c index 7bd1c30..4905f8a 100644 --- a/src/modules/vterm/lostio.c +++ b/src/modules/vterm/lostio.c @@ -37,129 +37,283 @@ #include #include #include +#include #include "vterm.h" #include "lostio.h" #include "keymap.h" -/// Handler fuer Lesen aus in -size_t terminal_read(lostio_filehandle_t* handle, void* buf, - size_t blocksize, size_t blockcount); +static struct lio_resource* root; -/// Handler fuer schreiben in out -size_t terminal_write(lostio_filehandle_t* handle, size_t blocksize, - size_t blockcount, void* data); +static void lio_add_vterm_dir(vterminal_t* vterm) +{ + struct lio_tree* tree = root->tree; -/// Handler fuer close auf in -static int lio_in_close(lostio_filehandle_t* fh); + struct lio_resource* dir; + struct lio_resource* in_node; + struct lio_resource* out_node; + struct lio_vterm* lv; -/** - * LostIO-Interface vorbereiten, ueber das die Prozesse mit vterm kommunizieren - * werden. - */ -void init_lostio_interface() + // Verzeichnis + dir = lio_resource_create(tree); + dir->browsable = 1; + dir->blocksize = 1; + lio_resource_modified(dir); + lio_node_create(root, dir, vterm->name); + + // In-Node + lv = malloc(sizeof(*lv)); + *lv = (struct lio_vterm) { + .type = LOSTIO_TYPES_IN, + .vterm = vterm, + }; + + in_node = lio_resource_create(tree); + in_node->readable = 1; + in_node->blocksize = 1; + in_node->moredata = 1; + in_node->opaque = lv; + lio_resource_modified(in_node); + lio_node_create(dir, in_node, "in"); + + vterm->lio_in_res = in_node; + + // Out-Node + lv = malloc(sizeof(*lv)); + *lv = (struct lio_vterm) { + .type = LOSTIO_TYPES_OUT, + .vterm = vterm, + }; + + out_node = lio_resource_create(tree); + out_node->writable = 1; + out_node->blocksize = 1; + out_node->opaque = lv; + lio_resource_modified(out_node); + lio_node_create(dir, out_node, "out"); +} + +struct lio_resource* vterm_load_root(struct lio_tree* tree) { - lostio_init(); - lostio_type_directory_use(); - - // Typehandle fuer Ausgabekanaele - typehandle_t* typehandle = malloc(sizeof(typehandle_t)); - typehandle->id = LOSTIO_TYPES_OUT; - typehandle->not_found = NULL; - typehandle->pre_open = NULL; - typehandle->post_open = NULL; - typehandle->read = NULL; - typehandle->write = &terminal_write; - typehandle->seek = NULL; - typehandle->close = NULL; - lostio_register_typehandle(typehandle); - - // Typehandle fuer Eingabekanaele - typehandle = malloc(sizeof(typehandle_t)); - typehandle->id = LOSTIO_TYPES_IN; - typehandle->not_found = NULL; - typehandle->pre_open = NULL; - typehandle->post_open = NULL; - typehandle->read = &terminal_read; - typehandle->write = NULL; - typehandle->seek = NULL; - typehandle->close = lio_in_close; - typehandle->link = NULL; - typehandle->unlink = NULL; - lostio_register_typehandle(typehandle); - - // Typehandle fuer Keymaps - typehandle = calloc(1, sizeof(typehandle_t)); - typehandle->id = LOSTIO_TYPES_KEYMAP; - typehandle->read = &keymap_read; - typehandle->write = &keymap_write; - lostio_register_typehandle(typehandle); + vterminal_t *vterm; + struct lio_resource* keymap_node; + struct lio_vterm* lv; + int i; + + if (tree->source != -1) { + return NULL; + } + + // Wurzelknoten + root = lio_resource_create(tree); + root->browsable = 1; + root->blocksize = 1; + lio_resource_modified(root); + lio_node_create(NULL, root, ""); + + // keymap + lv = malloc(sizeof(*lv)); + *lv = (struct lio_vterm) { + .type = LOSTIO_TYPES_KEYMAP, + .vterm = NULL, + }; + + keymap_node = lio_resource_create(tree); + keymap_node->readable = 1; + keymap_node->writable = 1; + keymap_node->blocksize = 1; + keymap_node->opaque = lv; + lio_resource_modified(keymap_node); + lio_node_create(root, keymap_node, "keymap"); + + // Terminals + for (i = 0; (vterm = list_get_element_at(vterm_list, i)); i++) { + lio_add_vterm_dir(vterm); + } + + return root; +} + +void lio_add_vterm(vterminal_t* vterm) +{ + if (root) { + lio_add_vterm_dir(vterm); + } } /** * LostIO-Handler um in den Ausgabekanal zu schreiben */ -size_t terminal_write(lostio_filehandle_t* file, size_t blocksize, - size_t blockcount, void* data) +int term_write(struct lio_resource* res, uint64_t offset, size_t bytes, + void* buf) { + struct lio_vterm *lv = res->opaque; + + //printf("term_write: %s: %d -> %p\n", lv->vterm->name, bytes, buf); + p(); - vterm_process_output((vterminal_t*) file->node->data, data, blocksize * - blockcount); + vterm_process_output(lv->vterm, buf, bytes); v(); - return blocksize * blockcount; + + return 0; } /** * LostIO-Handller um aus dem Eingabekanal zu lesen */ -size_t terminal_read(lostio_filehandle_t* file, void* buf, - size_t blocksize, size_t blockcount) +int term_read(struct lio_resource* res, uint64_t offset, size_t bytes, + void* buf) { + struct lio_vterm *lv = res->opaque; + p(); - size_t size = blocksize * blockcount; - vterminal_t* vterm = (vterminal_t*) file->node->data; + vterminal_t* vterm = lv->vterm; + + /*printf("vterm_read: offset %llx + %d bytes [buf %d; res %d; seteof %d; " + "moredata %d]\n", offset, bytes, + vterm->in_buffer_size, res->size, vterm->set_eof, res->moredata);*/ + // FIXME Erstmal die vorherigen Daten rausgeben if (vterm->set_eof) { vterm->set_eof = false; - file->flags |= LOSTIO_FLAG_EOF; + res->moredata = false; + lio_resource_modified(res); v(); - return 0; + return -EAGAIN; + } else if (res->moredata == false) { + res->moredata = true; + lio_resource_modified(res); } - if (vterm->in_buffer_size == 0) { + // Erst einmal alles wegwerfen, was nicht mehr gebraucht wird, weil schon + // von einem höheren Offset gelesen wurde + if (offset > vterm->in_buffer_offset) { + size_t drop; + + drop = offset - vterm->in_buffer_offset; + if (drop > vterm->in_buffer_size) { + drop = vterm->in_buffer_size; + } + vterm->in_buffer_size -= drop; + + if (vterm->in_buffer_size != 0) { + memmove(vterm->in_buffer, vterm->in_buffer + drop, + vterm->in_buffer_size); + } else { + free(vterm->in_buffer); + vterm->in_buffer = NULL; + } + + vterm->in_buffer_offset = offset; + } + + if (vterm->in_buffer_size < bytes) { v(); - return 0; + return -EAGAIN; + } + +/*printf("vterm_read: memcpy %p <- %p + %x [buf %x]\n", + buf, vterm->in_buffer, bytes, vterm->in_buffer_size);*/ + memcpy(buf, vterm->in_buffer, bytes); + + v(); + return 0; +} + +void lio_update_in_file_size(vterminal_t* vterm, size_t length) +{ + struct lio_resource* res = vterm->lio_in_res; + + if (res) { + res->size += length; + lio_resource_modified(res); } - - if (vterm->in_buffer_size < size) { - size = vterm->in_buffer_size; +} + +void lio_set_eof(vterminal_t* vterm) +{ + struct lio_resource* res = vterm->lio_in_res; + + if (res) { + res->moredata = false; + lio_resource_modified(res); } +} - memcpy(buf, vterm->in_buffer, size); - - vterm->in_buffer_size -= size; - // Die uebrigen Daten am ende des Buffers an den Anfang schieben - if (vterm->in_buffer_size != 0) { - memmove(vterm->in_buffer, vterm->in_buffer + size, - vterm->in_buffer_size); - } else { - free(vterm->in_buffer); - vterm->in_buffer = NULL; +int vterm_read(struct lio_resource* res, uint64_t offset, size_t bytes, + void* buf) +{ + struct lio_vterm *lv = res->opaque; + + switch (lv->type) { + case LOSTIO_TYPES_IN: return term_read(res, offset, bytes, buf); + case LOSTIO_TYPES_OUT: return -EBADF; + case LOSTIO_TYPES_KEYMAP: return keymap_read(offset, bytes, buf); } - v(); - return size; + return -EBADF; } +int vterm_write(struct lio_resource* res, uint64_t offset, size_t bytes, + void* buf) +{ + struct lio_vterm *lv = res->opaque; + + switch (lv->type) { + case LOSTIO_TYPES_IN: return -EBADF; + case LOSTIO_TYPES_OUT: return term_write(res, offset, bytes, buf); + case LOSTIO_TYPES_KEYMAP: return keymap_write(offset, bytes, buf); + } + + return -EBADF; +} + +int vterm_resize(struct lio_resource* res, uint64_t size) +{ + struct lio_vterm *lv = res->opaque; + + switch (lv->type) { + case LOSTIO_TYPES_IN: return 0; + case LOSTIO_TYPES_OUT: return 0; + case LOSTIO_TYPES_KEYMAP: return 0; /* TODO -EINVAL; */ + } + + return -EBADF; +} + +void vterm_close(struct lio_resource* res) +{ + struct lio_vterm *lv = res->opaque; + + if (lv->type == LOSTIO_TYPES_IN) { + lv->vterm->in_buffer_offset = 0; + res->size = lv->vterm->in_buffer_size = 0; + lio_resource_modified(res); + } +} + +static struct lio_service service = { + .name = "vterm", + .lio_ops = { + .load_root = vterm_load_root, + .close = vterm_close, + .read = vterm_read, + .write = vterm_write, + .resize = vterm_resize, + }, +}; + /** - * LostIO-Handler der einen allenfalls allozierten Buffer im Filehandle freigibt + * LostIO-Interface vorbereiten, ueber das die Prozesse mit vterm kommunizieren + * werden. */ -static int lio_in_close(lostio_filehandle_t* fh) +void init_lostio_interface() { - if (fh->data) { - free(fh->data); - } + // TODO Entfernen, wenn niemand mehr versucht, LIOv1 zu benutzen + // Im Moment brauchen wir das noch, damit RPCs beantwortet werden und der + // Aufrufer nicht hängt + lostio_init(); - return 0; + lio_add_service(&service); } diff --git a/src/modules/vterm/term.c b/src/modules/vterm/term.c index ccf4e6a..5a61ac7 100644 --- a/src/modules/vterm/term.c +++ b/src/modules/vterm/term.c @@ -51,7 +51,7 @@ char* strnstr(const char* s, const char* find, size_t slen); vterminal_t* current_vterm = NULL; /// Liste in der alle virtuellen Terminals gespeichert werden -static list_t* vterm_list; +list_t* vterm_list; /// Virtuelles Terminal erstellen vterminal_t* vterm_create(char shortcut); @@ -94,28 +94,9 @@ vterminal_t* vterm_create(char shortcut) static int next_vterm_id = 0; asprintf(&vterm->name, "vterm%d", next_vterm_id++); - - // Knoten fuer LostIO-Schnittstelle erstellen - size_t name_len = strlen(vterm->name); - char path[name_len + 7]; - path[0] = '/'; - memcpy(path + 1, vterm->name, name_len + 1); - - // Verzeichnis - vfstree_create_node(path, LOSTIO_TYPES_DIRECTORY, 0, NULL, - LOSTIO_FLAG_BROWSABLE); - // In-Node - memcpy(path + name_len + 1, "/in", 4); - vfstree_create_node(path, LOSTIO_TYPES_IN, 0, vterm, - LOSTIO_FLAG_NOAUTOEOF); - vterm->in_node = vfstree_get_node_by_path(path); - // Sonst setzt LIO das EOF - vterm->in_node->size = 1; - - // Out-Node - memcpy(path + name_len + 1, "/out", 5); - vfstree_create_node(path, LOSTIO_TYPES_OUT, 0, vterm, 0); - vterm->out_node = vfstree_get_node_by_path(path); + + // LostIO-Knoten erstellen + lio_add_vterm(vterm); // Shortcut zuweisen vterm->shortcut = shortcut; @@ -172,6 +153,8 @@ void vterm_process_input(char* data, size_t length) for (i = 0; i < length; i++) { input_buffer_append(current_vterm, data[i]); } + + lio_update_in_file_size(current_vterm, length); } /** @@ -243,6 +226,7 @@ bool vterm_process_raw_input(uint8_t keycode, struct modifiers* modifiers) } else if (modifiers->control && (keycode == 32)) { // Strg + D = EOF current_vterm->set_eof = true; + lio_set_eof(current_vterm); return true; } else if (keycode == KEYCODE_SCROLL_LOCK) { current_vterm->output.scroll_lock = !current_vterm->output.scroll_lock; diff --git a/src/modules/vterm/vterm.c b/src/modules/vterm/vterm.c index 0ff461f..5c9af8a 100644 --- a/src/modules/vterm/vterm.c +++ b/src/modules/vterm/vterm.c @@ -85,13 +85,9 @@ int main(int argc, char* argv[]) return -1; } - // Tastaturbelegung konfigurierbar machen - keymap_init(); - // Auf Anfragen warten while(true) { - wait_for_rpc(); - lostio_dispatch(); + lio_dispatch(); + lio_srv_wait(); } } - diff --git a/src/modules/vterm/vterm.h b/src/modules/vterm/vterm.h index a7b6ef7..491a028 100644 --- a/src/modules/vterm/vterm.h +++ b/src/modules/vterm/vterm.h @@ -145,6 +145,9 @@ typedef struct { /// Groesse des Eingabepuffers size_t in_buffer_size; + /// LIO-Offset, an dem der Eingabepuffer anfängt + uint64_t in_buffer_offset; + /// Pointer auf den Eingabenpuffer. char* in_buffer; @@ -168,6 +171,9 @@ typedef struct { /// Beim naechsten Lesen EOF setzen bool set_eof; + + /// LostIO-Ressource für Tastatureingaben + struct lio_resource* lio_in_res; } vterminal_t; /// Status der Modifiertasten @@ -178,7 +184,28 @@ struct modifiers { bool alt; }; +/// opaque-Struktur für LIO-Knoten +struct lio_vterm { + /// LOSTIO_TYPES_* + int type; + + /// Terminal, zu dem der Knoten gehört + vterminal_t* vterm; +}; + +/// Neues vterm bei LostIO registrieren +void lio_add_vterm(vterminal_t* vterm); + +/// Informiert LostIO, dass es @length neue Zeichen zu lesen gibt +void lio_update_in_file_size(vterminal_t* vterm, size_t length); + +/// Informiert LostIO, dass ein EOF gesendet werden soll +void lio_set_eof(vterminal_t* vterm); + + + extern vterminal_t* current_vterm; +extern list_t* vterm_list; /// Virtuelle terminals einrichten void init_vterminals(unsigned int count); -- 2.1.2 From littlefox at fsfe.org Sat Jan 17 20:53:24 2015 From: littlefox at fsfe.org (Moritz Grosch (LittleFox)) Date: Sat, 17 Jan 2015 20:53:24 +0100 Subject: [tyndur-devel] [PATCH] Changed size of hd-images to 2GB Message-ID: <1421524404-9970-1-git-send-email-littlefox@fsfe.org> From: "Moritz Grosch (LittleFox)" 64MB aren't even enough to install coreutils --- build/config/image_hd.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build/config/image_hd.sh b/build/config/image_hd.sh index 4b2df61..e5b3f7e 100644 --- a/build/config/image_hd.sh +++ b/build/config/image_hd.sh @@ -1,3 +1,3 @@ IMAGE_PATH="build/images/hd.img" # Imagegroesse in Megabytes -IMAGE_SIZE=64 +IMAGE_SIZE=2048 -- 1.7.10.4 From littlefox at fsfe.org Sat Jan 17 20:56:19 2015 From: littlefox at fsfe.org (Moritz Grosch (LittleFox)) Date: Sat, 17 Jan 2015 20:56:19 +0100 Subject: [tyndur-devel] [PATCH] Added script to automatically build a lpt-repo Message-ID: <1421524579-10010-1-git-send-email-littlefox@fsfe.org> From: "Moritz Grosch (LittleFox)" This script builds a lpt-repository from the lbuilds packages-directory and automatically generates an index. Currently it doesn't set a real description and is limited to i386. --- build/scripts/lpt_index.sh | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100755 build/scripts/lpt_index.sh diff --git a/build/scripts/lpt_index.sh b/build/scripts/lpt_index.sh new file mode 100755 index 0000000..a851fa4 --- /dev/null +++ b/build/scripts/lpt_index.sh @@ -0,0 +1,44 @@ +#!/bin/bash + +if [ "$1" == "" -o "$2" == "" ]; then + echo "Usage: lpt-index.sh " + exit -1 +fi + +PACKAGE_DIRECTORY=$1 +DESTINATION_DIRECTORY=$2 + +if [ ! -d "$DESTINATION_DIRECTORY" ]; then + mkdir -p "$DESTINATION_DIRECTORY" +else + rm -rf $DESTINATION_DIRECTORY/* +fi + +for file in $PACKAGE_DIRECTORY/* +do + extension=${file##*.} + + if [ $extension == "tar" ] + then + filename=${file##*/} + filenamewithoutsuffix=${file%.*} + packagename=${filename%-*} + packageversion=${filenamewithoutsuffix##*-} + + if [[ $packagename == lib* ]]; then + type="lib" + else + type="bin" + fi + + echo "P $packagename" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "D no description" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "S $type" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "V $packageversion" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "s $(ls -l $PACKAGE_DIRECTORY | grep $filename | awk '{print $5}')" >> "$DESTINATION_DIRECTORY/packages.i386" + + echo "" >> "$DESTINATION_DIRECTORY/packages.i386" + + cp "$file" "$DESTINATION_DIRECTORY/$packagename-$type-$packageversion-i386.tar" + fi +done -- 1.7.10.4 From kevin at tyndur.org Sat Jan 17 21:59:27 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sat, 17 Jan 2015 21:59:27 +0100 Subject: [tyndur-devel] [PATCH] Added script to automatically build a lpt-repo In-Reply-To: <1421524579-10010-1-git-send-email-littlefox@fsfe.org> References: <1421524579-10010-1-git-send-email-littlefox@fsfe.org> Message-ID: <20150117205926.GA13495@silvanus> On Sat, Jan 17, 2015 at 08:56:19PM +0100, Moritz Grosch (LittleFox) wrote: > From: "Moritz Grosch (LittleFox)" > > This script builds a lpt-repository from the lbuilds packages-directory > and automatically generates an index. > > Currently it doesn't set a real description and is limited to i386. Kannst du deine Patches nochmal mit Signed-off-by und deutschen Commitkommentaren schicken? Beim anderen Patch dürften auch 512 MB für die nächste Zeit reichen. > +PACKAGE_DIRECTORY=$1 > +DESTINATION_DIRECTORY=$2 > + > +if [ ! -d "$DESTINATION_DIRECTORY" ]; then > + mkdir -p "$DESTINATION_DIRECTORY" > +else > + rm -rf $DESTINATION_DIRECTORY/* > +fi > + > +for file in $PACKAGE_DIRECTORY/* > +do > + extension=${file##*.} > + > + if [ $extension == "tar" ] > + then Wie wäre es mit 'for file in $PACKAGE_DIRECTORY/*.tar'? Oder wäre das zu einfach? ;-) > + filename=${file##*/} > + filenamewithoutsuffix=${file%.*} > + packagename=${filename%-*} > + packageversion=${filenamewithoutsuffix##*-} > + > + if [[ $packagename == lib* ]]; then > + type="lib" > + else > + type="bin" > + fi > + > + echo "P $packagename" >> "$DESTINATION_DIRECTORY/packages.i386" > + echo "D no description" >> "$DESTINATION_DIRECTORY/packages.i386" > + echo "S $type" >> "$DESTINATION_DIRECTORY/packages.i386" > + echo "V $packageversion" >> "$DESTINATION_DIRECTORY/packages.i386" > + echo "s $(ls -l $PACKAGE_DIRECTORY | grep $filename | awk '{print $5}')" >> "$DESTINATION_DIRECTORY/packages.i386" Und hier 'ls -l $file | awk ...'? > + > + echo "" >> "$DESTINATION_DIRECTORY/packages.i386" > + > + cp "$file" "$DESTINATION_DIRECTORY/$packagename-$type-$packageversion-i386.tar" > + fi > +done Kevin From littlefox at fsfe.org Sat Jan 17 22:34:36 2015 From: littlefox at fsfe.org (Moritz Grosch (LittleFox)) Date: Sat, 17 Jan 2015 22:34:36 +0100 Subject: [tyndur-devel] [PATCH] Script zum Erzeugen eines LPT-Repositories In-Reply-To: <20150117205926.GA13495@silvanus> References: <20150117205926.GA13495@silvanus> Message-ID: <1421530476-710-1-git-send-email-littlefox@fsfe.org> From: "Moritz Grosch (LittleFox)" Generiert ein LPT-Repository aus dem packages-Ordner von lbuilds. Signed-off-by: Moritz Grosch (LittleFox) --- build/scripts/lpt_index.sh | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100755 build/scripts/lpt_index.sh diff --git a/build/scripts/lpt_index.sh b/build/scripts/lpt_index.sh new file mode 100755 index 0000000..94bd42a --- /dev/null +++ b/build/scripts/lpt_index.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +if [ "$1" == "" -o "$2" == "" ]; then + echo "Usage: lpt-index.sh " + exit -1 +fi + +PACKAGE_DIRECTORY=$1 +DESTINATION_DIRECTORY=$2 + +if [ ! -d "$DESTINATION_DIRECTORY" ]; then + mkdir -p "$DESTINATION_DIRECTORY" +else + rm -rf $DESTINATION_DIRECTORY/* +fi + +for file in $PACKAGE_DIRECTORY/*.tar +do + extension=${file##*.} + + filename=${file##*/} + filenamewithoutsuffix=${file%.*} + packagename=${filename%-*} + packageversion=${filenamewithoutsuffix##*-} + + if [[ $packagename == lib* ]]; then + type="lib" + else + type="bin" + fi + + echo "P $packagename" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "D no description" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "S $type" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "V $packageversion" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "s $(ls -l $file | awk '{print $5}')" >> "$DESTINATION_DIRECTORY/packages.i386" + echo "" >> "$DESTINATION_DIRECTORY/packages.i386" + + cp "$file" "$DESTINATION_DIRECTORY/$packagename-$type-$packageversion-i386.tar" +done -- 1.7.10.4 From kevin at tyndur.org Sat Jan 17 23:27:45 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sat, 17 Jan 2015 23:27:45 +0100 Subject: [tyndur-devel] [PATCH] Script zum Erzeugen eines LPT-Repositories In-Reply-To: <1421530476-710-1-git-send-email-littlefox@fsfe.org> References: <20150117205926.GA13495@silvanus> <1421530476-710-1-git-send-email-littlefox@fsfe.org> Message-ID: <20150117222744.GB13495@silvanus> On Sat, Jan 17, 2015 at 10:34:36PM +0100, Moritz Grosch (LittleFox) wrote: > From: "Moritz Grosch (LittleFox)" > > Generiert ein LPT-Repository aus dem packages-Ordner von lbuilds. > > Signed-off-by: Moritz Grosch (LittleFox) Danke, ist drin. Kevin From littlefox at fsfe.org Sat Jan 17 23:28:42 2015 From: littlefox at fsfe.org (Moritz Grosch (LittleFox)) Date: Sat, 17 Jan 2015 23:28:42 +0100 Subject: [tyndur-devel] [PATCH] Script zum Erzeugen eines LPT-Repositories In-Reply-To: <20150117222744.GB13495@silvanus> References: <20150117205926.GA13495@silvanus> <1421530476-710-1-git-send-email-littlefox@fsfe.org> <20150117222744.GB13495@silvanus> Message-ID: <54BAE21A.4060606@fsfe.org> OK :) Der IRC-Bot hat es ja schon vermeldet^^ Am 17.01.15 um 23:27 schrieb Kevin Wolf: > On Sat, Jan 17, 2015 at 10:34:36PM +0100, Moritz Grosch (LittleFox) wrote: >> From: "Moritz Grosch (LittleFox)" >> >> Generiert ein LPT-Repository aus dem packages-Ordner von lbuilds. >> >> Signed-off-by: Moritz Grosch (LittleFox) > Danke, ist drin. > > Kevin > _______________________________________________ > tyndur-devel mailing list > tyndur-devel at tyndur.org > http://list.tyndur.org/mailman/listinfo/tyndur-devel > From kevin at tyndur.org Sun Jan 25 17:21:17 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 25 Jan 2015 17:21:17 +0100 Subject: [tyndur-devel] [PATCH 0/4] Blockierendes Lesen Message-ID: <1422202881-18830-1-git-send-email-kevin@tyndur.org> Überraschenderweise scheint dabei nicht viel offensichtliches kaputtgegangen zu sein. Als nächstes müsste man noch waitpid() fixen, dann müssten sich die 100% CPU erledigt haben. :-) Kevin Wolf (4): libc: lio_compat_tell() auslagern libc: LIOv2 in lio_compat_eof() abfangen Pascal-RTL: lio_compat_* statt stdio.h-Funktionen benutzen kernel2: Blockierendes Lesen src/kernel2/include/tasks.h | 1 + src/kernel2/src/lostio/client.c | 39 ++++++++- src/kernel2/src/lostio/include/lostio_int.h | 11 +++ src/kernel2/src/lostio/tree.c | 6 ++ src/kernel2/src/syscalls/lio_server.c | 5 +- src/modules/include/lostio.h | 3 + src/modules/lib/lostio/client/file.c | 5 ++ src/modules/lib/lostio/client/seek.c | 33 ++++++- src/modules/lib/stdlibc/file.c | 25 +----- src/modules/pas/lib/rtl/sysfile.inc | 130 ++++++++++++++++++---------- src/modules/pas/lib/rtl/system.pas | 15 ++-- 11 files changed, 192 insertions(+), 81 deletions(-) -- 2.1.2 From kevin at tyndur.org Sun Jan 25 17:21:18 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 25 Jan 2015 17:21:18 +0100 Subject: [tyndur-devel] [PATCH 1/4] libc: lio_compat_tell() auslagern In-Reply-To: <1422202881-18830-1-git-send-email-kevin@tyndur.org> References: <1422202881-18830-1-git-send-email-kevin@tyndur.org> Message-ID: <1422202881-18830-2-git-send-email-kevin@tyndur.org> * libc: Bisher hatte ftell() direkt die Funktionalität, um sowohl auf LIOv1 als auch LIOv2 die Position zurückgeben zu können. Wenn man es raussplittet, ist nicht nur der Code sauberer, sondern man kann es auch ohne stdio.h benutzen. Signed-off-by: Kevin Wolf --- src/modules/include/lostio.h | 3 +++ src/modules/lib/lostio/client/seek.c | 33 ++++++++++++++++++++++++++++++++- src/modules/lib/stdlibc/file.c | 25 ++++--------------------- 3 files changed, 39 insertions(+), 22 deletions(-) diff --git a/src/modules/include/lostio.h b/src/modules/include/lostio.h index 5846be6..58fe314 100644 --- a/src/modules/include/lostio.h +++ b/src/modules/include/lostio.h @@ -239,6 +239,9 @@ int lio_compat_eof(io_resource_t* io_res); /// Stream-Position setzen bool lio_compat_seek(io_resource_t* io_res, uint64_t offset, int origin); +/// Stream-Position abfragen +int64_t lio_compat_tell(io_resource_t* io_res); + /****************************************************************************** * LIO2-Server * diff --git a/src/modules/lib/lostio/client/seek.c b/src/modules/lib/lostio/client/seek.c index 94d05cc..c7fdcf0 100644 --- a/src/modules/lib/lostio/client/seek.c +++ b/src/modules/lib/lostio/client/seek.c @@ -30,7 +30,8 @@ #include #include #include -#include +#include +#include static bool newlio_flseek(io_resource_t* io_res, uint64_t offset, int origin) { @@ -75,3 +76,33 @@ bool lio_compat_seek(io_resource_t* io_res, uint64_t offset, int origin) (char*) &seek_request) == 0); } +/** + * Aktuelle Cursorposition im Dateihandle abfragen + * + * @param io_res Dateihandle + * @return Aktuelle Position in Bytes vom Dateianfang oder -1 bei Fehler + */ +int64_t lio_compat_tell(io_resource_t* io_res) +{ + io_tell_request_t tell_request; + long result; + + if (IS_LIO2(io_res)) { + int64_t pos = lio_seek(io_res->lio2_stream, 0, LIO_SEEK_CUR); + return (pos < 0 ? -1 : pos); + } + + tell_request.id = io_res->id; + + //Da fuer qwords keine Funktion existiert um sie direkt uber RPC zu + // empfangen, muss hier ein kleiner Umweg gemacht werden. + response_t* resp = rpc_get_response(io_res->pid, "IO_TELL ", + sizeof(io_tell_request_t), (char*) &(tell_request)); + memcpy(&result, resp->data, sizeof(long)); + + //Antwort und Daten wieder freigeben + free(resp->data); + free(resp); + + return result; +} diff --git a/src/modules/lib/stdlibc/file.c b/src/modules/lib/stdlibc/file.c index fc99e17..7482c41 100644 --- a/src/modules/lib/stdlibc/file.c +++ b/src/modules/lib/stdlibc/file.c @@ -666,29 +666,12 @@ 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); - result = (pos < 0 ? -1 : pos); - goto out; + if (!IS_LIO2_FILE(io_res)) { + //Sonst könnte die Angabe falsch sein + fflush(io_res); } - io_tell_request_t tell_request; - tell_request.id = io_res->res->id; - - //Sonst könnte die Angabe falsch sein - fflush(io_res); - - //Da fuer qwords keine Funktion existiert um sie direkt uber RPC zu - // empfangen, muss hier ein kleiner Umweg gemacht werden. - response_t* resp = rpc_get_response(io_res->res->pid, "IO_TELL ", - sizeof(io_tell_request_t), (char*) &(tell_request)); - memcpy(&result, resp->data, sizeof(long)); - - //Antwort und Daten wieder freigeben - free(resp->data); - free(resp); - -out: + result = lio_compat_tell(io_res->res); if (result >= 0) { result += io_res->buffer_pos - io_res->ungetc_count; if (result < 0) { -- 2.1.2 From kevin at tyndur.org Sun Jan 25 17:21:19 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 25 Jan 2015 17:21:19 +0100 Subject: [tyndur-devel] [PATCH 2/4] libc: LIOv2 in lio_compat_eof() abfangen In-Reply-To: <1422202881-18830-1-git-send-email-kevin@tyndur.org> References: <1422202881-18830-1-git-send-email-kevin@tyndur.org> Message-ID: <1422202881-18830-3-git-send-email-kevin@tyndur.org> ! libc: lio_compat_eof() bleibt bisher hängen, wenn man es auf einer LIOv2-Ressource benutzt, weil es einen LIOv1-Request schickt und dann vergeblich auf die Antwort wartet. LIOv2-Ressourcen sind einfach nie EOF. Signed-off-by: Kevin Wolf --- src/modules/lib/lostio/client/file.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/modules/lib/lostio/client/file.c b/src/modules/lib/lostio/client/file.c index 45e7871..fabf7bc 100644 --- a/src/modules/lib/lostio/client/file.c +++ b/src/modules/lib/lostio/client/file.c @@ -324,6 +324,11 @@ ssize_t lio_compat_write(const void* src, size_t blocksize, size_t blockcount, int lio_compat_eof(io_resource_t* io_res) { io_eof_request_t eof_request; + + if (IS_LIO2(io_res)) { + return 0; + } + eof_request.id = io_res->id; return rpc_get_dword(io_res->pid, "IO_EOF ", sizeof(io_eof_request_t), -- 2.1.2 From kevin at tyndur.org Sun Jan 25 17:21:20 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 25 Jan 2015 17:21:20 +0100 Subject: [tyndur-devel] [PATCH 3/4] Pascal-RTL: lio_compat_* statt stdio.h-Funktionen benutzen In-Reply-To: <1422202881-18830-1-git-send-email-kevin@tyndur.org> References: <1422202881-18830-1-git-send-email-kevin@tyndur.org> Message-ID: <1422202881-18830-4-git-send-email-kevin@tyndur.org> * Pascal-RTL: Benutzt jetzt direkt lio_compat_*. Doppelt Puffern ist Blödsinn und sobald fread() blockiert wie es sollte, ist es vollends unbrauchbar für unsere Zwecke. Signed-off-by: Kevin Wolf --- src/modules/pas/lib/rtl/sysfile.inc | 130 +++++++++++++++++++++++------------- src/modules/pas/lib/rtl/system.pas | 15 +++-- 2 files changed, 91 insertions(+), 54 deletions(-) diff --git a/src/modules/pas/lib/rtl/sysfile.inc b/src/modules/pas/lib/rtl/sysfile.inc index b0cd787..7d731a1 100644 --- a/src/modules/pas/lib/rtl/sysfile.inc +++ b/src/modules/pas/lib/rtl/sysfile.inc @@ -3,25 +3,34 @@ const SEEK_CUR = 1; SEEK_END = 2; -function c_fopen(filename, mode: PChar): THandle; cdecl; external name 'fopen'; -function c_fclose(f: THandle): integer; cdecl; external name 'fclose'; - -function c_fwrite(src: Pointer; blocksize, blockcount: TSize; f: THandle): TSize; cdecl; external name 'fwrite'; -function c_fread(dest: Pointer; blocksize, blockcount: TSize; f: THandle): TSize; cdecl; external name 'fread'; -function c_fseek(f: THandle; offset, whence: longint): longint; cdecl; external name 'fseek'; -function c_ftell(f: THandle): TSize; cdecl; external name 'ftell'; +const + IO_OPEN_MODE_READ = 1; + IO_OPEN_MODE_WRITE = 2; + IO_OPEN_MODE_APPEND = 4; + IO_OPEN_MODE_TRUNC = 8; + IO_OPEN_MODE_DIRECTORY = 16; + IO_OPEN_MODE_CREATE = 32; + IO_OPEN_MODE_LINK = 64; + IO_OPEN_MODE_SYNC = 128; -function c_feof(f: THandle): boolean; cdecl; external name 'feof'; +const + EAGAIN = 18; -function c_setvbuf(f: THandle; buf: Pointer; mode: integer; size: TSize): - integer; cdecl; external name 'setvbuf'; +function lio_compat_open(filename: PChar; mode: byte): THandle; cdecl; external name 'lio_compat_open'; +function lio_compat_close(io_res: THandle): integer; cdecl; external name 'lio_compat_close'; +function lio_compat_read(dest: Pointer; blocksize, blockcount: TSize; io_res: THandle): TSSize; cdecl; external name 'lio_compat_read'; +function lio_compat_readahead(dest: Pointer; size: TSize; io_res: THandle): TSSize; cdecl; external name 'lio_compat_readahead'; +function lio_compat_write(src: Pointer; blocksize, blockcount: TSize; io_res: THandle): TSSize; cdecl; external name 'lio_compat_write'; +function lio_compat_eof(io_res: THandle): integer; cdecl; external name 'lio_compat_eof'; +function lio_compat_seek(io_res: THandle; offset: qword; origin: integer): boolean; cdecl; external name 'lio_compat_seek'; +function lio_compat_tell(io_res: THandle): int64; cdecl; external name 'lio_compat_tell'; { TODO errno setzen nicht vergessen } Procedure Do_Close(f: THandle); begin - c_fclose(f); + lio_compat_close(f); end; Procedure Do_Erase(p:pchar); @@ -37,49 +46,70 @@ begin { TODO } end; Function Do_Write(f: THandle; src: Pointer; len: TSize): TSize; var - ret: TSize; + ret: TSSize; begin - InOutRes := 0; - - Do_Write := 0; - while len > 0 do begin - ret := c_fwrite(src, 1, len, f); - if (ret = 0) or (ret > len) then begin - InOutRes := 101; - exit(0); - end; - - Inc(Do_Write, ret); - Inc(src, ret); - Dec(len, ret); + ret := lio_compat_write(src, 1, len, f); + if ret < 0 then begin + InOutRes := 101; + Do_Write := 0; + end else begin + InOutRes := 0; + Do_Write := ret; end; end; Function Do_Read(f: THandle; dest: Pointer; len: TSize): TSize; +var + ret: TSSize; begin InOutRes := 0; - repeat - Do_Read := c_fread(dest, 1, len, f); - until (Do_Read <> 0) or (c_feof(f)); + ret := lio_compat_read(dest, 1, len, f); + if ret < 0 then begin + InOutRes := 101; + exit(0); + end else begin + Do_Read := ret; + end; end; function Do_FilePos(f: THandle): TSize; +var + ret: int64; begin InOutRes := 0; - Do_FilePos := c_ftell(f); + ret := lio_compat_tell(f); + if ret < 0 then begin + InOutRes := 101; + exit(0); + end else begin + exit(ret); + end; end; Procedure Do_Seek(f: THandle; position: TSize); +var + ret: boolean; begin InOutRes := 0; - c_fseek(f, position, SEEK_SET); + ret := lio_compat_seek(f, position, SEEK_SET); + if not ret then begin + InOutRes := 101; + end; end; Function Do_SeekEnd(f: THandle): TSize; +var + ret: boolean; begin InOutRes := 0; - Do_SeekEnd := c_fseek(f, 0, SEEK_END); + ret := lio_compat_seek(f, 0, SEEK_END); + if not ret then begin + InOutRes := 101; + exit(0); + end else begin + exit(Do_FilePos(f)); + end; end; Function Do_FileSize(f: THandle): Longint; @@ -95,7 +125,8 @@ end; Procedure Do_Open(var f; name: PChar; flags: longint); var - c_mode: string[3]; + c_mode: byte; + autoclose: boolean; append: boolean; trunc: boolean; frec: ^FileRec; @@ -103,50 +134,55 @@ begin InOutRes := 0; frec := @FileRec(f); + append := (flags and $100 <> 0); + trunc := (flags and $1000 <> 0); + autoclose := (flags and $10000 <> 0); + // Wenn eine Datei noch geoeffnet ist, muss sie zuerst // geschlossen werden. - if (frec^.mode = fminput) or (frec^.mode = fmoutput) or (frec^.mode = fminout) then begin + if autoclose + and ((frec^.mode = fminput) or (frec^.mode = fmoutput) or (frec^.mode = fminout)) + and (frec^.handle <> 0) + then begin Do_Close(frec^.handle); end; - - append := (flags and $100 <> 0); - trunc := (flags and $1000 <> 0); if name <> '' then begin // Eine normale Datei case flags and 3 of 0: begin - c_mode := 'r'#0; + c_mode := IO_OPEN_MODE_READ; frec^.mode := fmInput; end; 1: begin + c_mode := IO_OPEN_MODE_WRITE; if append then begin - c_mode := 'a'#0 - end else begin - c_mode := 'w'#0; + c_mode := c_mode or IO_OPEN_MODE_APPEND; + end else if trunc then begin + c_mode := c_mode or IO_OPEN_MODE_CREATE or IO_OPEN_MODE_TRUNC; end; frec^.mode := fmOutput; end; - 2: begin + 2: begin if append then begin - c_mode := 'a+'#0 + c_mode := IO_OPEN_MODE_READ or IO_OPEN_MODE_WRITE + or IO_OPEN_MODE_CREATE or IO_OPEN_MODE_APPEND; end else if trunc then begin - c_mode := 'w+'#0 + c_mode := IO_OPEN_MODE_READ or IO_OPEN_MODE_WRITE + or IO_OPEN_MODE_CREATE or IO_OPEN_MODE_TRUNC; end else begin - c_mode := 'r+'#0; + c_mode := IO_OPEN_MODE_READ or IO_OPEN_MODE_WRITE; end; frec^.mode := fmInOut; end; end; - frec^.handle := c_fopen(name, @c_mode[1]); + frec^.handle := lio_compat_open(name, c_mode); if frec^.handle = 0 then begin InOutRes := 2; - end else begin - c_setvbuf(frec^.handle, nil, 1, 0); end; end else begin diff --git a/src/modules/pas/lib/rtl/system.pas b/src/modules/pas/lib/rtl/system.pas index a658a37..14661a3 100644 --- a/src/modules/pas/lib/rtl/system.pas +++ b/src/modules/pas/lib/rtl/system.pas @@ -12,6 +12,7 @@ interface type TSize = dword; + TSSize = longint; const LineEnding = #10; @@ -48,7 +49,7 @@ const DefaultTextLineBreakStyle : TTextLineBreakStyle = tlbsLF; var - argc: dword; + argc: integer; argv: PPChar; commandline: PChar; @@ -168,9 +169,9 @@ function c_setvbuf(f: Pointer; buf: Pointer; mode: integer; size: TSize): integer; cdecl; external name 'setvbuf'; var - c_stdin: dword; external name 'stdin'; - c_stdout: dword; external name 'stdout'; - c_stderr: dword; external name 'stderr'; + c_stdin: ^dword; external name 'stdin'; + c_stdout: ^dword; external name 'stdout'; + c_stderr: ^dword; external name 'stderr'; procedure SysInitStdIO; (* @@ -200,9 +201,9 @@ begin c_stdio_init(); - StdInputHandle := c_stdin; - StdOutputHandle := c_stdout; - StdErrorHandle := c_stderr; + StdInputHandle := c_stdin^; + StdOutputHandle := c_stdout^; + StdErrorHandle := c_stderr^; c_setvbuf(c_stdout, nil, 1, 0); -- 2.1.2 From kevin at tyndur.org Sun Jan 25 17:21:21 2015 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 25 Jan 2015 17:21:21 +0100 Subject: [tyndur-devel] [PATCH 4/4] kernel2: Blockierendes Lesen In-Reply-To: <1422202881-18830-1-git-send-email-kevin@tyndur.org> References: <1422202881-18830-1-git-send-email-kevin@tyndur.org> Message-ID: <1422202881-18830-5-git-send-email-kevin@tyndur.org> + kernel2: lio_(p)read() blockiert jetzt, wenn es gar nichts lesen kann, aber moredata noch gesetzt ist (d.h. es sonst -EAGAIN zurückgeben würde). Solange man sich nicht einloggt, verbraten die getterms jetzt nicht mehr 100% CPU um die Tastatur zu pollen, sondern der Idle-Thread kommt zum Zug. Signed-off-by: Kevin Wolf --- src/kernel2/include/tasks.h | 1 + src/kernel2/src/lostio/client.c | 39 ++++++++++++++++++++++++++--- src/kernel2/src/lostio/include/lostio_int.h | 11 ++++++++ src/kernel2/src/lostio/tree.c | 6 +++++ src/kernel2/src/syscalls/lio_server.c | 5 +++- 5 files changed, 57 insertions(+), 5 deletions(-) diff --git a/src/kernel2/include/tasks.h b/src/kernel2/include/tasks.h index e17d22b..8fac5ad 100644 --- a/src/kernel2/include/tasks.h +++ b/src/kernel2/include/tasks.h @@ -52,6 +52,7 @@ #define PM_STATUS_WAIT_FOR_RPC 3 #define PM_STATUS_WAIT_FOR_LIO 4 #define PM_STATUS_WAIT_FOR_IO_REQUEST 5 +#define PM_STATUS_WAIT_FOR_DATA 6 typedef struct pm_process { /// Die eindeutige Prozessnummer diff --git a/src/kernel2/src/lostio/client.c b/src/kernel2/src/lostio/client.c index db98df1..df425f2 100644 --- a/src/kernel2/src/lostio/client.c +++ b/src/kernel2/src/lostio/client.c @@ -302,11 +302,12 @@ ssize_t lio_read(struct lio_stream* s, size_t bytes, void* buf) /** * Liest aus einem Stream aus, ohne die Position des streams zu benutzen oder - * zu veraendern. + * zu veraendern. Diese Funktion blockiert nie, sondern gibt -EAGAIN zurück, + * wenn es nichts zu lesen gibt. * * @return Anzahl der gelesenen Bytes oder negativ im Fehlerfall */ -ssize_t lio_pread(struct lio_stream* s, uint64_t offset, size_t bytes, +ssize_t lio_pread_nonblock(struct lio_stream* s, uint64_t offset, size_t bytes, void* buf) { ssize_t ret = 0; @@ -361,6 +362,36 @@ ssize_t lio_pread(struct lio_stream* s, uint64_t offset, size_t bytes, return ret; } +static void lio_pread_unblock_cb(void* opaque) +{ + pm_thread_t* t = opaque; + + BUG_ON(t->status != PM_STATUS_WAIT_FOR_DATA); + t->status = PM_STATUS_READY; +} + +/** + * Liest aus einem Stream aus, ohne die Position des streams zu benutzen oder + * zu veraendern. Diese Funktion blockiert, bis etwas gelesen werden kann. + * + * @return Anzahl der gelesenen Bytes oder negativ im Fehlerfall + */ +ssize_t lio_pread(struct lio_stream* s, uint64_t offset, size_t bytes, + void* buf) +{ + ssize_t ret; + + ret = lio_pread_nonblock(s, offset, bytes, buf); + while (ret == -EAGAIN) { + notifier_add(&s->res_read->on_resize, + lio_pread_unblock_cb, current_thread, true); + pm_scheduler_kern_yield(0, PM_STATUS_WAIT_FOR_DATA); + ret = lio_pread_nonblock(s, offset, bytes, buf); + } + + return ret; +} + /** * Schreibt in einen Stream * @@ -447,7 +478,7 @@ ssize_t lio_pwrite(struct lio_stream* s, uint64_t offset, size_t bytes, // Offset zeigt jetzt auf das erste Byte nach dem letzten geschriebenen if (ret > 0){ if (res->size < offset) { - res->size = offset; + lio_resource_update_size(res, offset); } } @@ -583,7 +614,7 @@ int lio_truncate(struct lio_stream* s, uint64_t size) /* Anschliessend die Ressourcengroesse anpassen (drv->truncate kann das * u.U. auch schon gemacht haben) */ - res->size = size; + lio_resource_update_size(res, size); return 0; } diff --git a/src/kernel2/src/lostio/include/lostio_int.h b/src/kernel2/src/lostio/include/lostio_int.h index 4feb05c..f6a5ed1 100644 --- a/src/kernel2/src/lostio/include/lostio_int.h +++ b/src/kernel2/src/lostio/include/lostio_int.h @@ -40,6 +40,7 @@ #include #include "lostio/core.h" +#include "notifier.h" #include "tasks.h" #define ROUND_TO_NEXT_BLOCK(bytes, blocksize) \ @@ -180,6 +181,13 @@ struct lio_resource { bool resolvable; bool retargetable; + /** + * Wird aufgerufen, wenn sich die Größe einer Ressource ändert (dies + * schließt Fälle ein, in denen moredata von true zu false wechselt, wenn + * dann statt -EGAIN das Dateiende gemeldet wird. + */ + struct notifier* on_resize; + /** Id der Ressource fuer Userspace-Programme */ lio_usp_resource_t usp_id; @@ -281,6 +289,9 @@ void lio_resource_remove_child(struct lio_resource* parent, struct lio_node* lio_create_node(struct lio_resource* parent, struct lio_resource* res, const char* name); +/** Größe aktualisieren und on_size-Notifier ausführen */ +void lio_resource_update_size(struct lio_resource* res, uint64_t size); + /** Weist einer Ressource eine Userspace-ID zu */ void lio_usp_add_resource(struct lio_resource* res); diff --git a/src/kernel2/src/lostio/tree.c b/src/kernel2/src/lostio/tree.c index 60140d5..f53c9cd 100644 --- a/src/kernel2/src/lostio/tree.c +++ b/src/kernel2/src/lostio/tree.c @@ -367,3 +367,9 @@ struct lio_node* lio_create_node(struct lio_resource* parent, return n; } +/** Größe aktualisieren und on_size-Notifier ausführen */ +void lio_resource_update_size(struct lio_resource* res, uint64_t size) +{ + res->size = size; + notify(res->on_resize); +} diff --git a/src/kernel2/src/syscalls/lio_server.c b/src/kernel2/src/syscalls/lio_server.c index 0ead479..5127d7a 100644 --- a/src/kernel2/src/syscalls/lio_server.c +++ b/src/kernel2/src/syscalls/lio_server.c @@ -262,7 +262,6 @@ int syscall_lio_srv_res_upload(struct lio_server_resource* resource) } res->tree = lio_usp_get_tree(resource->tree); - res->size = resource->size; res->blocksize = resource->blocksize; res->readable = ((resource->flags & LIO_SRV_READABLE) ? 1 : 0); res->writable = ((resource->flags & LIO_SRV_WRITABLE) ? 1 : 0); @@ -278,6 +277,10 @@ int syscall_lio_srv_res_upload(struct lio_server_resource* resource) } res->opaque = resource->opaque; + /* Auch aufrufen falls sich die Größe nicht geändert hat: moredata könnte + * von true auf false gewechselt sein. */ + lio_resource_update_size(res, resource->size); + return 0; } -- 2.1.2