Changeset 20235a3 in mainline for uspace

Timestamp:

2010-09-02T20:55:28Z (16 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0c39b96

Parents:

0c61955 (diff), 3249673 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace

Files:

• Makefile (modified) (1 diff)
• Makefile.common (modified) (1 diff)
• app/init/init.c (modified) (1 diff)
• app/klog/klog.c (modified) (3 diffs)
• lib/c/Makefile (modified) (1 diff)
• lib/c/generic/async_rel.c (added)
• lib/c/generic/io/io.c (modified) (1 diff)
• lib/c/generic/libc.c (modified) (2 diffs)
• lib/c/include/async_rel.h (added)
• lib/c/include/stdio.h (modified) (1 diff)
• srv/fs/fat/fat.h (modified) (2 diffs)
• srv/fs/fat/fat_fat.c (modified) (20 diffs)
• srv/fs/fat/fat_fat.h (modified) (1 diff)
• srv/fs/fat/fat_ops.c (modified) (50 diffs)
• srv/fs/tmpfs/tmpfs_ops.c (modified) (1 diff)
• srv/hid/console/gcons.c (modified) (1 diff)
• srv/hid/fb/fb.c (modified) (1 diff)
• srv/hid/kbd/Makefile (modified) (1 diff)
• srv/hid/kbd/port/chardev.c (modified) (3 diffs)
• srv/hid/s3c24xx_ts/Makefile (added)
• srv/hid/s3c24xx_ts/s3c24xx_ts.c (added)
• srv/hid/s3c24xx_ts/s3c24xx_ts.h (added)
• srv/hw/char/s3c24xx_uart/Makefile (added)
• srv/hw/char/s3c24xx_uart/s3c24xx_uart.c (added)
• srv/hw/char/s3c24xx_uart/s3c24xx_uart.h (added)
• srv/vfs/vfs.h (modified) (1 diff)
• srv/vfs/vfs_lookup.c (modified) (2 diffs)
• srv/vfs/vfs_node.c (modified) (1 diff)
• srv/vfs/vfs_ops.c (modified) (14 diffs)
• srv/vfs/vfs_register.c (modified) (6 diffs)

uspace/Makefile

@@ -66 +66 @@
         srv/hid/adb_mouse \
         srv/hid/char_mouse \
+        srv/hid/s3c24xx_ts \
         srv/hid/fb \
         srv/hid/kbd \
         srv/hw/char/i8042 \
+        srv/hw/char/s3c24xx_uart \
         srv/hw/netif/dp8390 \
         srv/net/cfg \

uspace/Makefile.common

@@ -172 +172 @@
 ifneq ($(BINARY),)
 %.disasm: $(BINARY)
+ifeq ($(CONFIG_LINE_DEBUG),y)
+        $(OBJDUMP) -d -S $< > $@
+else
         $(OBJDUMP) -d $< > $@
+endif
 
 $(BINARY): $(LINKER_SCRIPT) $(OBJECTS) $(LIBS) $(BASE_LIBS)

uspace/app/init/init.c

@@ -274 +274 @@
         srv_start("/srv/cuda_adb");
         srv_start("/srv/i8042");
+        srv_start("/srv/s3c24ser");
         srv_start("/srv/adb_ms");
         srv_start("/srv/char_ms");
+        srv_start("/srv/s3c24ts");
         
         spawn("/srv/fb");

uspace/app/klog/klog.c

@@ -43 +43 @@
 #include <event.h>
 #include <errno.h>
+#include <str_error.h>
 #include <io/klog.h>
 
-#define NAME  "klog"
+#define NAME       "klog"
+#define LOG_FNAME  "/log/klog"
 
 /* Pointer to klog area */
 static wchar_t *klog;
 static size_t klog_length;
+
+static FILE *log;
 
 static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
@@ -58 +62 @@
         size_t i;
         
-        for (i = klog_len - klog_stored; i < klog_len; i++)
-                putchar(klog[(klog_start + i) % klog_length]);
+        for (i = klog_len - klog_stored; i < klog_len; i++) {
+                wchar_t ch = klog[(klog_start + i) % klog_length];
+                
+                putchar(ch);
+                
+                if (log != NULL)
+                        fputc(ch, log);
+        }
+        
+        if (log != NULL) {
+                fflush(log);
+                fsync(fileno(log));
+        }
 }
 
@@ -91 +106 @@
         }
         
+        /*
+         * Mode "a" would be definitively much better here, but it is
+         * not well supported by the FAT driver.
+         *
+         */
+        log = fopen(LOG_FNAME, "w");
+        if (log == NULL)
+                printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,
+                    str_error(errno));
+        
         async_set_interrupt_received(interrupt_received);
         klog_update();

uspace/lib/c/Makefile

@@ -84 +84 @@
         generic/ipc.c \
         generic/async.c \
+        generic/async_rel.c \
         generic/loader.c \
         generic/getopt.c \

uspace/lib/c/generic/io/io.c

@@ -757 +757 @@
 }
 
+int fileno(FILE *stream)
+{
+        if (stream->klog) {
+                errno = EBADF;
+                return -1;
+        }
+        
+        return stream->fd;
+}
+
 int fphone(FILE *stream)
 {

uspace/lib/c/generic/libc.c

@@ -50 +50 @@
 #include <ipc/ipc.h>
 #include <async.h>
+#include <async_rel.h>
 #include <as.h>
 #include <loader/pcb.h>
@@ -65 +66 @@
         __heap_init();
         __async_init();
+        (void) async_rel_init();
         fibril_t *fibril = fibril_setup();
         __tcb_set(fibril->tcb);

uspace/lib/c/include/stdio.h

@@ -171 +171 @@
 extern off64_t ftell(FILE *);
 extern int feof(FILE *);
+extern int fileno(FILE *);
 
 extern int fflush(FILE *);

uspace/srv/fs/fat/fat.h

@@ -48 +48 @@
 
 #define min(a, b)               ((a) < (b) ? (a) : (b))
+
+/*
+ * Convenience macros for accessing some frequently used boot sector members.
+ */
+#define BPS(bs)         uint16_t_le2host((bs)->bps)
+#define SPC(bs)         (bs)->spc
+#define RSCNT(bs)       uint16_t_le2host((bs)->rscnt)
+#define FATCNT(bs)      (bs)->fatcnt
+#define SF(bs)          uint16_t_le2host((bs)->sec_per_fat)
+#define RDE(bs)         uint16_t_le2host((bs)->root_ent_max)
+#define TS(bs)          (uint16_t_le2host((bs)->totsec16) != 0 ? \
+                        uint16_t_le2host((bs)->totsec16) : \
+                        uint32_t_le2host(bs->totsec32))
 
 #define BS_BLOCK                0
