WebSVN – HelenOS – Path Comparison – / – /branches/tracing/uspace/srv/ Rev 3425 and /branches/tracing/uspace/srv Rev 3424

Ignore whitespace Rev 3425 → Rev 3424

/branches/tracing/uspace/srv/loader/interp.s
File deleted

/branches/tracing/uspace/srv/loader/include/elf_load.h
File deleted

/branches/tracing/uspace/srv/loader/include/elf.h
File deleted

/branches/tracing/uspace/srv/loader/include/arch.h
File deleted

/branches/tracing/uspace/srv/loader/main.c
File deleted

/branches/tracing/uspace/srv/loader/elf_load.c
File deleted

/branches/tracing/uspace/srv/loader/arch/amd64/Makefile.inc
File deleted

/branches/tracing/uspace/srv/loader/arch/amd64/amd64.s
File deleted

/branches/tracing/uspace/srv/loader/arch/amd64/_link.ld.in
File deleted

/branches/tracing/uspace/srv/loader/arch/mips32/mips32.s
File deleted

/branches/tracing/uspace/srv/loader/arch/mips32/_link.ld.in
File deleted

/branches/tracing/uspace/srv/loader/arch/mips32/Makefile.inc
File deleted

/branches/tracing/uspace/srv/loader/arch/ia32/ia32.s
File deleted

/branches/tracing/uspace/srv/loader/arch/ia32/_link.ld.in
File deleted

/branches/tracing/uspace/srv/loader/arch/ia32/Makefile.inc
File deleted

/branches/tracing/uspace/srv/loader/arch/sparc64/_link.ld.in
File deleted

/branches/tracing/uspace/srv/loader/arch/sparc64/sparc64.s
File deleted

/branches/tracing/uspace/srv/loader/arch/sparc64/Makefile.inc
File deleted

/branches/tracing/uspace/srv/loader/arch/ia64/_link.ld.in
File deleted

/branches/tracing/uspace/srv/loader/arch/ia64/ia64.s
File deleted

/branches/tracing/uspace/srv/loader/arch/ia64/Makefile.inc
File deleted

/branches/tracing/uspace/srv/loader/arch/arm32/Makefile.inc
File deleted

/branches/tracing/uspace/srv/loader/arch/arm32/arm32.s
File deleted

/branches/tracing/uspace/srv/loader/arch/arm32/_link.ld.in
File deleted

/branches/tracing/uspace/srv/loader/arch/ppc32/Makefile.inc
File deleted

/branches/tracing/uspace/srv/loader/arch/ppc32/ppc32.s
File deleted

/branches/tracing/uspace/srv/loader/arch/ppc32/_link.ld.in
File deleted

/branches/tracing/uspace/srv/loader/Makefile
File deleted

 /branches/tracing/uspace/srv/kbd/Makefile
 ,7 → 83,7
 .PHONY: all clean depend disasm links
-all: links $(OUTPUT) $(OUTPUT).disasm
+all: links $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 100,9
 $(OUTPUT): $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(GENARCH_OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(GENERIC_OBJECTS) $(ARCH_OBJECTS) $(GENARCH_OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/tracing/uspace/srv/ns/Makefile
 ,7 → 46,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 59,9
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/tracing/uspace/srv/console/Makefile
 ,7 → 59,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 72,9
 $(OUTPUT): $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(GENERIC_OBJECTS) $(ARCH_OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/tracing/uspace/srv/rd/rd.c
 ,24 → 81,46
     ipc_call_t call;
     int retval;
     void *fs_va = NULL;
-    off_t offset;
-    size_t block_size;
-    size_t maxblock_size;
+    ipcarg_t offset;
     /*
-     * Answer the first IPC_M_CONNECT_ME_TO call.
+     * We allocate VA for communication per connection.
+     * This allows us to potentionally have more clients and work
+     * concurrently.
      */
-    ipc_answer_0(iid, EOK);
+    fs_va = as_get_mappable_page(ALIGN_UP(BLOCK_SIZE, PAGE_SIZE));
+    if (!fs_va) {
+        /*
+         * Hang up the phone if we cannot proceed any further.
+         * This is the answer to the call that opened the connection.
+         */
+        ipc_answer_0(iid, EHANGUP);
+        return;
+    } else {
+        /*
+         * Answer the first IPC_M_CONNECT_ME_TO call.
+         * Return supported block size as ARG1.
+         */
+        ipc_answer_1(iid, EOK, BLOCK_SIZE);
+    }
     /*
      * Now we wait for the client to send us its communication as_area.
      */
+    size_t size;
     int flags;
-    if (ipc_share_out_receive(&callid, &maxblock_size, &flags)) {
-        fs_va = as_get_mappable_page(maxblock_size);
-        if (fs_va) {
+    if (ipc_share_out_receive(&callid, &size, &flags)) {
+        if (size >= BLOCK_SIZE) {
+            /*
+             * The client sends an as_area that can absorb the whole
+             * block.
+             */
             (void) ipc_share_out_finalize(callid, fs_va);
         } else {
+            /*
+             * The client offered as_area too small.
+             * Close the connection.
+             */
             ipc_answer_0(callid, EHANGUP);
             return;
         }
 ,16 → 146,8
             return;
         case RD_READ_BLOCK:
             offset = IPC_GET_ARG1(call);
-            block_size = IPC_GET_ARG2(call);
-            if (block_size > maxblock_size) {
+            if (offset * BLOCK_SIZE > rd_size - BLOCK_SIZE) {
                 /*
-                 * Maximum block size exceeded.
-                 */
-                retval = ELIMIT;
-                break;
-            }
-            if (offset * block_size > rd_size - block_size) {
-                /*
                  * Reading past the end of the device.
                  */
                 retval = ELIMIT;
 ,22 → 154,14
                 break;
             }
             futex_down(&rd_futex);
-            memcpy(fs_va, rd_addr + offset * block_size, block_size);
+            memcpy(fs_va, rd_addr + offset * BLOCK_SIZE, BLOCK_SIZE);
             futex_up(&rd_futex);
             retval = EOK;
             break;
         case RD_WRITE_BLOCK:
             offset = IPC_GET_ARG1(call);
-            block_size = IPC_GET_ARG2(call);
-            if (block_size > maxblock_size) {
+            if (offset * BLOCK_SIZE > rd_size - BLOCK_SIZE) {
                 /*
-                 * Maximum block size exceeded.
-                 */
-                retval = ELIMIT;
-                break;
-            }
-            if (offset * block_size > rd_size - block_size) {
-                /*
                  * Writing past the end of the device.
                  */
                 retval = ELIMIT;
 ,7 → 168,7
                 break;
             }
             futex_up(&rd_futex);
-            memcpy(rd_addr + offset * block_size, fs_va, block_size);
+            memcpy(rd_addr + offset * BLOCK_SIZE, fs_va, BLOCK_SIZE);
             futex_down(&rd_futex);
             retval = EOK;
             break;

 /branches/tracing/uspace/srv/rd/Makefile
 ,7 → 46,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 59,9
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/tracing/uspace/srv/rd/rd.h
 ,6 → 43,8
 #ifndef RD_RD_H_
 #define RD_RD_H_
+#define BLOCK_SIZE  1024    /**< Working block size */
 #define RD_BASE     1024
 #define RD_READ_BLOCK   (RD_BASE + 1)   /**< Method for reading block. */
 #define RD_WRITE_BLOCK  (RD_BASE + 2)   /**< Method for writing block. */

/branches/tracing/uspace/srv/fb/msim.c
File deleted

/branches/tracing/uspace/srv/fb/msim.h
File deleted

 /branches/tracing/uspace/srv/fb/main.c
 ,7 → 37,6
 #include "fb.h"
 #include "ega.h"
-#include "msim.h"
 #include "main.h"
 #define NAME "fb"
 ,26 → 58,20
     printf(NAME ": HelenOS Framebuffer service\n");
     ipcarg_t phonead;
-    bool initialized = false;
+    int initialized = 0;
 #ifdef FB_ENABLED
     if (sysinfo_value("fb.kind") == 1) {
         if (fb_init() == 0)
-            initialized = true;
+            initialized = 1;
     }
 #endif
 #ifdef EGA_ENABLED
-    if ((!initialized) && (sysinfo_value("fb.kind") == 2)) {
+    if (!initialized && sysinfo_value("fb.kind") == 2) {
         if (ega_init() == 0)
-            initialized = true;
+            initialized = 1;
     }
 #endif
-#ifdef MSIM_ENABLED
-    if ((!initialized) && (sysinfo_value("fb.kind") == 3)) {
-        if (msim_init() == 0)
-            initialized = true;
-    }
-#endif
     if (!initialized)
         return -1;

 /branches/tracing/uspace/srv/fb/Makefile
 ,6 → 50,7
         font-8x16.c
     CFLAGS += -DFB_ENABLED
 endif
 ifeq ($(ARCH), ia32)
     SOURCES += ega.c
     CFLAGS += -DEGA_ENABLED
 ,8 → 60,7
     CFLAGS += -DEGA_ENABLED
 endif
 ifeq ($(ARCH), mips32)
-    SOURCES += msim.c
-    CFLAGS += -DMSIM_ENABLED -DFB_INVERT_ENDIAN
+    CFLAGS += -DFB_INVERT_ENDIAN
 endif
 CFLAGS += -D$(ARCH)
 ,7 → 70,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 83,9
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/tracing/uspace/srv/fs/tmpfs/tmpfs.h
 ,12 → 44,6
 #define dprintf(...)    printf(__VA_ARGS__)
 #endif
-typedef enum {
-    TMPFS_NONE,
-    TMPFS_FILE,
-    TMPFS_DIRECTORY
-} tmpfs_dentry_type_t;
 typedef struct tmpfs_dentry {
     fs_index_t index;   /**< TMPFS node index. */
     link_t dh_link;     /**< Dentries hash table link. */
 ,7 → 50,11
     struct tmpfs_dentry *sibling;
     struct tmpfs_dentry *child;
     hash_table_t names; /**< All names linking to this TMPFS node. */
-    tmpfs_dentry_type_t type;
+    enum {
+        TMPFS_NONE,
+        TMPFS_FILE,
+        TMPFS_DIRECTORY
+    } type;
     unsigned lnkcnt;    /**< Link count. */
     size_t size;        /**< File size if type is TMPFS_FILE. */
     void *data;     /**< File content's if type is TMPFS_FILE. */

 /branches/tracing/uspace/srv/fs/tmpfs/tmpfs_dump.c
 ,7 → 39,6
 #include "tmpfs.h"
 #include "../../vfs/vfs.h"
 #include <ipc/ipc.h>
-#include <async.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 ,7 → 50,9
 #include <sys/mman.h>
 #include <byteorder.h>
-#define TMPFS_BLOCK_SIZE    1024
+#define BLOCK_SIZE          1024    // FIXME
+#define RD_BASE             1024    // FIXME
+#define RD_READ_BLOCK   (RD_BASE + 1)
 struct rdentry {
     uint8_t type;
 ,9 → 59,48
     uint32_t len;
 } __attribute__((packed));
+static bool
+tmpfs_blockread(int phone, void *buffer, size_t *bufpos, size_t *buflen,
+    size_t *pos, void *dst, size_t size)
+{
+    size_t offset = 0;
+    size_t left = size;
+    while (left > 0) {
+        size_t rd;
+        if (*bufpos + left < *buflen)
+            rd = left;
+        else
+            rd = *buflen - *bufpos;
+        if (rd > 0) {
+            memcpy(dst + offset, buffer + *bufpos, rd);
+            offset += rd;
+            *bufpos += rd;
+            *pos += rd;
+            left -= rd;
+        }
+        if (*bufpos == *buflen) {
+            ipcarg_t retval;
+            int rc = ipc_call_sync_2_1(phone, RD_READ_BLOCK,
+                *pos / BLOCK_SIZE, BLOCK_SIZE,
+                &retval);
+            if ((rc != EOK) || (retval != EOK))
+                return false;
+            *bufpos = 0;
+            *buflen = BLOCK_SIZE;
+        }
+    }
+    return true;
+}
 static bool
-tmpfs_restore_recursion(int phone, void *block, off_t *bufpos, size_t *buflen,
-    off_t *pos, tmpfs_dentry_t *parent)
+tmpfs_restore_recursion(int phone, void *block, size_t *bufpos, size_t *buflen,
+    size_t *pos, tmpfs_dentry_t *parent)
 {
     struct rdentry entry;
     libfs_ops_t *ops = &tmpfs_libfs_ops;
 ,16 → 110,16
         tmpfs_dentry_t *node;
         uint32_t size;
-        if (!libfs_blockread(phone, block, bufpos, buflen, pos, &entry,
-            sizeof(entry), TMPFS_BLOCK_SIZE))
+        if (!tmpfs_blockread(phone, block, bufpos, buflen, pos, &entry,
+            sizeof(entry)))
             return false;
         entry.len = uint32_t_le2host(entry.len);
         switch (entry.type) {
-        case TMPFS_NONE:
+        case 0:
             break;
-        case TMPFS_FILE:
+        case 1:
             fname = malloc(entry.len + 1);
             if (fname == NULL)
                 return false;
 ,8 → 130,8
                 return false;
             }
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                fname, entry.len, TMPFS_BLOCK_SIZE)) {
+            if (!tmpfs_blockread(phone, block, bufpos, buflen, pos,
+                fname, entry.len)) {
                 ops->destroy((void *) node);
                 free(fname);
                 return false;
 ,8 → 145,8
             }
             free(fname);
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                &size, sizeof(size), TMPFS_BLOCK_SIZE))
+            if (!tmpfs_blockread(phone, block, bufpos, buflen, pos,
+                &size, sizeof(size)))
                 return false;
             size = uint32_t_le2host(size);
 ,12 → 156,12
                 return false;
             node->size = size;
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                node->data, size, TMPFS_BLOCK_SIZE))
+            if (!tmpfs_blockread(phone, block, bufpos, buflen, pos,
+                node->data, size))
                 return false;
             break;
-        case TMPFS_DIRECTORY:
+        case 2:
             fname = malloc(entry.len + 1);
             if (fname == NULL)
                 return false;
 ,8 → 172,8
                 return false;
             }
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                fname, entry.len, TMPFS_BLOCK_SIZE)) {
+            if (!tmpfs_blockread(phone, block, bufpos, buflen, pos,
+                fname, entry.len)) {
                 ops->destroy((void *) node);
                 free(fname);
                 return false;
 ,7 → 195,7
         default:
             return false;
         }
-    } while (entry.type != TMPFS_NONE);
+    } while (entry.type != 0);
     return true;
 }
 ,7 → 204,7
 {
     libfs_ops_t *ops = &tmpfs_libfs_ops;
-    void *block = mmap(NULL, TMPFS_BLOCK_SIZE,
+    void *block = mmap(NULL, BLOCK_SIZE,
         PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
     if (block == NULL)
 ,7 → 214,7
         DEVMAP_CONNECT_TO_DEVICE, dev);
     if (phone < 0) {
-        munmap(block, TMPFS_BLOCK_SIZE);
+        munmap(block, BLOCK_SIZE);
         return false;
     }
 ,13 → 222,12
         EOK)
         goto error;
-    off_t bufpos = 0;
+    size_t bufpos = 0;
     size_t buflen = 0;
-    off_t pos = 0;
+    size_t pos = 0;
     char tag[6];
-    if (!libfs_blockread(phone, block, &bufpos, &buflen, &pos, tag, 5,
-        TMPFS_BLOCK_SIZE))
+    if (!tmpfs_blockread(phone, block, &bufpos, &buflen, &pos, tag, 5))
         goto error;
     tag[5] = 0;
 ,12 → 239,12
         goto error;
     ipc_hangup(phone);
-    munmap(block, TMPFS_BLOCK_SIZE);
+    munmap(block, BLOCK_SIZE);
     return true;
 error:
     ipc_hangup(phone);
-    munmap(block, TMPFS_BLOCK_SIZE);
+    munmap(block, BLOCK_SIZE);
     return false;
 }

 /branches/tracing/uspace/srv/fs/tmpfs/tmpfs_ops.c
 ,7 → 233,7
         hash_table_destroy(&dentries);
         return false;
     }