@@ -198 +211 @@
         unsigned                refcnt;
         bool                    dirty;
+
+        /*
+         * Cache of the node's last and "current" cluster to avoid some
+         * unnecessary FAT walks.
+         */
+        /* Node's last cluster in FAT. */
+        bool            lastc_cached_valid;
+        fat_cluster_t   lastc_cached_value;
+        /* Node's "current" cluster, i.e. where the last I/O took place. */
+        bool            currc_cached_valid;
+        aoff64_t        currc_cached_bn;
+        fat_cluster_t   currc_cached_value;
 } fat_node_t;
 

uspace/srv/fs/fat/fat_fat.c

@@ -49 +49 @@
 #include <mem.h>
 
+/*
+ * Convenience macros for computing some frequently used values from the
+ * primitive boot sector members.
+ */
+#define RDS(bs)         ((sizeof(fat_dentry_t) * RDE((bs))) / BPS((bs))) + \
+                        (((sizeof(fat_dentry_t) * RDE((bs))) % BPS((bs))) != 0)
+#define SSA(bs)         (RSCNT((bs)) + FATCNT((bs)) * SF((bs)) + RDS(bs))
+
+#define CLBN2PBN(bs, cl, bn) \
+        (SSA((bs)) + ((cl) - FAT_CLST_FIRST) * SPC((bs)) + (bn) % SPC((bs)))
+
 /**
  * The fat_alloc_lock mutex protects all copies of the File Allocation Table
@@ -74 +85 @@
 {
         block_t *b;
-        unsigned bps;
-        unsigned rscnt;         /* block address of the first FAT */
         uint16_t clusters = 0;
         fat_cluster_t clst = firstc;
         int rc;