-    root->lnkcnt = 0;   /* FS root is not linked */
+    root->lnkcnt = 1;
     return true;
 }
 ,12 → 405,11
     if (dev_handle >= 0) {
         if (tmpfs_restore(dev_handle))
-            ipc_answer_3(rid, EOK, root->index, root->size,
-                root->lnkcnt);
+            ipc_answer_0(rid, EOK);
         else
             ipc_answer_0(rid, ELIMIT);
     } else {
-        ipc_answer_3(rid, EOK, root->index, root->size, root->lnkcnt);
+            ipc_answer_0(rid, EOK);
     }
 }

 /branches/tracing/uspace/srv/fs/tmpfs/Makefile
 ,7 → 51,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 64,9
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

/branches/tracing/uspace/srv/fs/fat/fat.h
222,7 → 222,6
extern void fat_mounted(ipc_callid_t, ipc_call_t *);
extern void fat_mount(ipc_callid_t, ipc_call_t *);
extern void fat_lookup(ipc_callid_t, ipc_call_t *);
extern void fat_read(ipc_callid_t, ipc_call_t *);

extern fat_idx_t *fat_idx_get_by_pos(dev_handle_t, fat_cluster_t, unsigned);
extern fat_idx_t *fat_idx_get_by_index(dev_handle_t, fs_index_t);

 /branches/tracing/uspace/srv/fs/fat/fat.c
 ,9 → 107,6
         case VFS_LOOKUP:
             fat_lookup(callid, &call);
             break;
-        case VFS_READ:
-            fat_read(callid, &call);
-            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;

 /branches/tracing/uspace/srv/fs/fat/fat_ops.c
 ,8 → 39,6
 #include "../../vfs/vfs.h"
 #include <libfs.h>
 #include <ipc/ipc.h>
-#include <ipc/services.h>
-#include <ipc/devmap.h>
 #include <async.h>
 #include <errno.h>
 #include <string.h>
 ,10 → 47,8
 #include <libadt/list.h>
 #include <assert.h>
 #include <futex.h>
-#include <sys/mman.h>
 #define BS_BLOCK        0
-#define BS_SIZE         512
 /** Futex protecting the list of cached free FAT nodes. */
 static futex_t ffn_futex = FUTEX_INITIALIZER;
 ,15 → 66,15
 #define FAT_DENTRY_DOT      0x2e
 #define FAT_DENTRY_ERASED   0xe5
-#define min(a, b)       ((a) < (b) ? (a) : (b))
 static void dentry_name_canonify(fat_dentry_t *d, char *buf)
 {
     int i;
     for (i = 0; i < FAT_NAME_LEN; i++) {
-        if (d->name[i] == FAT_PAD)
+        if (d->name[i] == FAT_PAD) {
+            buf++;
             break;
+        }
         if (d->name[i] == FAT_DENTRY_E5_ESC)
             *buf++ = 0xe5;
         else
 ,55 → 92,21
         else
             *buf++ = d->ext[i];
     }
-    *buf = '\0';
 }