-
-        bps = uint16_t_le2host(bs->bps);
-        rscnt = uint16_t_le2host(bs->rscnt);
 
         if (firstc == FAT_CLST_RES0) {
@@ -99 +105 @@
                 if (lastc)
                         *lastc = clst;  /* remember the last cluster number */
-                fsec = (clst * sizeof(fat_cluster_t)) / bps;
-                fidx = clst % (bps / sizeof(fat_cluster_t));
+                fsec = (clst * sizeof(fat_cluster_t)) / BPS(bs);
+                fidx = clst % (BPS(bs) / sizeof(fat_cluster_t));
                 /* read FAT1 */
-                rc = block_get(&b, dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
+                rc = block_get(&b, dev_handle, RSCNT(bs) + fsec,
+                    BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         return rc;
@@ -125 +132 @@
  * @param block         Pointer to a block pointer for storing result.
  * @param bs            Buffer holding the boot sector of the file system.
- * @param dev_handle    Device handle of the file system.
- * @param firstc        First cluster used by the file. Can be zero if the file
- *                      is empty.
+ * @param nodep         FAT node.
  * @param bn            Block number.
  * @param flags         Flags passed to libblock.
@@ -134 +139 @@
  */
 int
+fat_block_get(block_t **block, struct fat_bs *bs, fat_node_t *nodep,
+    aoff64_t bn, int flags)
+{
+        fat_cluster_t firstc = nodep->firstc;
+        fat_cluster_t currc;
+        aoff64_t relbn = bn;
+        int rc;
+
+        if (!nodep->size)
+                return ELIMIT;
+
+        if (nodep->firstc == FAT_CLST_ROOT) 
+                goto fall_through;
+
+        if (((((nodep->size - 1) / BPS(bs)) / SPC(bs)) == bn / SPC(bs)) &&
+            nodep->lastc_cached_valid) {
+                /*
+                 * This is a request to read a block within the last cluster
+                 * when fortunately we have the last cluster number cached.
+                 */
+                return block_get(block, nodep->idx->dev_handle,
+                    CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);
+        }
+
+        if (nodep->currc_cached_valid && bn >= nodep->currc_cached_bn) {
+                /*
+                 * We can start with the cluster cached by the previous call to
+                 * fat_block_get().
+                 */
+                firstc = nodep->currc_cached_value;
+                relbn -= (nodep->currc_cached_bn / SPC(bs)) * SPC(bs);
+        }
+
+fall_through:
+        rc = _fat_block_get(block, bs, nodep->idx->dev_handle, firstc,
+            &currc, relbn, flags);
+        if (rc != EOK)
+                return rc;
+        
+        /*
+         * Update the "current" cluster cache.
+         */
+        nodep->currc_cached_valid = true;
+        nodep->currc_cached_bn = bn;
+        nodep->currc_cached_value = currc;
+
+        return rc;
+}
+
+/** Read block from file located on a FAT file system.
+ *
+ * @param block         Pointer to a block pointer for storing result.
+ * @param bs            Buffer holding the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param fcl           First cluster used by the file. Can be zero if the file
+ *                      is empty.
+ * @param clp           If not NULL, address where the cluster containing bn
+ *                      will be stored.
+ *                      stored 
+ * @param bn            Block number.
+ * @param flags         Flags passed to libblock.
+ *
+ * @return              EOK on success or a negative error code.
+ */
+int
 _fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle,
-    fat_cluster_t firstc, aoff64_t bn, int flags)
-{
-        unsigned bps;
-        unsigned rscnt;         /* block address of the first FAT */
-        unsigned rde;
-        unsigned rds;           /* root directory size */
-        unsigned sf;
-        unsigned ssa;           /* size of the system area */
+    fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
+{
         uint16_t clusters;
         unsigned max_clusters;
-        fat_cluster_t lastc;
+        fat_cluster_t c;
         int rc;
 
@@ -151 +215 @@
          * This function can only operate on non-zero length files.
          */
-        if (firstc == FAT_CLST_RES0)
+        if (fcl == FAT_CLST_RES0)
                 return ELIMIT;
 
-        bps = uint16_t_le2host(bs->bps);
-        rscnt = uint16_t_le2host(bs->rscnt);
-        rde = uint16_t_le2host(bs->root_ent_max);
-        sf = uint16_t_le2host(bs->sec_per_fat);
-
-        rds = (sizeof(fat_dentry_t) * rde) / bps;
-        rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
-        ssa = rscnt + bs->fatcnt * sf + rds;
-
-        if (firstc == FAT_CLST_ROOT) {
+        if (fcl == FAT_CLST_ROOT) {
                 /* root directory special case */
-                assert(bn < rds);
-                rc = block_get(block, dev_handle, rscnt + bs->fatcnt * sf + bn,
-                    flags);
+                assert(bn < RDS(bs));
+                rc = block_get(block, dev_handle,
+                    RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags);
                 return rc;
         }
 
-        max_clusters = bn / bs->spc;
-        rc = fat_cluster_walk(bs, dev_handle, firstc, &lastc, &clusters,
-            max_clusters);
+        max_clusters = bn / SPC(bs);
+        rc = fat_cluster_walk(bs, dev_handle, fcl, &c, &clusters, max_clusters);
         if (rc != EOK)
                 return rc;
         assert(clusters == max_clusters);
 
-        rc = block_get(block, dev_handle,
-            ssa + (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
+        rc = block_get(block, dev_handle, CLBN2PBN(bs, c, bn), flags);
+
+        if (clp)
+                *clp = c;
 
         return rc;
@@ -198 +254 @@
 int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
 {
-        uint16_t bps;
-        unsigned spc;
         block_t *b;
         aoff64_t o, boundary;
         int rc;
 
-        bps = uint16_t_le2host(bs->bps);
-        spc = bs->spc;
-        
-        boundary = ROUND_UP(nodep->size, bps * spc);
+        boundary = ROUND_UP(nodep->size, BPS(bs) * SPC(bs));
 
         /* zero out already allocated space */
         for (o = nodep->size; o < pos && o < boundary;
-            o = ALIGN_DOWN(o + bps, bps)) {
-                int flags = (o % bps == 0) ?
+            o = ALIGN_DOWN(o + BPS(bs), BPS(bs))) {
+                int flags = (o % BPS(bs) == 0) ?
                     BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
-                rc = fat_block_get(&b, bs, nodep, o / bps, flags);
-                if (rc != EOK)
-                        return rc;
-                memset(b->data + o % bps, 0, bps - o % bps);
+                rc = fat_block_get(&b, bs, nodep, o / BPS(bs), flags);
+                if (rc != EOK)
+                        return rc;
+                memset(b->data + o % BPS(bs), 0, BPS(bs) - o % BPS(bs));
                 b->dirty = true;                /* need to sync node */
                 rc = block_put(b);
@@ -228 +279 @@
         
         /* zero out the initial part of the new cluster chain */
-        for (o = boundary; o < pos; o += bps) {
+        for (o = boundary; o < pos; o += BPS(bs)) {
                 rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
-                    (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
-                if (rc != EOK)
-                        return rc;
-                memset(b->data, 0, min(bps, pos - o));
+                    NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);
+                if (rc != EOK)
+                        return rc;
+                memset(b->data, 0, min(BPS(bs), pos - o));
                 b->dirty = true;                /* need to sync node */
                 rc = block_put(b);
@@ -257 +308 @@
 {
         block_t *b;
-        uint16_t bps;
-        uint16_t rscnt;
-        uint16_t sf;
         fat_cluster_t *cp;
         int rc;
 
-        bps = uint16_t_le2host(bs->bps);
-        rscnt = uint16_t_le2host(bs->rscnt);
-        sf = uint16_t_le2host(bs->sec_per_fat);
-
-        rc = block_get(&b, dev_handle, rscnt + sf * fatno +
-            (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
+        rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
+            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
-        cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
+        cp = (fat_cluster_t *)b->data +
+            clst % (BPS(bs) / sizeof(fat_cluster_t));
         *value = uint16_t_le2host(*cp);
         rc = block_put(b);
@@ -293 +338 @@
 {
         block_t *b;
-        uint16_t bps;
-        uint16_t rscnt;
-        uint16_t sf;
         fat_cluster_t *cp;
         int rc;
 
-        bps = uint16_t_le2host(bs->bps);
-        rscnt = uint16_t_le2host(bs->rscnt);
-        sf = uint16_t_le2host(bs->sec_per_fat);
-
-        assert(fatno < bs->fatcnt);
-        rc = block_get(&b, dev_handle, rscnt + sf * fatno +
-            (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
+        assert(fatno < FATCNT(bs));
+        rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno +
+            (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
-        cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
+        cp = (fat_cluster_t *)b->data +
+            clst % (BPS(bs) / sizeof(fat_cluster_t));
         *cp = host2uint16_t_le(value);
         b->dirty = true;                /* need to sync block */
@@ -364 +403 @@
     fat_cluster_t *mcl, fat_cluster_t *lcl)
 {
-        uint16_t bps;
-        uint16_t rscnt;
-        uint16_t sf;
-        uint32_t ts;
-        unsigned rde;
-        unsigned rds;
-        unsigned ssa;
         block_t *blk;
         fat_cluster_t *lifo;    /* stack for storing free cluster numbers */ 
@@ -380 +412 @@
         if (!lifo)
                 return ENOMEM;
-        
-        bps = uint16_t_le2host(bs->bps);
-        rscnt = uint16_t_le2host(bs->rscnt);
-        sf = uint16_t_le2host(bs->sec_per_fat);
-        rde = uint16_t_le2host(bs->root_ent_max);
-        ts = (uint32_t) uint16_t_le2host(bs->totsec16);
-        if (ts == 0)
-                ts = uint32_t_le2host(bs->totsec32);
-
-        rds = (sizeof(fat_dentry_t) * rde) / bps;
-        rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
-        ssa = rscnt + bs->fatcnt * sf + rds;
         
         /*
@@ -397 +417 @@
          */
         fibril_mutex_lock(&fat_alloc_lock);
-        for (b = 0, cl = 0; b < sf; b++) {
-                rc = block_get(&blk, dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
+        for (b = 0, cl = 0; b < SF(bs); b++) {
+                rc = block_get(&blk, dev_handle, RSCNT(bs) + b,
+                    BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         goto error;
-                for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
+                for (c = 0; c < BPS(bs) / sizeof(fat_cluster_t); c++, cl++) {
                         /*
-                         * Check if the cluster is physically there. This check
-                         * becomes necessary when the file system is created
-                         * with fewer total sectors than how many is inferred
-                         * from the size of the file allocation table.
+                         * Check if the entire cluster is physically there.
+                         * This check becomes necessary when the file system is
+                         * created with fewer total sectors than how many is
+                         * inferred from the size of the file allocation table
+                         * or when the last cluster ends beyond the end of the
+                         * device.
                          */
-                        if ((cl >= 2) && ((cl - 2) * bs->spc + ssa >= ts)) {
+                        if ((cl >= FAT_CLST_FIRST) &&
+                            CLBN2PBN(bs, cl, SPC(bs) - 1) >= TS(bs)) {
                                 rc = block_put(blk);
                                 if (rc != EOK)
@@ -511 +535 @@
  * @param nodep         Node representing the file.
  * @param mcl           First cluster of the cluster chain to append.
+ * @param lcl           Last cluster of the cluster chain to append.
  *
  * @return              EOK on success or a negative error code.
  */
-int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
+int
+fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
+    fat_cluster_t lcl)
 {
         dev_handle_t dev_handle = nodep->idx->dev_handle;
-        fat_cluster_t lcl;
+        fat_cluster_t lastc;
         uint16_t numc;
         uint8_t fatno;
         int rc;
 
-        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc,
-            (uint16_t) -1);
-        if (rc != EOK)
-                return rc;
-
-        if (numc == 0) {
-                /* No clusters allocated to the node yet. */
-                nodep->firstc = mcl;
-                nodep->dirty = true;            /* need to sync node */
-                return EOK;
+        if (nodep->lastc_cached_valid) {
+                lastc = nodep->lastc_cached_value;
+                nodep->lastc_cached_valid = false;
+        } else {
+                rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lastc,
+                    &numc, (uint16_t) -1);
+                if (rc != EOK)
+                        return rc;
+
+                if (numc == 0) {
+                        /* No clusters allocated to the node yet. */
+                        nodep->firstc = mcl;
+                        nodep->dirty = true;    /* need to sync node */
+                        return EOK;
+                }
         }
 
         for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl,
+                rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lastc,
                     mcl);
                 if (rc != EOK)
                         return rc;
         }
+
+        nodep->lastc_cached_valid = true;
+        nodep->lastc_cached_value = lcl;
 
         return EOK;
@@ -548 +583 @@
  * @param bs            Buffer holding the boot sector of the file system.
  * @param nodep         FAT node where the chopping will take place.
- * @param lastc         Last cluster which will remain in the node. If this
+ * @param lcl           Last cluster which will remain in the node. If this
  *                      argument is FAT_CLST_RES0, then all clusters will
  *                      be chopped off.
@@ -554 +589 @@
  * @return              EOK on success or a negative return code.
  */
-int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
-{
-        int rc;
-
+int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl)
+{
+        int rc;
         dev_handle_t dev_handle = nodep->idx->dev_handle;
-        if (lastc == FAT_CLST_RES0) {
+
+        /*
+         * Invalidate cached cluster numbers.
+         */
+        nodep->lastc_cached_valid = false;
+        if (nodep->currc_cached_value != lcl)
+                nodep->currc_cached_valid = false;
+
+        if (lcl == FAT_CLST_RES0) {
                 /* The node will have zero size and no clusters allocated. */
                 rc = fat_free_clusters(bs, dev_handle, nodep->firstc);
@@ -570 +612 @@
                 unsigned fatno;
 
-                rc = fat_get_cluster(bs, dev_handle, FAT1, lastc, &nextc);
+                rc = fat_get_cluster(bs, dev_handle, FAT1, lcl, &nextc);
                 if (rc != EOK)
                         return rc;
@@ -576 +618 @@
                 /* Terminate the cluster chain in all copies of FAT. */
                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
-                        rc = fat_set_cluster(bs, dev_handle, fatno, lastc,
+                        rc = fat_set_cluster(bs, dev_handle, fatno, lcl,
                             FAT_CLST_LAST1);
                         if (rc != EOK)
@@ -588 +630 @@
         }
 
+        /*
+         * Update and re-enable the last cluster cache.
+         */
+        nodep->lastc_cached_valid = true;
+        nodep->lastc_cached_value = lcl;
+
         return EOK;
 }
@@ -596 +644 @@
         int i;
         block_t *b;
-        unsigned bps;
-        int rc;
-
-        bps = uint16_t_le2host(bs->bps);
-        
-        for (i = 0; i < bs->spc; i++) {
-                rc = _fat_block_get(&b, bs, dev_handle, c, i,
+        int rc;
+
+        for (i = 0; i < SPC(bs); i++) {
+                rc = _fat_block_get(&b, bs, dev_handle, c, NULL, i,
                     BLOCK_FLAGS_NOREAD);
                 if (rc != EOK)
                         return rc;
-                memset(b->data, 0, bps);
+                memset(b->data, 0, BPS(bs));
                 b->dirty = true;
                 rc = block_put(b);

uspace/srv/fs/fat/fat_fat.h

@@ -64 +64 @@
     fat_cluster_t *, uint16_t *, uint16_t);
 
-#define fat_block_get(b, bs, np, bn, flags) \
-    _fat_block_get((b), (bs), (np)->idx->dev_handle, (np)->firstc, (bn), \
-    (flags))
-
+extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *,
+    aoff64_t, int);
 extern int _fat_block_get(block_t **, struct fat_bs *, dev_handle_t,
-    fat_cluster_t, aoff64_t, int);
+    fat_cluster_t, fat_cluster_t *, aoff64_t, int);
 
 extern int fat_append_clusters(struct fat_bs *, struct fat_node *,
-    fat_cluster_t);
+    fat_cluster_t, fat_cluster_t);
 extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
     fat_cluster_t);

uspace/srv/fs/fat/fat_ops.c

@@ -60 +60 @@
 #define FS_NODE(node)   ((node) ? (node)->bp : NULL)
 
+#define DPS(bs)         (BPS((bs)) / sizeof(fat_dentry_t))
+#define BPC(bs)         (BPS((bs)) * SPC((bs)))
+
 /** Mutex protecting the list of cached free FAT nodes. */
 static FIBRIL_MUTEX_INITIALIZE(ffn_mutex);
@@ -101 +104 @@
         node->refcnt = 0;
         node->dirty = false;
+        node->lastc_cached_valid = false;
+        node->lastc_cached_value = FAT_CLST_LAST1;
+        node->currc_cached_valid = false;
+        node->currc_cached_bn = 0;
+        node->currc_cached_value = FAT_CLST_LAST1;
 }
 
@@ -108 +116 @@
         fat_bs_t *bs;
         fat_dentry_t *d;
-        uint16_t bps;
-        unsigned dps;
         int rc;
         
@@ -115 +121 @@
 
         bs = block_bb_get(node->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
         
         /* Read the block that contains the dentry of interest. */
         rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
-            (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
+            NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
+            BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
 
-        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
+        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % DPS(bs));
 
         d->firstc = host2uint16_t_le(node->firstc);
@@ -266 +271 @@
         fat_dentry_t *d;
         fat_node_t *nodep = NULL;
-        unsigned bps;
-        unsigned spc;
-        unsigned dps;
         int rc;
 
@@ -298 +300 @@
 
         bs = block_bb_get(idxp->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        spc = bs->spc;
-        dps = bps / sizeof(fat_dentry_t);
 
         /* Read the block that contains the dentry of interest. */
-        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc,
-            (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
+        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc, NULL,
+            (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE);
         if (rc != EOK) {
                 (void) fat_node_put(FS_NODE(nodep));
@@ -310 +309 @@
         }
 
-        d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
+        d = ((fat_dentry_t *)b->data) + (idxp->pdi % DPS(bs));
         if (d->attr & FAT_ATTR_SUBDIR) {
                 /* 
@@ -330 +329 @@
                         return rc;
                 }
-                nodep->size = bps * spc * clusters;
+                nodep->size = BPS(bs) * SPC(bs) * clusters;
         } else {
                 nodep->type = FAT_FILE;
@@ -368 +367 @@
         char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
         unsigned i, j;
-        unsigned bps;           /* bytes per sector */
-        unsigned dps;           /* dentries per sector */
         unsigned blocks;
         fat_dentry_t *d;
@@ -377 +374 @@
         fibril_mutex_lock(&parentp->idx->lock);
         bs = block_bb_get(parentp->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
-        blocks = parentp->size / bps;
+        blocks = parentp->size / BPS(bs);
         for (i = 0; i < blocks; i++) {
                 rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
@@ -386 +381 @@
                         return rc;
                 }
-                for (j = 0; j < dps; j++) { 
+                for (j = 0; j < DPS(bs); j++) { 
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -414 +409 @@
                                 fat_idx_t *idx = fat_idx_get_by_pos(
                                     parentp->idx->dev_handle, parentp->firstc,
-                                    i * dps + j);
+                                    i * DPS(bs) + j);
                                 fibril_mutex_unlock(&parentp->idx->lock);
                                 if (!idx) {
@@ -513 +508 @@
         fat_bs_t *bs;
         fat_cluster_t mcl, lcl;
-        uint16_t bps;
         int rc;
 
         bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
         if (flags & L_DIRECTORY) {
                 /* allocate a cluster */
@@ -546 +539 @@
                 nodep->type = FAT_DIRECTORY;
                 nodep->firstc = mcl;
-                nodep->size = bps * bs->spc;
+                nodep->size = BPS(bs) * SPC(bs);
         } else {
                 nodep->type = FAT_FILE;
@@ -609 +602 @@
         block_t *b;
         unsigned i, j;
-        uint16_t bps;
-        unsigned dps;
         unsigned blocks;
         fat_cluster_t mcl, lcl;
@@ -640 +631 @@
         fibril_mutex_lock(&parentp->idx->lock);
         bs = block_bb_get(parentp->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
-
-        blocks = parentp->size / bps;
+
+        blocks = parentp->size / BPS(bs);
 
         for (i = 0; i < blocks; i++) {
@@ -651 +640 @@
                         return rc;
                 }
-                for (j = 0; j < dps; j++) {
+                for (j = 0; j < DPS(bs); j++) {
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -691 +680 @@
                 return rc;
         }
-        rc = fat_append_clusters(bs, parentp, mcl);
+        rc = fat_append_clusters(bs, parentp, mcl, lcl);
         if (rc != EOK) {
                 (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl);
@@ -697 +686 @@
                 return rc;
         }
-        parentp->size += bps * bs->spc;
+        parentp->size += BPS(bs) * SPC(bs);
         parentp->dirty = true;          /* need to sync node */
         rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
@@ -771 +760 @@
 
         childp->idx->pfc = parentp->firstc;
-        childp->idx->pdi = i * dps + j;
+        childp->idx->pdi = i * DPS(bs) + j;
         fibril_mutex_unlock(&childp->idx->lock);
 
@@ -793 +782 @@
         fat_bs_t *bs;
         fat_dentry_t *d;
-        uint16_t bps;
         block_t *b;
         bool has_children;
@@ -812 +800 @@
         fibril_mutex_lock(&childp->idx->lock);
         bs = block_bb_get(childp->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
 
         rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
-            (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
+            NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs),
             BLOCK_FLAGS_NONE);
         if (rc != EOK) 
                 goto error;
         d = (fat_dentry_t *)b->data +
-            (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
+            (childp->idx->pdi % (BPS(bs) / sizeof(fat_dentry_t)));
         /* mark the dentry as not-currently-used */
         d->name[0] = FAT_DENTRY_ERASED;
@@ -852 +839 @@
         fat_bs_t *bs;
         fat_node_t *nodep = FAT_NODE(fn);
-        unsigned bps;
-        unsigned dps;
         unsigned blocks;
         block_t *b;
@@ -866 +851 @@
         fibril_mutex_lock(&nodep->idx->lock);
         bs = block_bb_get(nodep->idx->dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        dps = bps / sizeof(fat_dentry_t);
-
-        blocks = nodep->size / bps;
+
+        blocks = nodep->size / BPS(bs);
 
         for (i = 0; i < blocks; i++) {
@@ -879 +862 @@
                         return rc;
                 }
-                for (j = 0; j < dps; j++) {
+                for (j = 0; j < DPS(bs); j++) {
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
@@ -976 +959 @@
         enum cache_mode cmode;
         fat_bs_t *bs;
-        uint16_t bps;
-        uint16_t rde;
         
         /* Accept the mount options */
@@ -1014 +995 @@
         bs = block_bb_get(dev_handle);
         
-        /* Read the number of root directory entries. */
-        bps = uint16_t_le2host(bs->bps);
-        rde = uint16_t_le2host(bs->root_ent_max);
-
-        if (bps != BS_SIZE) {
+        if (BPS(bs) != BS_SIZE) {
                 block_fini(dev_handle);
                 ipc_answer_0(rid, ENOTSUP);
@@ -1025 +1002 @@
 
         /* Initialize the block cache */
-        rc = block_cache_init(dev_handle, bps, 0 /* XXX */, cmode);
+        rc = block_cache_init(dev_handle, BPS(bs), 0 /* XXX */, cmode);
         if (rc != EOK) {
                 block_fini(dev_handle);
@@ -1087 +1064 @@
         rootp->refcnt = 1;
         rootp->lnkcnt = 0;      /* FS root is not linked */
-        rootp->size = rde * sizeof(fat_dentry_t);
+        rootp->size = RDE(bs) * sizeof(fat_dentry_t);
         rootp->idx = ridxp;
         ridxp->nodep = rootp;
@@ -1165 +1142 @@
         fat_node_t *nodep;
         fat_bs_t *bs;
-        uint16_t bps;
         size_t bytes;
         block_t *b;
@@ -1191 +1167 @@
 
         bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
 
         if (nodep->type == FAT_FILE) {
@@ -1204 +1179 @@
                         (void) async_data_read_finalize(callid, NULL, 0);
                 } else {
-                        bytes = min(len, bps - pos % bps);
+                        bytes = min(len, BPS(bs) - pos % BPS(bs));
                         bytes = min(bytes, nodep->size - pos);
-                        rc = fat_block_get(&b, bs, nodep, pos / bps,
+                        rc = fat_block_get(&b, bs, nodep, pos / BPS(bs),
                             BLOCK_FLAGS_NONE);
                         if (rc != EOK) {
@@ -1214 +1189 @@
                                 return;
                         }
-                        (void) async_data_read_finalize(callid, b->data + pos % bps,
-                            bytes);
+                        (void) async_data_read_finalize(callid,
+                            b->data + pos % BPS(bs), bytes);
                         rc = block_put(b);
                         if (rc != EOK) {
@@ -1230 +1205 @@
 
                 assert(nodep->type == FAT_DIRECTORY);
-                assert(nodep->size % bps == 0);
-                assert(bps % sizeof(fat_dentry_t) == 0);
+                assert(nodep->size % BPS(bs) == 0);
+                assert(BPS(bs) % sizeof(fat_dentry_t) == 0);
 
                 /*
@@ -1239 +1214 @@
                  * the position pointer accordingly.
                  */
-                bnum = (pos * sizeof(fat_dentry_t)) / bps;
-                while (bnum < nodep->size / bps) {
+                bnum = (pos * sizeof(fat_dentry_t)) / BPS(bs);
+                while (bnum < nodep->size / BPS(bs)) {
                         aoff64_t o;
 
@@ -1247 +1222 @@
                         if (rc != EOK)
                                 goto err;
-                        for (o = pos % (bps / sizeof(fat_dentry_t));
-                            o < bps / sizeof(fat_dentry_t);
+                        for (o = pos % (BPS(bs) / sizeof(fat_dentry_t));
+                            o < BPS(bs) / sizeof(fat_dentry_t);
                             o++, pos++) {
                                 d = ((fat_dentry_t *)b->data) + o;
@@ -1306 +1281 @@
         size_t bytes, size;
         block_t *b;
-        uint16_t bps;
-        unsigned spc;
-        unsigned bpc;           /* bytes per cluster */
         aoff64_t boundary;
         int flags = BLOCK_FLAGS_NONE;
@@ -1334 +1306 @@
 
         bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        spc = bs->spc;
-        bpc = bps * spc;
 
         /*
@@ -1345 +1314 @@
          * value signalizing a smaller number of bytes written. 
          */ 
-        bytes = min(len, bps - pos % bps);
-        if (bytes == bps)
+        bytes = min(len, BPS(bs) - pos % BPS(bs));
+        if (bytes == BPS(bs))
                 flags |= BLOCK_FLAGS_NOREAD;
         
-        boundary = ROUND_UP(nodep->size, bpc);
+        boundary = ROUND_UP(nodep->size, BPC(bs));
         if (pos < boundary) {
                 /*
@@ -1364 +1333 @@
                         return;
                 }
-                rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
+                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
                 if (rc != EOK) {
                         (void) fat_node_put(fn);
@@ -1371 +1340 @@
                         return;
                 }
-                (void) async_data_write_finalize(callid, b->data + pos % bps,
-                    bytes);
+                (void) async_data_write_finalize(callid,
+                    b->data + pos % BPS(bs), bytes);
                 b->dirty = true;                /* need to sync block */
                 rc = block_put(b);
@@ -1396 +1365 @@
                 fat_cluster_t mcl, lcl; 
  
-                nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
+                nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs);
                 /* create an independent chain of nclsts clusters in all FATs */
                 rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
@@ -1415 +1384 @@
                         return;
                 }
-                rc = _fat_block_get(&b, bs, dev_handle, lcl, (pos / bps) % spc,
-                    flags);
+                rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL,
+                    (pos / BPS(bs)) % SPC(bs), flags);
                 if (rc != EOK) {
                         (void) fat_free_clusters(bs, dev_handle, mcl);
@@ -1424 +1393 @@
                         return;
                 }
-                (void) async_data_write_finalize(callid, b->data + pos % bps,
-                    bytes);
+                (void) async_data_write_finalize(callid,
+                    b->data + pos % BPS(bs), bytes);
                 b->dirty = true;                /* need to sync block */
                 rc = block_put(b);
@@ -1438 +1407 @@
                  * node's cluster chain.
                  */
-                rc = fat_append_clusters(bs, nodep, mcl);
+                rc = fat_append_clusters(bs, nodep, mcl, lcl);
                 if (rc != EOK) {
                         (void) fat_free_clusters(bs, dev_handle, mcl);
@@ -1462 +1431 @@
         fat_node_t *nodep;
         fat_bs_t *bs;
-        uint16_t bps;
-        uint8_t spc;
-        unsigned bpc;   /* bytes per cluster */
         int rc;
 
@@ -1479 +1445 @@
 
         bs = block_bb_get(dev_handle);
-        bps = uint16_t_le2host(bs->bps);
-        spc = bs->spc;
-        bpc = bps * spc;
 
         if (nodep->size == size) {
@@ -1491 +1454 @@
                  */
                 rc = EINVAL;
-        } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
+        } else if (ROUND_UP(nodep->size, BPC(bs)) == ROUND_UP(size, BPC(bs))) {
                 /*
                  * The node will be shrunk, but no clusters will be deallocated.
@@ -1509 +1472 @@
                         fat_cluster_t lastc;
                         rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
-                            &lastc, NULL, (size - 1) / bpc);
+                            &lastc, NULL, (size - 1) / BPC(bs));
                         if (rc != EOK)
                                 goto out;
@@ -1564 +1527 @@
 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
 {
-        /* Dummy implementation */
-        ipc_answer_0(rid, EOK);
+        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        
+        fs_node_t *fn;
+        int rc = fat_node_get(&fn, dev_handle, index);
+        if (rc != EOK) {
+                ipc_answer_0(rid, rc);
+                return;
+        }
+        if (!fn) {
+                ipc_answer_0(rid, ENOENT);
+                return;
+        }
+        
+        fat_node_t *nodep = FAT_NODE(fn);
+        
+        nodep->dirty = true;
+        rc = fat_node_sync(nodep);
+        
+        fat_node_put(fn);
+        ipc_answer_0(rid, rc);
 }
 

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -736 +736 @@
 void tmpfs_sync(ipc_callid_t rid, ipc_call_t *request)
 {
-        /* Dummy implementation */
+        /*
+         * TMPFS keeps its data structures always consistent,
+         * thus the sync operation is a no-op.
+         */
         ipc_answer_0(rid, EOK);
 }

uspace/srv/hid/console/gcons.c

@@ -286 +286 @@
         ssize_t nx = (ssize_t) mouse_x + dx;
         ssize_t ny = (ssize_t) mouse_y + dy;
+
+        if (!use_gcons)
+                return;
         
         mouse_x = (size_t) limit(nx, 0, xres);

uspace/srv/hid/fb/fb.c

@@ -1347 +1347 @@
 {
         mouse_hide();
-        pointer_x = x;
-        pointer_y = y;
+        pointer_x = x % screen.xres;
+        pointer_y = y % screen.yres;
         mouse_show();
 }

uspace/srv/hid/kbd/Makefile

@@ -58 +58 @@
 
 ifeq ($(UARCH),arm32)
+        ifeq ($(MACHINE),gta02)
+                SOURCES += \
+                        port/chardev.c \
+                        ctl/stty.c
+        endif
         ifeq ($(MACHINE),testarm)
                 SOURCES += \

uspace/srv/hid/kbd/port/chardev.c

@@ -41 +41 @@
 #include <kbd.h>
 #include <vfs/vfs.h>
+#include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -50 +51 @@
 #define NAME "kbd"
 
+/** List of devices to try connecting to. */
+static const char *in_devs[] = {
+        "/dev/char/ps2a",
+        "/dev/char/s3c24ser"
+};
+
+static const int num_devs = sizeof(in_devs) / sizeof(in_devs[0]);
+
 int kbd_port_init(void)
 {
-        const char *input = "/dev/char/ps2a";
         int input_fd;
+        int i;
 
-        printf(NAME ": open %s\n", input);
+        input_fd = -1;
+        for (i = 0; i < num_devs; i++) {
+                struct stat s;
 
-        input_fd = open(input, O_RDONLY);
+                if (stat(in_devs[i], &s) == EOK)
+                        break;
+        }
+
+        if (i >= num_devs) {
+                printf(NAME ": Could not find any suitable input device.\n");
+                return -1;
+        }
+
+        input_fd = open(in_devs[i], O_RDONLY);
         if (input_fd < 0) {
-                printf(NAME ": Failed opening %s (%d)\n", input, input_fd);
-                return false;
+                printf(NAME ": failed opening device %s (%d).\n", in_devs[i],
+                    input_fd);
+                return -1;
         }
 
         dev_phone = fd_phone(input_fd);
         if (dev_phone < 0) {
-                printf(NAME ": Failed to connect to device\n");
-                return false;
+                printf(NAME ": Failed connecting to device\n");
+                return -1;
         }
 
@@ -73 +94 @@
         if (ipc_connect_to_me(dev_phone, 0, 0, 0, &phonehash) != 0) {
                 printf(NAME ": Failed to create callback from device\n");
-                return false;
+                return -1;
         }
 

uspace/srv/vfs/vfs.h

@@ -169 +169 @@
 
 extern int vfs_grab_phone(fs_handle_t);
-extern void vfs_release_phone(int);
+extern void vfs_release_phone(fs_handle_t, int);
 
 extern fs_handle_t fs_name_to_handle(char *, bool);

uspace/srv/vfs/vfs_lookup.c

@@ -168 +168 @@
         ipcarg_t rc;
         async_wait_for(req, &rc);
-        vfs_release_phone(phone);
+        vfs_release_phone(root->fs_handle, phone);
         
         fibril_mutex_lock(&plb_mutex);
@@ -215 +215 @@
         ipcarg_t rc;
         async_wait_for(req, &rc);
-        vfs_release_phone(phone);
+        vfs_release_phone(result->triplet.fs_handle, phone);
         
         if (rc == EOK) {

uspace/srv/vfs/vfs_node.c

@@ -133 +133 @@
                     (ipcarg_t)node->dev_handle, (ipcarg_t)node->index);
                 assert(rc == EOK);
-                vfs_release_phone(phone);
+                vfs_release_phone(node->fs_handle, phone);
         }
         if (free_vfs_node)

uspace/srv/vfs/vfs_ops.c

@@ -131 +131 @@
                         if (rc != EOK) {
                                 async_wait_for(msg, NULL);
-                                vfs_release_phone(phone);
+                                vfs_release_phone(fs_handle, phone);
                                 fibril_rwlock_write_unlock(&namespace_rwlock);
                                 ipc_answer_0(rid, rc);
@@ -137 +137 @@
                         }
                         async_wait_for(msg, &rc);
-                        vfs_release_phone(phone);
+                        vfs_release_phone(fs_handle, phone);
                         
                         if (rc != EOK) {
@@ -196 +196 @@
         if (rc != EOK) {
                 async_wait_for(msg, NULL);
-                vfs_release_phone(mountee_phone);
-                vfs_release_phone(phone);
+                vfs_release_phone(fs_handle, mountee_phone);
+                vfs_release_phone(mp_res.triplet.fs_handle, phone);
                 /* Mount failed, drop reference to mp_node. */
                 if (mp_node)
@@ -206 +206 @@
         }
 
-        vfs_release_phone(mountee_phone);
+        vfs_release_phone(fs_handle, mountee_phone);
         
         /* send the mount options */
@@ -212 +212 @@
         if (rc != EOK) {
                 async_wait_for(msg, NULL);
-                vfs_release_phone(phone);
+                vfs_release_phone(mp_res.triplet.fs_handle, phone);
                 /* Mount failed, drop reference to mp_node. */
                 if (mp_node)
@@ -221 +221 @@
         }
         async_wait_for(msg, &rc);
-        vfs_release_phone(phone);
+        vfs_release_phone(mp_res.triplet.fs_handle, phone);
         
         if (rc == EOK) {
@@ -423 +423 @@
                 rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
                     mr_node->dev_handle);
-                vfs_release_phone(phone);
+                vfs_release_phone(mr_node->fs_handle, phone);
                 if (rc != EOK) {
                         fibril_rwlock_write_unlock(&namespace_rwlock);
@@ -460 +460 @@
                 rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->dev_handle,
                     mp_node->index);
-                vfs_release_phone(phone);
+                vfs_release_phone(mp_node->fs_handle, phone);
                 if (rc != EOK) {
                         fibril_rwlock_write_unlock(&namespace_rwlock);
@@ -716 +716 @@
         async_wait_for(msg, &rc);
         
-        vfs_release_phone(fs_phone);
+        vfs_release_phone(file->node->fs_handle, fs_phone);
         fibril_mutex_unlock(&file->lock);
         
@@ -747 +747 @@
                 async_wait_for(msg, &rc);
                 
-                vfs_release_phone(fs_phone);
+                vfs_release_phone(file->node->fs_handle, fs_phone);
                 fibril_mutex_unlock(&file->lock);
                 
@@ -846 +846 @@
         }
         
-        vfs_release_phone(fs_phone);
+        vfs_release_phone(file->node->fs_handle, fs_phone);
         
         size_t bytes = IPC_GET_ARG1(answer);
@@ -970 +970 @@
         rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) dev_handle,
             (ipcarg_t) index, LOWER32(size), UPPER32(size));
-        vfs_release_phone(fs_phone);
+        vfs_release_phone(fs_handle, fs_phone);
         return (int)rc;
 }
@@ -1026 +1026 @@
         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
         async_wait_for(msg, &rc);
-        vfs_release_phone(fs_phone);
+        vfs_release_phone(file->node->fs_handle, fs_phone);
 
         fibril_mutex_unlock(&file->lock);
@@ -1077 +1077 @@
         ipcarg_t rv;
         async_wait_for(msg, &rv);
-        vfs_release_phone(fs_phone);
+        vfs_release_phone(node->fs_handle, fs_phone);
 
         ipc_answer_0(rid, rv);

uspace/srv/vfs/vfs_register.c

@@ -39 +39 @@
 #include <ipc/services.h>
 #include <async.h>
+#include <async_rel.h>
 #include <fibril.h>
+#include <fibril_synch.h>
 #include <errno.h>
 #include <stdio.h>
@@ -46 +48 @@
 #include <ctype.h>
 #include <bool.h>
-#include <fibril_synch.h>
 #include <adt/list.h>
 #include <as.h>
@@ -252 +253 @@
 int vfs_grab_phone(fs_handle_t handle)
 {
+        link_t *cur;
+        fs_info_t *fs;
         int phone;
 
@@ -262 +265 @@
          */
         fibril_mutex_lock(&fs_head_lock);
-        link_t *cur;
-        fs_info_t *fs;
         for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
                 fs = list_get_instance(cur, fs_info_t, fs_link);
@@ -269 +270 @@
                         fibril_mutex_unlock(&fs_head_lock);
                         fibril_mutex_lock(&fs->phone_lock);
-                        phone = ipc_connect_me_to(fs->phone, 0, 0, 0);
+                        phone = async_relation_create(fs->phone);
                         fibril_mutex_unlock(&fs->phone_lock);
 
@@ -284 +285 @@
  * @param phone         Phone to FS task.
  */
-void vfs_release_phone(int phone)
-{
-        /* TODO: implement connection caching */
-        ipc_hangup(phone);
+void vfs_release_phone(fs_handle_t handle, int phone)
+{
+        link_t *cur;
+        fs_info_t *fs;
+
+        fibril_mutex_lock(&fs_head_lock);
+        for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
+                fs = list_get_instance(cur, fs_info_t, fs_link);
+                if (fs->fs_handle == handle) {
+                        fibril_mutex_unlock(&fs_head_lock);
+                        fibril_mutex_lock(&fs->phone_lock);
+                        async_relation_destroy(fs->phone, phone);
+                        fibril_mutex_unlock(&fs->phone_lock);
+                        return;
+                }
+        }
+        /* should not really get here */
+        abort();
+        fibril_mutex_unlock(&fs_head_lock);
 }