-static int dev_phone = -1;      /* FIXME */
-static void *dev_buffer = NULL;     /* FIXME */
 /* TODO move somewhere else */
 typedef struct {
     void *data;
-    size_t size;
 } block_t;
-static block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
+static block_t *block_get(dev_handle_t dev_handle, off_t offset)
 {
-    /* FIXME */
-    block_t *b;
-    off_t bufpos = 0;
-    size_t buflen = 0;
-    off_t pos = offset * bs;
-    assert(dev_phone != -1);
-    assert(dev_buffer);
-    b = malloc(sizeof(block_t));
-    if (!b)
-        return NULL;
-    b->data = malloc(bs);
-    if (!b->data) {
-        free(b);
-        return NULL;
-    }
-    b->size = bs;
-    if (!libfs_blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos,
-        b->data, bs, bs)) {
-        free(b->data);
-        free(b);
-        return NULL;
-    }
-    return b;
+    return NULL;    /* TODO */
 }
 static void block_put(block_t *block)
 {
-    /* FIXME */
-    free(block->data);
-    free(block);
+    /* TODO */
 }
 #define FAT_BS(b)       ((fat_bs_t *)((b)->data))
 ,7 → 143,7
     fat_cluster_t clst = firstc;
     unsigned i;
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
+    bb = block_get(dev_handle, BS_BLOCK);
     bps = uint16_t_le2host(FAT_BS(bb)->bps);
     spc = FAT_BS(bb)->spc;
     rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
 ,7 → 159,7
     if (firstc == FAT_CLST_ROOT) {
         /* root directory special case */
         assert(offset < rds);
-        b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
+        b = block_get(dev_handle, rscnt + fatcnt * sf + offset);
         return b;
     }
 ,7 → 172,7
         fsec = (clst * sizeof(fat_cluster_t)) / bps;
         fidx = clst % (bps / sizeof(fat_cluster_t));
         /* read FAT1 */
-        b = block_get(dev_handle, rscnt + fsec, bps);
+        b = block_get(dev_handle, rscnt + fsec);
         clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
         assert(clst != FAT_CLST_BAD);
         assert(clst < FAT_CLST_LAST1);
 ,58 → 180,11
     }
     b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
-        offset % spc, bps);
+        offset % spc);
     return b;
 }
-/** Return number of blocks allocated to a file.
- *
- * @param dev_handle    Device handle of the device with the file.
- * @param firstc    First cluster of the file.
- *
- * @return      Number of blocks allocated to the file.
- */
-static uint16_t
-_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
-{
-    block_t *bb;
-    block_t *b;
-    unsigned bps;
-    unsigned spc;
-    unsigned rscnt;     /* block address of the first FAT */
-    unsigned clusters = 0;
-    fat_cluster_t clst = firstc;
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-    spc = FAT_BS(bb)->spc;
-    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
-    block_put(bb);
-    if (firstc == FAT_CLST_RES0) {
-        /* No space allocated to the file. */
-        return 0;
-    }
-    while (clst < FAT_CLST_LAST1) {
-        unsigned fsec;  /* sector offset relative to FAT1 */
-        unsigned fidx;  /* FAT1 entry index */
-        assert(clst >= FAT_CLST_FIRST);
-        fsec = (clst * sizeof(fat_cluster_t)) / bps;
-        fidx = clst % (bps / sizeof(fat_cluster_t));
-        /* read FAT1 */
-        b = block_get(dev_handle, rscnt + fsec, bps);
-        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
-        assert(clst != FAT_CLST_BAD);
-        block_put(b);
-        clusters++;
-    }
-    return clusters * spc;
-}
 static void fat_node_initialize(fat_node_t *node)
 {
     futex_initialize(&node->lock, 1);
 ,7 → 202,7
     block_t *bb;
     uint16_t bps;
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
+    bb = block_get(dev_handle, BS_BLOCK);
     assert(bb != NULL);
     bps = uint16_t_le2host(FAT_BS(bb)->bps);
     block_put(bb);
 ,7 → 253,7
 {
     block_t *b;
     fat_dentry_t *d;
-    fat_node_t *nodep = NULL;
+    fat_node_t *nodep;
     unsigned bps;
     unsigned dps;
 ,7 → 264,7
          */
         futex_down(&idxp->nodep->lock);
         if (!idxp->nodep->refcnt++)
-            list_remove(&idxp->nodep->ffn_link);
+            list_remove(&nodep->ffn_link);
         futex_up(&idxp->nodep->lock);
         return idxp->nodep;
     }
 ,18 → 320,11
          * and initialized elsewhere.
          */
         nodep->type = FAT_DIRECTORY;
-        /*
-         * Unfortunately, the 'size' field of the FAT dentry is not
-         * defined for the directory entry type. We must determine the
-         * size of the directory by walking the FAT.
-         */
-        nodep->size = bps * _fat_blcks_get(idxp->dev_handle,
-            uint16_t_le2host(d->firstc));
     } else {
         nodep->type = FAT_FILE;
-        nodep->size = uint32_t_le2host(d->size);
     }
     nodep->firstc = uint16_t_le2host(d->firstc);
+    nodep->size = uint32_t_le2host(d->size);
     nodep->lnkcnt = 1;
     nodep->refcnt = 1;
 ,7 → 421,7
                 dentry_name_canonify(d, name);
                 break;
             }
-            if (stricmp(name, component) == 0) {
+            if (strcmp(name, component) == 0) {
                 /* hit */
                 void *node;
                 /*
 ,56 → 567,16
 {
     dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     block_t *bb;
-    uint16_t bps;
     uint16_t rde;
     int rc;
-    /*
-     * For now, we don't bother to remember dev_handle, dev_phone or
-     * dev_buffer in some data structure. We use global variables because we
-     * know there will be at most one mount on this file system.
-     * Of course, this is a huge TODO item.
-     */
-    dev_buffer = mmap(NULL, BS_SIZE, PROTO_READ | PROTO_WRITE,
-        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-    if (!dev_buffer) {
-        ipc_answer_0(rid, ENOMEM);
-        return;
-    }
-    dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
-    if (dev_phone < 0) {
-        munmap(dev_buffer, BS_SIZE);
-        ipc_answer_0(rid, dev_phone);
-        return;
-    }
-    rc = ipc_share_out_start(dev_phone, dev_buffer,
-        AS_AREA_READ | AS_AREA_WRITE);
-    if (rc != EOK) {
-            munmap(dev_buffer, BS_SIZE);
-        ipc_answer_0(rid, rc);
-        return;
-    }
     /* Read the number of root directory entries. */
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
+    bb = block_get(dev_handle, BS_BLOCK);
     rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
     block_put(bb);
-    if (bps != BS_SIZE) {
-        munmap(dev_buffer, BS_SIZE);
-        ipc_answer_0(rid, ENOTSUP);
-        return;
-    }
     rc = fat_idx_init_by_dev_handle(dev_handle);
     if (rc != EOK) {
-            munmap(dev_buffer, BS_SIZE);
         ipc_answer_0(rid, rc);
         return;
     }
 ,7 → 584,6
     /* Initialize the root node. */
     fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
     if (!rootp) {
-            munmap(dev_buffer, BS_SIZE);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
         return;
 ,7 → 592,6
     fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
     if (!ridxp) {
-            munmap(dev_buffer, BS_SIZE);
         free(rootp);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
 ,7 → 603,6
     rootp->type = FAT_DIRECTORY;
     rootp->firstc = FAT_CLST_ROOT;
     rootp->refcnt = 1;
-    rootp->lnkcnt = 0;  /* FS root is not linked */
     rootp->size = rde * sizeof(fat_dentry_t);
     rootp->idx = ridxp;
     ridxp->nodep = rootp;
 ,7 → 609,7
     futex_up(&ridxp->lock);
-    ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
+    ipc_answer_0(rid, EOK);
 }
 void fat_mount(ipc_callid_t rid, ipc_call_t *request)
 ,96 → 622,6
     libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
 }
-void fat_read(ipc_callid_t rid, ipc_call_t *request)
-{
-    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
-    off_t pos = (off_t)IPC_GET_ARG3(*request);
-    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
-    uint16_t bps = fat_bps_get(dev_handle);
-    size_t bytes;
-    block_t *b;
-    if (!nodep) {
-        ipc_answer_0(rid, ENOENT);
-        return;
-    }
-    ipc_callid_t callid;
-    size_t len;
-    if (!ipc_data_read_receive(&callid, &len)) {
-        fat_node_put(nodep);
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    if (nodep->type == FAT_FILE) {
-        /*
-         * Our strategy for regular file reads is to read one block at
-         * most and make use of the possibility to return less data than
-         * requested. This keeps the code very simple.
-         */
-        bytes = min(len, bps - pos % bps);
-        b = fat_block_get(nodep, pos / bps);
-        (void) ipc_data_read_finalize(callid, b->data + pos % bps,
-            bytes);
-        block_put(b);
-    } else {
-        unsigned bnum;
-        off_t spos = pos;
-        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
-        fat_dentry_t *d;
-        assert(nodep->type == FAT_DIRECTORY);
-        assert(nodep->size % bps == 0);
-        assert(bps % sizeof(fat_dentry_t) == 0);
-        /*
-         * Our strategy for readdir() is to use the position pointer as
-         * an index into the array of all dentries. On entry, it points
-         * to the first unread dentry. If we skip any dentries, we bump
-         * the position pointer accordingly.
-         */
-        bnum = (pos * sizeof(fat_dentry_t)) / bps;
-        while (bnum < nodep->size / bps) {
-            off_t o;
-            b = fat_block_get(nodep, bnum);
-            for (o = pos % (bps / sizeof(fat_dentry_t));
-                o < bps / sizeof(fat_dentry_t);
-                o++, pos++) {
-                d = ((fat_dentry_t *)b->data) + o;
-                switch (fat_classify_dentry(d)) {
-                case FAT_DENTRY_SKIP:
-                    continue;
-                case FAT_DENTRY_LAST:
-                    block_put(b);
-                    goto miss;
-                default:
-                case FAT_DENTRY_VALID:
-                    dentry_name_canonify(d, name);
-                    block_put(b);
-                    goto hit;
-                }
-            }
-            block_put(b);
-            bnum++;
-        }
-miss:
-        fat_node_put(nodep);
-        ipc_answer_0(callid, ENOENT);
-        ipc_answer_1(rid, ENOENT, 0);
-        return;
-hit:
-        (void) ipc_data_read_finalize(callid, name, strlen(name) + 1);
-        bytes = (pos - spos) + 1;
-    }
-    fat_node_put(nodep);
-    ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
-}
 /**
  * @}
  */

 /branches/tracing/uspace/srv/fs/fat/Makefile
 ,7 → 51,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 64,9
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/tracing/uspace/srv/devmap/Makefile
 ,7 → 50,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 63,9
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

 /branches/tracing/uspace/srv/vfs/vfs_ops.c
 ,11 → 71,8
 {
     dev_handle_t dev_handle;
     vfs_node_t *mp_node = NULL;
-    ipc_callid_t callid;
-    ipc_call_t data;
     int rc;
     int phone;
-    size_t size;
     /*
      * We expect the library to do the device-name to device-handle
 ,6 → 86,9
      * carry mount options in the future.
      */
+    ipc_callid_t callid;
+    size_t size;
     /*
      * Now, we expect the client to send us data with the name of the file
      * system.
 ,30 → 115,15
     fs_name[size] = '\0';
     /*
-     * Wait for IPC_M_PING so that we can return an error if we don't know
-     * fs_name.
-     */
-    callid = async_get_call(&data);
-    if (IPC_GET_METHOD(data) != IPC_M_PING) {
-        ipc_answer_0(callid, ENOTSUP);
-        ipc_answer_0(rid, ENOTSUP);
-        return;
-    }
-    /*
      * Check if we know a file system with the same name as is in fs_name.
      * This will also give us its file system handle.
      */
     fs_handle_t fs_handle = fs_name_to_handle(fs_name, true);
     if (!fs_handle) {
-        ipc_answer_0(callid, ENOENT);
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    /* Acknowledge that we know fs_name. */
-    ipc_answer_0(callid, EOK);
     /* Now, we want the client to send us the mount point. */
     if (!ipc_data_write_receive(&callid, &size)) {
         ipc_answer_0(callid, EINVAL);
 ,12 → 190,6
     } else {
         /* We still don't have the root file system mounted. */
         if ((size == 1) && (buf[0] == '/')) {
-            vfs_lookup_res_t mr_res;
-            vfs_node_t *mr_node;
-            ipcarg_t rindex;
-            ipcarg_t rsize;
-            ipcarg_t rlnkcnt;
             /*
              * For this simple, but important case,
              * we are almost done.
 ,30 → 198,16
             /* Tell the mountee that it is being mounted. */
             phone = vfs_grab_phone(fs_handle);
-            rc = async_req_1_3(phone, VFS_MOUNTED,
-                (ipcarg_t) dev_handle, &rindex, &rsize, &rlnkcnt);
+            rc = async_req_1_0(phone, VFS_MOUNTED,
+                (ipcarg_t) dev_handle);
             vfs_release_phone(phone);
-            if (rc != EOK) {
-                futex_up(&rootfs_futex);
-                ipc_answer_0(rid, rc);
-                return;
+            if (rc == EOK) {
+                rootfs.fs_handle = fs_handle;
+                rootfs.dev_handle = dev_handle;
             }
-            mr_res.triplet.fs_handle = fs_handle;
-            mr_res.triplet.dev_handle = dev_handle;
-            mr_res.triplet.index = (fs_index_t) rindex;
-            mr_res.size = (size_t) rsize;
-            mr_res.lnkcnt = (unsigned) rlnkcnt;
-            rootfs.fs_handle = fs_handle;
-            rootfs.dev_handle = dev_handle;
             futex_up(&rootfs_futex);
-            /* Add reference to the mounted root. */
-            mr_node = vfs_node_get(&mr_res);
-            assert(mr_node);
             ipc_answer_0(rid, rc);
             return;
         } else {
 ,8 → 374,12
 void vfs_close(ipc_callid_t rid, ipc_call_t *request)
 {
     int fd = IPC_GET_ARG1(*request);
-    int rc = vfs_fd_free(fd);
-    ipc_answer_0(rid, rc);
+    if (fd >= MAX_OPEN_FILES) {
+        ipc_answer_0(rid, EBADF);
+        return;
+    }
+    vfs_fd_free(fd);
+    ipc_answer_0(rid, EOK);
 }
 static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)

 /branches/tracing/uspace/srv/vfs/vfs.h
 ,7 → 282,7
 extern bool vfs_files_init(void);
 extern vfs_file_t *vfs_file_get(int);
 extern int vfs_fd_alloc(void);
-extern int vfs_fd_free(int);
+extern void vfs_fd_free(int);
 extern void vfs_file_addref(vfs_file_t *);
 extern void vfs_file_delref(vfs_file_t *);

 /branches/tracing/uspace/srv/vfs/vfs_file.c
 ,17 → 97,13
 /** Release file descriptor.
  *
  * @param fd        File descriptor being released.
- *
- * @return      EOK on success or EBADF if fd is an invalid file
- *          descriptor.
  */
-int vfs_fd_free(int fd)
+void vfs_fd_free(int fd)
 {
-    if ((fd >= MAX_OPEN_FILES) || (files[fd] == NULL))
-        return EBADF;
+    assert(fd < MAX_OPEN_FILES);
+    assert(files[fd] != NULL);
     vfs_file_delref(files[fd]);
     files[fd] = NULL;
-    return EOK;
 }
 /** Increment reference count of VFS file structure.

 /branches/tracing/uspace/srv/vfs/Makefile
 ,7 → 52,7
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 ,11 → 65,9
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< >$@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3425 → Rev 3424