WebSVN – HelenOS – Path Comparison – / – /branches/network/uspace/lib/ Rev 4152 and /branches/network/uspace/lib/ Rev 4153

Ignore whitespace Rev 4152 → Rev 4153

 /branches/network/uspace/lib/libfs/libfs.c
 ,7 → 36,6
 #include "libfs.h"
 #include "../../srv/vfs/vfs.h"
-#include "../../srv/rd/rd.h"
 #include <errno.h>
 #include <async.h>
 #include <ipc/ipc.h>
 ,17 → 191,20
                 }
                 void *nodep;
                 if (lflag & L_CREATE)
-                    nodep = ops->create(lflag);
+                    nodep = ops->create(dev_handle, lflag);
                 else
                     nodep = ops->node_get(dev_handle,
                         index);
                 if (nodep) {
-                    if (!ops->link(cur, nodep, component)) {
+                    int rc;
+                    rc = ops->link(cur, nodep, component);
+                    if (rc != EOK) {
                         if (lflag & L_CREATE) {
                             (void)ops->destroy(
                                 nodep);
                         }
-                        ipc_answer_0(rid, ENOSPC);
+                        ipc_answer_0(rid, rc);
                     } else {
                         ipc_answer_5(rid, EOK,
                             fs_handle, dev_handle,
 ,14 → 265,17
             void *nodep;
             if (lflag & L_CREATE)
-                nodep = ops->create(lflag);
+                nodep = ops->create(dev_handle, lflag);
             else
                 nodep = ops->node_get(dev_handle, index);
             if (nodep) {
-                if (!ops->link(cur, nodep, component)) {
+                int rc;
+                rc = ops->link(cur, nodep, component);
+                if (rc != EOK) {
                     if (lflag & L_CREATE)
                         (void)ops->destroy(nodep);
-                    ipc_answer_0(rid, ENOSPC);
+                    ipc_answer_0(rid, rc);
                 } else {
                     ipc_answer_5(rid, EOK,
                         fs_handle, dev_handle,
 ,62 → 336,5
         ops->node_put(tmp);
 }
-/** Read data from a block device.
- *
- * @param phone     Phone to be used to communicate with the device.
- * @param buffer    Communication buffer shared with the device.
- * @param bufpos    Pointer to the first unread valid offset within the
- *          communication buffer.
- * @param buflen    Pointer to the number of unread bytes that are ready in
- *          the communication buffer.
- * @param pos       Device position to be read.
- * @param dst       Destination buffer.
- * @param size      Size of the destination buffer.
- * @param block_size    Block size to be used for the transfer.
- *
- * @return      True on success, false on failure.
- */
-bool libfs_blockread(int phone, void *buffer, off_t *bufpos, size_t *buflen,
-    off_t *pos, void *dst, size_t size, size_t block_size)
-{
-    off_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) {
-            /*
-             * Copy the contents of the communication buffer to the
-             * destination buffer.
-             */
-            memcpy(dst + offset, buffer + *bufpos, rd);
-            offset += rd;
-            *bufpos += rd;
-            *pos += rd;
-            left -= rd;
-        }
-        if (*bufpos == *buflen) {
-            /* Refill the communication buffer with a new block. */
-            ipcarg_t retval;
-            int rc = async_req_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;
-}
 /** @}
  */

 /branches/network/uspace/lib/libfs/libfs.h
 ,9 → 45,9
     void * (* match)(void *, const char *);
     void * (* node_get)(dev_handle_t, fs_index_t);
     void (* node_put)(void *);
-    void * (* create)(int);
+    void * (* create)(dev_handle_t, int);
     int (* destroy)(void *);
-    bool (* link)(void *, void *, const char *);
+    int (* link)(void *, void *, const char *);
     int (* unlink)(void *, void *);
     fs_index_t (* index_get)(void *);
     size_t (* size_get)(void *);
 ,9 → 69,6
 extern void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
-extern bool libfs_blockread(int, void *, off_t *, size_t *, off_t *, void *,
-    size_t, size_t);
 #endif
 /** @}

 /branches/network/uspace/lib/libfs/Makefile
 ,6 → 31,7
 #
 LIBC_PREFIX = ../libc
 ## Setup toolchain
 #
 ,7 → 58,7
     find . -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
 libfs.a: depend $(OBJECTS)
     $(AR) rc libfs.a $(OBJECTS)

 /branches/network/uspace/lib/softfloat/Makefile
 ,25 → 30,26
 #
 LIBC_PREFIX = ../libc
 ## Setup toolchain
 #
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS +=-Iinclude -Iarch/$(ARCH)/include/
+CFLAGS +=-Iinclude -Iarch/$(UARCH)/include/
 ## Sources
 #
-GENERIC_SOURCES =       \
-    generic/add.c       \
-    generic/common.c    \
-    generic/comparison.c    \
-    generic/conversion.c    \
-    generic/div.c       \
-    generic/mul.c       \
-    generic/other.c     \
-    generic/softfloat.c \
+GENERIC_SOURCES = \
+    generic/add.c \
+    generic/common.c \
+    generic/comparison.c \
+    generic/conversion.c \
+    generic/div.c \
+    generic/mul.c \
+    generic/other.c \
+    generic/softfloat.c \
     generic/sub.c
 ARCH_SOURCES =
 ,7 → 67,7
     find generic/ -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libsoftfloat.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libsoftfloat.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

/branches/network/uspace/lib/softfloat/arch/ppc64/include/functions.h
File deleted

 /branches/network/uspace/lib/libblock/libblock.c
 ,0 → 1,494
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2008 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libblock
+ * @{
+ */
+/**
+ * @file
+ * @brief
+ */
+#include "libblock.h"
+#include "../../srv/vfs/vfs.h"
+#include "../../srv/rd/rd.h"
+#include <ipc/devmap.h>
+#include <ipc/services.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <async.h>
+#include <ipc/ipc.h>
+#include <as.h>
+#include <assert.h>
+#include <futex.h>
+#include <libadt/list.h>
+#include <libadt/hash_table.h>
+/** Lock protecting the device connection list */
+static futex_t dcl_lock = FUTEX_INITIALIZER;
+/** Device connection list head. */
+static LIST_INITIALIZE(dcl_head);
+#define CACHE_BUCKETS_LOG2      10
+#define CACHE_BUCKETS           (1 << CACHE_BUCKETS_LOG2)
+typedef struct {
+    futex_t lock;
+    size_t block_size;      /**< Block size. */
+    unsigned block_count;       /**< Total number of blocks. */
+    hash_table_t block_hash;
+    link_t free_head;
+} cache_t;
+typedef struct {
+    link_t link;
+    int dev_handle;
+    int dev_phone;
+    void *com_area;
+    size_t com_size;
+    void *bb_buf;
+    off_t bb_off;
+    size_t bb_size;
+    cache_t *cache;
+} devcon_t;
+static devcon_t *devcon_search(dev_handle_t dev_handle)
+{
+    link_t *cur;
+    futex_down(&dcl_lock);
+    for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
+        devcon_t *devcon = list_get_instance(cur, devcon_t, link);
+        if (devcon->dev_handle == dev_handle) {
+            futex_up(&dcl_lock);
+            return devcon;
+        }
+    }
+    futex_up(&dcl_lock);
+    return NULL;
+}
+static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
+   size_t com_size)
+{
+    link_t *cur;
+    devcon_t *devcon;
+    devcon = malloc(sizeof(devcon_t));
+    if (!devcon)
+        return ENOMEM;
+    link_initialize(&devcon->link);
+    devcon->dev_handle = dev_handle;
+    devcon->dev_phone = dev_phone;
+    devcon->com_area = com_area;
+    devcon->com_size = com_size;
+    devcon->bb_buf = NULL;
+    devcon->bb_off = 0;
+    devcon->bb_size = 0;
+    devcon->cache = NULL;
+    futex_down(&dcl_lock);
+    for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
+        devcon_t *d = list_get_instance(cur, devcon_t, link);
+        if (d->dev_handle == dev_handle) {
+            futex_up(&dcl_lock);
+            free(devcon);
+            return EEXIST;
+        }
+    }
+    list_append(&devcon->link, &dcl_head);
+    futex_up(&dcl_lock);
+    return EOK;
+}
+static void devcon_remove(devcon_t *devcon)
+{
+    futex_down(&dcl_lock);
+    list_remove(&devcon->link);
+    futex_up(&dcl_lock);
+}
+int block_init(dev_handle_t dev_handle, size_t com_size)
+{
+    int rc;
+    int dev_phone;
+    void *com_area;
+    com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
+        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+    if (!com_area) {
+        return ENOMEM;
+    }
+    dev_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
+        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
+    if (dev_phone < 0) {
+        munmap(com_area, com_size);
+        return dev_phone;
+    }
+    rc = ipc_share_out_start(dev_phone, com_area,
+        AS_AREA_READ | AS_AREA_WRITE);
+    if (rc != EOK) {
+            munmap(com_area, com_size);
+        ipc_hangup(dev_phone);
+        return rc;
+    }
+    rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
+    if (rc != EOK) {
+        munmap(com_area, com_size);
+        ipc_hangup(dev_phone);
+        return rc;
+    }
+    return EOK;
+}
+void block_fini(dev_handle_t dev_handle)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    devcon_remove(devcon);
+    if (devcon->bb_buf)
+        free(devcon->bb_buf);
+    if (devcon->cache) {
+        hash_table_destroy(&devcon->cache->block_hash);
+        free(devcon->cache);
+    }
+    munmap(devcon->com_area, devcon->com_size);
+    ipc_hangup(devcon->dev_phone);
+    free(devcon);
+}
+int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
+{
+    void *bb_buf;
+    int rc;
+    devcon_t *devcon = devcon_search(dev_handle);
+    if (!devcon)
+        return ENOENT;
+    if (devcon->bb_buf)
+        return EEXIST;
+    bb_buf = malloc(size);
+    if (!bb_buf)
+        return ENOMEM;
+    off_t bufpos = 0;
+    size_t buflen = 0;
+    rc = block_read(dev_handle, &bufpos, &buflen, &off,
+        bb_buf, size, size);
+    if (rc != EOK) {
+            free(bb_buf);
+        return rc;
+    }
+    devcon->bb_buf = bb_buf;
+    devcon->bb_off = off;
+    devcon->bb_size = size;
+    return EOK;
+}
+void *block_bb_get(dev_handle_t dev_handle)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    return devcon->bb_buf;
+}
+static hash_index_t cache_hash(unsigned long *key)
+{
+    return *key & (CACHE_BUCKETS - 1);
+}
+static int cache_compare(unsigned long *key, hash_count_t keys, link_t *item)
+{
+    block_t *b = hash_table_get_instance(item, block_t, hash_link);
+    return b->boff == *key;
+}
+static void cache_remove_callback(link_t *item)
+{
+}
+static hash_table_operations_t cache_ops = {
+    .hash = cache_hash,
+    .compare = cache_compare,
+    .remove_callback = cache_remove_callback
+};
+int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    cache_t *cache;
+    if (!devcon)
+        return ENOENT;
+    if (devcon->cache)
+        return EEXIST;
+    cache = malloc(sizeof(cache_t));
+    if (!cache)
+        return ENOMEM;
+    futex_initialize(&cache->lock, 1);
+    list_initialize(&cache->free_head);
+    cache->block_size = size;
+    cache->block_count = blocks;
+    if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
+        &cache_ops)) {
+        free(cache);
+        return ENOMEM;
+    }
+    devcon->cache = cache;
+    return EOK;
+}
+static bool cache_can_grow(cache_t *cache)
+{
+    return true;
+}
+static void block_initialize(block_t *b)
+{
+    futex_initialize(&b->lock, 1);
+    b->refcnt = 1;
+    b->dirty = false;
+    rwlock_initialize(&b->contents_lock);
+    link_initialize(&b->free_link);
+    link_initialize(&b->hash_link);
+}
+/** Instantiate a block in memory and get a reference to it.
+ *
+ * @param dev_handle        Device handle of the block device.
+ * @param boff          Block offset.
+ * @param flags         If BLOCK_FLAGS_NOREAD is specified, block_get()
+ *              will not read the contents of the block from the
+ *              device.
+ *
+ * @return          Block structure.
+ */
+block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags)
+{
+    devcon_t *devcon;
+    cache_t *cache;
+    block_t *b;
+    link_t *l;
+    unsigned long key = boff;
+    devcon = devcon_search(dev_handle);
+    assert(devcon);
+    assert(devcon->cache);
+    cache = devcon->cache;
+    futex_down(&cache->lock);
+    l = hash_table_find(&cache->block_hash, &key);
+    if (l) {
+        /*
+         * We found the block in the cache.
+         */
+        b = hash_table_get_instance(l, block_t, hash_link);
+        futex_down(&b->lock);
+        if (b->refcnt++ == 0)
+            list_remove(&b->free_link);
+        futex_up(&b->lock);
+        futex_up(&cache->lock);
+    } else {
+        /*
+         * The block was not found in the cache.
+         */
+        int rc;
+        off_t bufpos = 0;
+        size_t buflen = 0;
+        off_t pos = boff * cache->block_size;
+        bool sync = false;
+        if (cache_can_grow(cache)) {
+            /*
+             * We can grow the cache by allocating new blocks.
+             * Should the allocation fail, we fail over and try to
+             * recycle a block from the cache.
+             */
+            b = malloc(sizeof(block_t));
+            if (!b)
+                goto recycle;
+            b->data = malloc(cache->block_size);
+            if (!b->data) {
+                free(b);
+                goto recycle;
+            }
+        } else {
+            /*
+             * Try to recycle a block from the free list.
+             */
+            unsigned long temp_key;
+recycle:
+            assert(!list_empty(&cache->free_head));
+            l = cache->free_head.next;
+            list_remove(l);
+            b = hash_table_get_instance(l, block_t, hash_link);
+            sync = b->dirty;
+            temp_key = b->boff;
+            hash_table_remove(&cache->block_hash, &temp_key, 1);
+        }
+        block_initialize(b);
+        b->dev_handle = dev_handle;
+        b->size = cache->block_size;
+        b->boff = boff;
+        hash_table_insert(&cache->block_hash, &key, &b->hash_link);
+        /*
+         * Lock the block before releasing the cache lock. Thus we don't
+         * kill concurent operations on the cache while doing I/O on the
+         * block.
+         */
+        futex_down(&b->lock);
+        futex_up(&cache->lock);
+        if (sync) {
+            /*
+             * The block is dirty and needs to be written back to
+             * the device before we can read in the new contents.
+             */
+            abort();    /* TODO: block_write() */
+        }
+        if (!(flags & BLOCK_FLAGS_NOREAD)) {
+            /*
+             * The block contains old or no data. We need to read
+             * the new contents from the device.
+             */
+            rc = block_read(dev_handle, &bufpos, &buflen, &pos,
+                b->data, cache->block_size, cache->block_size);
+            assert(rc == EOK);
+        }
+        futex_up(&b->lock);
+    }
+    return b;
+}
+/** Release a reference to a block.
+ *
+ * If the last reference is dropped, the block is put on the free list.
+ *
+ * @param block     Block of which a reference is to be released.
+ */
+void block_put(block_t *block)
+{
+    devcon_t *devcon = devcon_search(block->dev_handle);
+    cache_t *cache;
+    assert(devcon);
+    assert(devcon->cache);
+    cache = devcon->cache;
+    futex_down(&cache->lock);
+    futex_down(&block->lock);
+    if (!--block->refcnt) {
+        /*
+         * Last reference to the block was dropped, put the block on the
+         * free list.
+         */
+        list_append(&block->free_link, &cache->free_head);
+    }
+    futex_up(&block->lock);
+    futex_up(&cache->lock);
+}
+/** Read data from a block device.
+ *
+ * @param dev_handle    Device handle of the block device.
+ * @param bufpos    Pointer to the first unread valid offset within the
+ *          communication buffer.
+ * @param buflen    Pointer to the number of unread bytes that are ready in
+ *          the communication buffer.
+ * @param pos       Device position to be read.
+ * @param dst       Destination buffer.
+ * @param size      Size of the destination buffer.
+ * @param block_size    Block size to be used for the transfer.
+ *
+ * @return      EOK on success or a negative return code on failure.
+ */
+int
+block_read(int dev_handle, off_t *bufpos, size_t *buflen, off_t *pos, void *dst,
+    size_t size, size_t block_size)
+{
+    off_t offset = 0;
+    size_t left = size;
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    while (left > 0) {
+        size_t rd;
+        if (*bufpos + left < *buflen)
+            rd = left;
+        else
+            rd = *buflen - *bufpos;
+        if (rd > 0) {
+            /*
+             * Copy the contents of the communication buffer to the
+             * destination buffer.
+             */
+            memcpy(dst + offset, devcon->com_area + *bufpos, rd);
+            offset += rd;
+            *bufpos += rd;
+            *pos += rd;
+            left -= rd;
+        }
+        if (*bufpos == *buflen) {
+            /* Refill the communication buffer with a new block. */
+            ipcarg_t retval;
+            int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK,
+                *pos / block_size, block_size, &retval);
+            if ((rc != EOK) || (retval != EOK))
+                return (rc != EOK ? rc : retval);
+            *bufpos = 0;
+            *buflen = block_size;
+        }
+    }
+    return EOK;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libblock/Makefile
 ,0 → 1,67
+#
+# Copyright (c) 2005 Martin Decky
+# Copyright (c) 2007 Jakub Jermar
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+# - The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+## Common compiler flags
+#
+LIBC_PREFIX = ../libc
+## Setup toolchain
+#
+include $(LIBC_PREFIX)/Makefile.toolchain
+CFLAGS += -Iinclude
+## Sources
+#
+SOURCES = \
+    libblock.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend
+all: libblock.a
+-include Makefile.depend
+clean:
+    -rm -f libblock.a Makefile.depend
+    find . -name '*.o' -follow -exec rm \{\} \;
+depend:
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+libblock.a: depend $(OBJECTS)
+    $(AR) rc libblock.a $(OBJECTS)
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/lib/libblock/libblock.h
 ,0 → 1,105
+/*
+ * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2008 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libblock
+ * @{
+ */
+/**
+ * @file
+ */
+#ifndef LIBBLOCK_LIBBLOCK_H_
+#define LIBBLOCK_LIBBLOCK_H_
+#include <stdint.h>
+#include "../../srv/vfs/vfs.h"
+#include <futex.h>
+#include <rwlock.h>
+#include <libadt/hash_table.h>
+#include <libadt/list.h>
+/*
+ * Flags that can be used with block_get().
+ */
+/**
+ * This macro is a symbolic value for situations where no special flags are
+ * needed.
+ */
+#define BLOCK_FLAGS_NONE    0
+/**
+ * When the client of block_get() intends to overwrite the current contents of
+ * the block, this flag is used to avoid the unnecessary read.
+ */
+#define BLOCK_FLAGS_NOREAD  1
+typedef unsigned bn_t;  /**< Block number type. */
+typedef struct block {
+    /** Futex protecting the reference count. */
+    futex_t lock;
+    /** Number of references to the block_t structure. */
+    unsigned refcnt;
+    /** If true, the block needs to be written back to the block device. */
+    bool dirty;
+    /** Readers / Writer lock protecting the contents of the block. */
+    rwlock_t contents_lock;
+    /** Handle of the device where the block resides. */
+    dev_handle_t dev_handle;
+    /** Block offset on the block device. Counted in 'size'-byte blocks. */
+    bn_t boff;
+    /** Size of the block. */
+    size_t size;
+    /** Link for placing the block into the free block list. */
+    link_t free_link;
+    /** Link for placing the block into the block hash table. */
+    link_t hash_link;
+    /** Buffer with the block data. */
+    void *data;
+} block_t;
+extern int block_init(dev_handle_t, size_t);
+extern void block_fini(dev_handle_t);
+extern int block_bb_read(dev_handle_t, off_t, size_t);
+extern void *block_bb_get(dev_handle_t);
+extern int block_cache_init(dev_handle_t, size_t, unsigned);
+extern block_t *block_get(dev_handle_t, bn_t, int flags);
+extern void block_put(block_t *);
+extern int block_read(int, off_t *, size_t *, off_t *, void *, size_t, size_t);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/softint/Makefile
 ,6 → 30,7
 #
 LIBC_PREFIX = ../libc
 ## Setup toolchain
 #
 ,7 → 59,7
     find generic/ -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEMD_DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libsoftint.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libsoftint.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/network/uspace/lib/libc/include/align.h
 ,21 → 35,28
 #ifndef LIBC_ALIGN_H_
 #define LIBC_ALIGN_H_
-/** Align to the nearest lower address.
+/** Align to the nearest lower address which is a power of two.
  *
- * @param s Address or size to be aligned.
- * @param a Size of alignment, must be power of 2.
+ * @param s     Address or size to be aligned.
+ * @param a     Size of alignment, must be power of 2.
  */
 #define ALIGN_DOWN(s, a)    ((s) & ~((a) - 1))
-/** Align to the nearest higher address.
+/** Align to the nearest higher address which is a power of two.
  *
- * @param s Address or size to be aligned.
- * @param a Size of alignment, must be power of 2.
+ * @param s     Address or size to be aligned.
+ * @param a     Size of alignment, must be power of 2.
  */
 #define ALIGN_UP(s, a)      ((long)((s) + ((a) - 1)) & ~((long) (a) - 1))
+/** Round up to the nearest higher boundary.
+ *
+ * @param n     Number to be aligned.
+ * @param b     Boundary, arbitrary unsigned number.
+ */
+#define ROUND_UP(n, b)      (((n) / (b) + ((n) % (b) != 0)) * (b))
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/byteorder.h
 ,6 → 52,14
 #define uint32_t_be2host(n)     (n)
 #define uint64_t_be2host(n)     (n)
+#define host2uint16_t_le(n)     uint16_t_byteorder_swap(n)
+#define host2uint32_t_le(n)     uint32_t_byteorder_swap(n)
+#define host2uint64_t_le(n)     uint64_t_byteorder_swap(n)
+#define host2uint16_t_be(n)     (n)
+#define host2uint32_t_be(n)     (n)
+#define host2uint64_t_be(n)     (n)
 #else
 #define uint16_t_le2host(n)     (n)
 ,6 → 70,14
 #define uint32_t_be2host(n)     uint32_t_byteorder_swap(n)
 #define uint64_t_be2host(n)     uint64_t_byteorder_swap(n)
+#define host2uint16_t_le(n)     (n)
+#define host2uint32_t_le(n)     (n)
+#define host2uint64_t_le(n)     (n)
+#define host2uint16_t_be(n)     uint16_t_byteorder_swap(n)
+#define host2uint32_t_be(n)     uint32_t_byteorder_swap(n)
+#define host2uint64_t_be(n)     uint64_t_byteorder_swap(n)
 #endif
 static inline uint64_t uint64_t_byteorder_swap(uint64_t n)

 /branches/network/uspace/lib/libc/include/ddi.h
 ,9 → 37,11
 #include <task.h>
-extern int physmem_map(void *pf, void *vp, unsigned long pages, int flags);
-extern int iospace_enable(task_id_t id, void *ioaddr, unsigned long size);
-extern int preemption_control(int enable);
+extern int device_assign_devno(void);
+extern int physmem_map(void *, void *, unsigned long, int);
+extern int iospace_enable(task_id_t, void *, unsigned long);
+extern int preemption_control(int);
+extern int pio_enable(void *, size_t, void **);
 #endif

 /branches/network/uspace/lib/libc/include/console.h
 ,0 → 1,53
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_CONSOLE_H_
+#define LIBC_CONSOLE_H_
+#include <console/style.h>
+#include <console/color.h>
+extern void console_clear(void);
+extern void console_goto(int, int);
+extern void console_flush(void);
+extern int console_get_size(int *, int *);
+extern void console_set_style(int);
+extern void console_set_color(int, int, int);
+extern void console_set_rgb_color(int, int);
+extern void console_cursor_visibility(int);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/string.h
 ,16 → 35,9
 #ifndef LIBC_STRING_H_
 #define LIBC_STRING_H_
+#include <mem.h>
 #include <sys/types.h>
-#define bzero(ptr, len) memset((ptr), 0, (len))
-extern void * memset(void *, int, size_t);
-extern void * memcpy(void *, const void *, size_t);
-extern void * memmove(void *, const void *, size_t);
-extern int bcmp(const char *, const char *, size_t);
 extern int strcmp(const char *, const char *);
 extern int strncmp(const char *, const char *, size_t);
 extern int stricmp(const char *, const char *);
 ,6 → 57,9
 extern long int strtol(const char *, char **, int);
 extern unsigned long strtoul(const char *, char **, int);
+extern char * strtok_r(char *, const char *, char **);
+extern char * strtok(char *, const char *);
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/vfs/vfs.h
 ,7 → 39,8
 extern char *absolutize(const char *, size_t *);
-extern int mount(const char *, const char *, const char *);
+extern int mount(const char *, const char *, const char *,
+    const unsigned int flags);
 #endif

 /branches/network/uspace/lib/libc/include/syscall.h
 ,15 → 32,28
 /**
  * @file
  * @brief   Syscall function declaration for architectures that don't
- *      inline syscalls.
+ *      inline syscalls or architectures that handle syscalls
+ *      according to the number of arguments.
  */
 #ifndef LIBC_SYSCALL_H_
 #define LIBC_SYSCALL_H_
+#ifndef LIBARCH_SYSCALL_GENERIC
+#error "You can't include this file directly."
+#endif
 #include <sys/types.h>
 #include <kernel/syscall/syscall.h>
+#define __syscall0  __syscall
+#define __syscall1  __syscall
+#define __syscall2  __syscall
+#define __syscall3  __syscall
+#define __syscall4  __syscall
+#define __syscall5  __syscall
+#define __syscall6  __syscall
 extern sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2,
     const sysarg_t p3, const sysarg_t p4, const sysarg_t p5, const sysarg_t p6,
     const syscall_t id);

 /branches/network/uspace/lib/libc/include/async.h
 ,7 → 76,7
 #define async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, dataptr) \
     async_send_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \
         (arg5), (dataptr))
 extern aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr);
 extern aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
 ,8 → 86,8
 extern int async_wait_timeout(aid_t amsgid, ipcarg_t *retval,
     suseconds_t timeout);
-fid_t async_new_connection(ipcarg_t in_phone_hash,ipc_callid_t callid,
-    ipc_call_t *call, void (*cthread)(ipc_callid_t,ipc_call_t *));
+fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
+    ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *));
 void async_usleep(suseconds_t timeout);
 void async_create_manager(void);
 void async_destroy_manager(void);
 ,7 → 118,7
 /*
  * User-friendly wrappers for async_req_fast() and async_req_slow(). The macros
  * are in the form async_req_m_n(), where m is the number of payload arguments
- * and n is the number of return arguments. The macros decidce between the fast
+ * and n is the number of return arguments. The macros decide between the fast
  * and slow verion based on m.
  */
 #define async_req_0_0(phoneid, method) \

 /branches/network/uspace/lib/libc/include/stdio.h
 ,6 → 52,19
         (void) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, strlen(buf)); \
 }
+typedef struct {
+    /** Underlying file descriptor. */
+    int fd;
+    /** Error indicator. */
+    int error;
+    /** End-of-file indicator. */
+    int eof;
+} FILE;
+extern FILE *stdin, *stdout, *stderr;
 extern int getchar(void);
 extern int puts(const char *);
 ,7 → 72,7
 extern int printf(const char *, ...);
 extern int asprintf(char **, const char *, ...);
-extern int sprintf(char *, const char *fmt, ...);
+extern int sprintf(char *, const char *, ...);
 extern int snprintf(char *, size_t , const char *, ...);
 extern int vprintf(const char *, va_list);
 ,11 → 79,35
 extern int vsprintf(char *, const char *, va_list);
 extern int vsnprintf(char *, size_t, const char *, va_list);
-#define fprintf(f, fmt, ...) printf(fmt, ##__VA_ARGS__)
 extern int rename(const char *, const char *);
+extern FILE *fopen(const char *, const char *);
+extern int fclose(FILE *);
+extern size_t fread(void *, size_t, size_t, FILE *);
+extern size_t fwrite(const void *, size_t, size_t, FILE *);
+extern int feof(FILE *);
+extern int ferror(FILE *);
+extern void clearerr(FILE *);
+extern int fgetc(FILE *);
+extern int fputc(int, FILE *);
+extern int fputs(const char *, FILE *);
+extern int fprintf(FILE *, const char *, ...);
+extern int vfprintf(FILE *, const char *, va_list);
+#define getc fgetc
+#define putc fputc
+extern int fseek(FILE *, long, int);
+#ifndef SEEK_SET
+    #define SEEK_SET    0
+    #define SEEK_CUR    1
+    #define SEEK_END    2
 #endif
+#endif
 /** @}
  */

 /branches/network/uspace/lib/libc/include/task.h
 ,7 → 40,8
 typedef uint64_t task_id_t;
 extern task_id_t task_get_id(void);
-extern task_id_t task_spawn(const char *path, const char *argv[]);
+extern int task_set_name(const char *name);
+extern task_id_t task_spawn(const char *path, char *const argv[]);
 #endif

 /branches/network/uspace/lib/libc/include/unistd.h
 ,9 → 44,11
 #define getpagesize()     (PAGE_SIZE)
-#define SEEK_SET    0
-#define SEEK_CUR    1
-#define SEEK_END    2
+#ifndef SEEK_SET
+    #define SEEK_SET    0
+    #define SEEK_CUR    1
+    #define SEEK_END    2
+#endif
 extern ssize_t write(int, const void *, size_t);
 extern ssize_t read(int, void *, size_t);

 /branches/network/uspace/lib/libc/include/libc.h
 ,14 → 39,20
 #include <kernel/syscall/syscall.h>
 #include <libarch/syscall.h>
-#define __SYSCALL0(id) __syscall(0, 0, 0, 0, 0, 0, id)
-#define __SYSCALL1(id, p1) __syscall(p1, 0, 0, 0, 0, 0, id)
-#define __SYSCALL2(id, p1, p2) __syscall(p1, p2, 0, 0, 0, 0, id)
-#define __SYSCALL3(id, p1, p2, p3) __syscall(p1, p2, p3, 0, 0, 0, id)
-#define __SYSCALL4(id, p1, p2, p3, p4) __syscall(p1, p2, p3, p4, 0, 0, id)
-#define __SYSCALL5(id, p1, p2, p3, p4, p5) __syscall(p1, p2, p3, p4, p5, 0, id)
+#define __SYSCALL0(id) \
+    __syscall0(0, 0, 0, 0, 0, 0, id)
+#define __SYSCALL1(id, p1) \
+    __syscall1(p1, 0, 0, 0, 0, 0, id)
+#define __SYSCALL2(id, p1, p2) \
+    __syscall2(p1, p2, 0, 0, 0, 0, id)
+#define __SYSCALL3(id, p1, p2, p3) \
+    __syscall3(p1, p2, p3, 0, 0, 0, id)
+#define __SYSCALL4(id, p1, p2, p3, p4) \
+    __syscall4(p1, p2, p3, p4, 0, 0, id)
+#define __SYSCALL5(id, p1, p2, p3, p4, p5) \
+    __syscall5(p1, p2, p3, p4, p5, 0, id)
 #define __SYSCALL6(id, p1, p2, p3, p4, p5, p6) \
-    __syscall(p1, p2, p3, p4, p5, p6,id)
+    __syscall6(p1, p2, p3, p4, p5, p6, id)
 extern void __main(void *pcb_ptr);
 extern void __exit(void);

 /branches/network/uspace/lib/libc/include/kbd/keycode.h
 ,0 → 1,220
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_KBD_KEYCODE_H_
+#define LIBC_KBD_KEYCODE_H_
+/** Keycode definitions.
+ *
+ * A keycode identifies a key by its position on the keyboard, rather
+ * than by its label. For human readability, key positions are noted
+ * with the key label on a keyboard with US layout. This label has
+ * nothing to do with the character, that the key produces
+ * -- this is determined by the keymap.
+ *
+ * The keyboard model reflects a standard PC keyboard layout.
+ * Non-standard keyboards need to be mapped to this model in some
+ * logical way. Scancodes are mapped to keycodes with a scanmap.
+ *
+ * For easier mapping to the model and to emphasize the nature of keycodes,
+ * they really are organized here by position, rather than by label.
+ */
+enum keycode {
+    /* Main block row 1 */
+    KC_BACKTICK = 1,
+    KC_1,
+    KC_2,
+    KC_3,
+    KC_4,
+    KC_5,
+    KC_6,
+    KC_7,
+    KC_8,
+    KC_9,
+    KC_0,
+    KC_MINUS,
+    KC_EQUALS,
+    KC_BACKSPACE,
+    /* Main block row 2 */
+    KC_TAB,
+    KC_Q,
+    KC_W,
+    KC_E,
+    KC_R,
+    KC_T,
+    KC_Y,
+    KC_U,
+    KC_I,
+    KC_O,
+    KC_P,
+    KC_LBRACKET,
+    KC_RBRACKET,
+    /* Main block row 3 */
+    KC_CAPS_LOCK,
+    KC_A,
+    KC_S,
+    KC_D,
+    KC_F,
+    KC_G,
+    KC_H,
+    KC_J,
+    KC_K,
+    KC_L,
+    KC_SEMICOLON,
+    KC_QUOTE,
+    KC_BACKSLASH,
+    KC_ENTER,
+    /* Main block row 4 */
+    KC_LSHIFT,
+    KC_Z,
+    KC_X,
+    KC_C,
+    KC_V,
+    KC_B,
+    KC_N,
+    KC_M,
+    KC_COMMA,
+    KC_PERIOD,
+    KC_SLASH,
+    KC_RSHIFT,
+    /* Main block row 5 */
+    KC_LCTRL,
+    KC_LALT,
+    KC_SPACE,
+    KC_RALT,
+    KC_RCTRL,
+    /* Function keys block */
+    KC_ESCAPE,
+    KC_F1,
+    KC_F2,
+    KC_F3,
+    KC_F4,
+    KC_F5,
+    KC_F6,
+    KC_F7,
+    KC_F8,
+    KC_F9,
+    KC_F10,
+    KC_F11,
+    KC_F12,
+    KC_PRTSCR,
+    KC_SCROLL_LOCK,
+    KC_PAUSE,
+    /* Cursor keys block */
+    KC_INSERT,
+    KC_HOME,
+    KC_PAGE_UP,
+    KC_DELETE,
+    KC_END,
+    KC_PAGE_DOWN,
+    KC_UP,
+    KC_LEFT,
+    KC_DOWN,
+    KC_RIGHT,
+    /* Numeric block */
+    KC_NUM_LOCK,
+    KC_NSLASH,
+    KC_NTIMES,
+    KC_NMINUS,
+    KC_NPLUS,
+    KC_NENTER,
+    KC_N7,
+    KC_N8,
+    KC_N9,
+    KC_N4,
+    KC_N5,
+    KC_N6,
+    KC_N1,
+    KC_N2,
+    KC_N3,
+    KC_N0,
+    KC_NPERIOD
+} keycode_t;
+enum keymod {
+    KM_LSHIFT   = 0x001,
+    KM_RSHIFT   = 0x002,
+    KM_LCTRL    = 0x004,
+    KM_RCTRL    = 0x008,
+    KM_LALT     = 0x010,
+    KM_RALT     = 0x020,
+    KM_CAPS_LOCK    = 0x040,
+    KM_NUM_LOCK = 0x080,
+    KM_SCROLL_LOCK  = 0x100,
+    KM_SHIFT    = KM_LSHIFT | KM_RSHIFT,
+    KM_CTRL     = KM_LCTRL | KM_RCTRL,
+    KM_ALT      = KM_LALT | KM_RALT
+} keymod_t;
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/kbd/kbd.h
 ,0 → 1,63
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_KBD_H_
+#define LIBC_KBD_H_
+typedef enum kbd_ev_type {
+    KE_PRESS,
+    KE_RELEASE
+} kbd_ev_type_t;
+/** Keyboard event structure. */
+typedef struct {
+    /** Press or release event. */
+    kbd_ev_type_t type;
+    /** Keycode of the key that was pressed or released. */
+    unsigned int key;
+    /** Bitmask of modifiers held. */
+    unsigned int mods;
+    /** The character that was generated or '\0' for none. */
+    char c;
+} kbd_event_t;
+extern int kbd_get_event(kbd_event_t *);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/udebug.h
 ,0 → 1,58
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_UDEBUG_H_
+#define LIBC_UDEBUG_H_
+#include <kernel/udebug/udebug.h>
+#include <sys/types.h>
+#include <libarch/types.h>
+typedef sysarg_t thash_t;
+int udebug_begin(int phoneid);
+int udebug_end(int phoneid);
+int udebug_set_evmask(int phoneid, udebug_evmask_t mask);
+int udebug_thread_read(int phoneid, void *buffer, size_t n,
+    size_t *copied, size_t *needed);
+int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n);
+int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer);
+int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
+    sysarg_t *val0, sysarg_t *val1);
+int udebug_stop(int phoneid, thash_t tid);
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/console/color.h
 ,0 → 1,55
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_CONSOLE_COLOR_H_
+#define LIBC_CONSOLE_COLOR_H_
+enum console_color {
+    COLOR_BLACK = 0,
+    COLOR_BLUE  = 1,
+    COLOR_GREEN = 2,
+    COLOR_CYAN  = 3,
+    COLOR_RED   = 4,
+    COLOR_MAGENTA   = 5,
+    COLOR_YELLOW    = 6,
+    COLOR_WHITE = 7,
+    CATTR_BRIGHT    = 8,
+    CATTR_BLINK = 8
+};
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/console/style.h
 ,0 → 1,46
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_CONSOLE_STYLE_H_
+#define LIBC_CONSOLE_STYLE_H_
+enum console_style {
+    STYLE_NORMAL    = 0,
+    STYLE_EMPHASIS  = 1
+};
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/mem.h
 ,0 → 1,51
+/*
+ * Copyright (c) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_MEM_H_
+#define LIBC_MEM_H_
+#include <sys/types.h>
+#define bzero(ptr, len)  memset((ptr), 0, (len))
+extern void * memset(void *, int, size_t);
+extern void * memcpy(void *, const void *, size_t);
+extern void * memmove(void *, const void *, size_t);
+extern int bcmp(const char *, const char *, size_t);
+#endif
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/network/uspace/lib/libc/include/loader/pcb.h
 ,31 → 40,32
 typedef void (*entry_point_t)(void);
-/**
+/** Program Control Block.
+ *
  * Holds pointers to data passed from the program loader to the program
  * and/or to the dynamic linker. This includes the program entry point,
  * arguments, environment variables etc.
  */
 typedef struct {
-    /** Program entry point */
+    /** Program entry point. */
     entry_point_t entry;
-    /** Number of command-line arguments */
+    /** Number of command-line arguments. */
     int argc;
-    /** Command-line arguments */
+    /** Command-line arguments. */
     char **argv;
     /*
-     * ELF-specific data
+     * ELF-specific data.
      */
-    /** Pointer to ELF dynamic section of the program */
+    /** Pointer to ELF dynamic section of the program. */
     void *dynamic;
-    /** Pointer to dynamic section of the runtime linker */
-    void *rtld_dynamic;
-    /** Runtime-linker load bias */
-    uintptr_t rtld_bias;
 } pcb_t;
+/**
+ * A pointer to the program control block. Having received the PCB pointer,
+ * the C library startup code stores it here for later use.
+ */
 extern pcb_t *__pcb;
 #endif

 /branches/network/uspace/lib/libc/include/loader/loader.h
 ,0 → 1,60
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup fs
+ * @{
+ */
+/** @file
+ * @brief Program loader interface.
+ */
+#ifndef LIBC_LOADER_H_
+#define LIBC_LOADER_H_
+#include <task.h>
+/** Abstraction of a loader connection */
+typedef struct {
+    /** ID of the phone connected to the loader. */
+    int phone_id;
+} loader_t;
+extern int loader_spawn(const char *);
+extern loader_t *loader_connect(void);
+extern int loader_get_task_id(loader_t *, task_id_t *);
+extern int loader_set_pathname(loader_t *, const char *);
+extern int loader_set_args(loader_t *, char *const []);
+extern int loader_load_program(loader_t *);
+extern int loader_run(loader_t *);
+extern void loader_abort(loader_t *);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/lib/libc/include/io/stream.h
 ,7 → 47,8
 extern ssize_t write_stdout(const void *, size_t);
 extern ssize_t write_stderr(const void *, size_t);
-extern int get_cons_phone(void);
+extern int get_console_phone(void);
+extern void console_wait(void);
 #endif

 /branches/network/uspace/lib/libc/include/ctype.h
 ,11 → 79,19
 static inline int tolower(int c)
 {
     if (isupper(c))
-        return (c + ('a' - 'A' > 0 ? 'a' - 'A' : 'A' - 'a'));
+        return (c + ('a' - 'A'));
     else
         return c;
 }
+static inline int toupper(int c)
+{
+    if (islower(c))
+        return (c + ('A' - 'a'));
+    else
+        return c;
+}
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/macros.h
 ,0 → 1,50
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_MACROS_H_
+#define LIBC_MACROS_H_
+#define SIZE2KB(size) ((size) >> 10)
+#define SIZE2MB(size) ((size) >> 20)
+#define KB2SIZE(kb) ((kb) << 10)
+#define MB2SIZE(mb) ((mb) << 20)
+#define STRING(arg) STRING_ARG(arg)
+#define STRING_ARG(arg) #arg
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/ipc/bus.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_BUS_H_
+#define LIBC_BUS_H_
+#include <ipc/ipc.h>
+typedef enum {
+    BUS_CLEAR_INTERRUPT = IPC_FIRST_USER_METHOD
+} bus_request_t;
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/include/ipc/ipc.h
 ,8 → 47,7
 } ipc_call_t;
 typedef sysarg_t ipc_callid_t;
-typedef void (* ipc_async_callback_t)(void *private, int retval,
-    ipc_call_t *data);
+typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
 /*
  * User-friendly wrappers for ipc_call_sync_fast() and ipc_call_sync_slow().
 ,22 → 172,20
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (res1), (res2), (res3), (res4), (res5))
-extern int ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2,
-    ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5);
+extern int ipc_call_sync_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *);
-extern int ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
-    ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4,
-    ipcarg_t *result5);
+extern int ipc_call_sync_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *,
+    ipcarg_t *);
-extern ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags);
-extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *data, uint32_t usec);
+extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
+extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
 static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)
 {
     return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT);
 }
-extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *data);
+extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *);
 /*
  * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow().
 ,10 → 206,10
 #define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \
     ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
-extern ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval,
-    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4);
-extern ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval,
-    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5);
+extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t);
+extern ipcarg_t ipc_answer_slow(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t);
 /*
  * User-friendly wrappers for ipc_call_async_fast() and ipc_call_async_slow().
 ,8 → 217,7
  * arguments. The macros decide between the fast and the slow version according
  * to m.
  */
-#define ipc_call_async_0(phoneid, method, private, callback, \
-    can_preempt) \
+#define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \
     ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \
         (callback), (can_preempt))
 #define ipc_call_async_1(phoneid, method, arg1, private, callback, \
 ,23 → 241,24
     ipc_call_async_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (private), (callback), (can_preempt))
-extern void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, void *private,
-    ipc_async_callback_t callback, int can_preempt);
-extern void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
-    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private,
-    ipc_async_callback_t callback, int can_preempt);
+extern void ipc_call_async_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, void *, ipc_async_callback_t, int);
+extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int);
-extern int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
-    ipcarg_t *phone);
-extern int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3);
-extern int ipc_hangup(int phoneid);
-extern int ipc_register_irq(int inr, int devno, int method, irq_code_t *code);
-extern int ipc_unregister_irq(int inr, int devno);
-extern int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method,
-    ipcarg_t arg1, ipcarg_t arg2, int mode);
+#define IPC_FLAG_BLOCKING  0x01
+extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *);
+extern int ipc_connect_me_to(int, int, int, int);
+extern int ipc_connect_me_to_blocking(int, int, int, int);
+extern int ipc_hangup(int);
+extern int ipc_register_irq(int, int, int, irq_code_t *);
+extern int ipc_unregister_irq(int, int);
+extern int ipc_forward_fast(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, int);
+extern int ipc_forward_slow(ipc_callid_t, int, int, ipcarg_t, ipcarg_t,
+    ipcarg_t, ipcarg_t, ipcarg_t, int);
 /*
  * User-friendly wrappers for ipc_share_in_start().
  */
 ,20 → 271,23
 #define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
     ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
-extern int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
-    int *flags);
-extern int ipc_share_in_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags);
-extern int ipc_share_out_start(int phoneid, void *src, int flags);
-extern int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags);
-extern int ipc_share_out_finalize(ipc_callid_t callid, void *dst);
-extern int ipc_data_read_start(int phoneid, void *dst, size_t size);
-extern int ipc_data_read_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_data_read_finalize(ipc_callid_t callid, void *src, size_t size);
-extern int ipc_data_write_start(int phoneid, void *src, size_t size);
-extern int ipc_data_write_receive(ipc_callid_t *callid, size_t *size);
-extern int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size);
+extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
+extern int ipc_share_in_receive(ipc_callid_t *, size_t *);
+extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
+extern int ipc_share_out_start(int, void *, int);
+extern int ipc_share_out_receive(ipc_callid_t *, size_t *, int *);
+extern int ipc_share_out_finalize(ipc_callid_t, void *);
+extern int ipc_data_read_start(int, void *, size_t);
+extern int ipc_data_read_receive(ipc_callid_t *, size_t *);
+extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);
+extern int ipc_data_write_start(int, const void *, size_t);
+extern int ipc_data_write_receive(ipc_callid_t *, size_t *);
+extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t);
+#include <task.h>
+extern int ipc_connect_kbox(task_id_t);
 #endif
 /** @}

 /branches/network/uspace/lib/libc/include/ipc/console.h
 ,0 → 1,56
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcipc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_IPC_CONSOLE_H_
+#define LIBC_IPC_CONSOLE_H_
+#include <ipc/ipc.h>
+typedef enum {
+    CONSOLE_GETKEY = IPC_FIRST_USER_METHOD,
+    CONSOLE_PUTCHAR,
+    CONSOLE_CLEAR,
+    CONSOLE_GOTO,
+    CONSOLE_GETSIZE,
+    CONSOLE_FLUSH,
+    CONSOLE_SET_STYLE,
+    CONSOLE_SET_COLOR,
+    CONSOLE_SET_RGB_COLOR,
+    CONSOLE_CURSOR_VISIBILITY
+} console_request_t;
+#endif
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/network/uspace/lib/libc/include/ipc/services.h
 ,8 → 30,8
  * @{
  */
 /**
- * @file    services.h
- * @brief   List of all known services and their codes.
+ * @file  services.h
+ * @brief List of all known services and their codes.
  */
 #ifndef LIBIPC_SERVICES_H_
 ,12 → 38,15
 #define LIBIPC_SERVICES_H_
 typedef enum {
-    SERVICE_PCI = 1,
+    SERVICE_LOAD = 1,
+    SERVICE_PCI,
     SERVICE_KEYBOARD,
     SERVICE_VIDEO,
     SERVICE_CONSOLE,
     SERVICE_VFS,
     SERVICE_DEVMAP,
+    SERVICE_FHC,
+    SERVICE_OBIO,
     SERVICE_NETWORKING,
     SERVICE_LO,
     SERVICE_DP8390_ISA,

 /branches/network/uspace/lib/libc/include/ipc/loader.h
 ,17 → 32,19
 /** @file
  */
-#ifndef LIBC_LOADER_H_
-#define LIBC_LOADER_H_
+#ifndef LIBC_IPC_LOADER_H_
+#define LIBC_IPC_LOADER_H_
 #include <ipc/ipc.h>
 typedef enum {
     LOADER_HELLO = IPC_FIRST_USER_METHOD,
+    LOADER_GET_TASKID,
     LOADER_SET_PATHNAME,
     LOADER_SET_ARGS,
+    LOADER_LOAD,
     LOADER_RUN
-} fb_request_t;
+} loader_request_t;
 #endif

/branches/network/uspace/lib/libc/include/ipc/fb.h
48,10 → 48,11
FB_VIEWPORT_CREATE,
FB_VIEWPORT_DELETE,
FB_SET_STYLE,
FB_SET_COLOR,
FB_SET_RGB_COLOR,
FB_GET_RESOLUTION,
FB_DRAW_TEXT_DATA,
FB_FLUSH,
FB_VIEWPORT_DB,
FB_DRAW_PPM,
FB_PREPARE_SHM,
FB_DROP_SHM,
59,7 → 60,6
FB_VP_DRAW_PIXMAP,
FB_VP2PIXMAP,
FB_DROP_PIXMAP,
FB_TRANS_PUTCHAR,
FB_ANIM_CREATE,
FB_ANIM_DROP,
FB_ANIM_ADDPIXMAP,
69,7 → 69,6
FB_POINTER_MOVE
} fb_request_t;


#endif

/** @}

 /branches/network/uspace/lib/libc/include/errno.h
 ,6 → 35,10
 #ifndef LIBC_ERRNO_H_
 #define LIBC_ERRNO_H_
+/* TODO: support threads/fibrils */
+extern int _errno;
+#define errno _errno
 #include <kernel/errno.h>
 #define ENAMETOOLONG    (-256)
 ,6 → 50,8
 #define EBADF       (-262)
 #define ERANGE      (-263)
 #define EXDEV       (-264)
+#define EIO     (-265)
+#define EMLINK      (-266)
 #endif

 /branches/network/uspace/lib/libc/include/sys/types.h
 ,6 → 42,10
 typedef long off_t;
 typedef int mode_t;
+typedef volatile uint8_t ioport8_t;
+typedef volatile uint16_t ioport16_t;
+typedef volatile uint32_t ioport32_t;
 #endif
 /** @}

 /branches/network/uspace/lib/libc/Makefile.toolchain
 ,16 → 26,23
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-DEFS = -DARCH=$(ARCH)
-CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration -Wmissing-prototypes -O3 -nostdlib -nostdinc -I$(LIBC_PREFIX)/include
+CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration -Wmissing-prototypes -O3 -nostdlib -nostdinc -imacros $(LIBC_PREFIX)/../../../config.h -I$(LIBC_PREFIX)/include -pipe -g
 LFLAGS = -M -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS =
-#-Werror
+## Cross-toolchain prefix
+#
+ifndef CROSS_PREFIX
+    CROSS_PREFIX = /usr/local
+endif
 ## Setup platform configuration
 #
-include $(LIBC_PREFIX)/arch/$(ARCH)/Makefile.inc
+-include $(LIBC_PREFIX)/../../../Makefile.config
+-include $(LIBC_PREFIX)/../../../config.defs
+-include $(LIBC_PREFIX)/arch/$(UARCH)/Makefile.inc
 ## Simple detection of the host system
 #
 ,6 → 66,7
     AR = $(BINUTILS_PREFIX)ar
     OBJCOPY = $(BINUTILS_PREFIX)objcopy
     OBJDUMP = $(BINUTILS_PREFIX)objdump
+    DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
 endif
 ifeq ($(COMPILER),icc_native)
 ,6 → 76,7
     AR = ar
     OBJCOPY = objcopy
     OBJDUMP = objdump
+    DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
 endif
 ifeq ($(COMPILER),gcc_cross)
 ,5 → 86,5
     AR = $(TOOLCHAIN_DIR)/$(TARGET)-ar
     OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy
     OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
+    DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
 endif

 /branches/network/uspace/lib/libc/generic/time.c
 ,6 → 47,8
 #include <as.h>
 #include <ddi.h>
+#include <time.h>
 /* Pointers to public variables with time */
 struct {
     volatile sysarg_t seconds1;

 /branches/network/uspace/lib/libc/generic/ddi.c
 ,26 → 33,42
  */
 #include <ddi.h>
+#include <libarch/ddi.h>
 #include <libc.h>
 #include <task.h>
+#include <as.h>
+#include <align.h>
+#include <libarch/config.h>
 #include <kernel/ddi/ddi_arg.h>
+/** Return unique device number.
+ *
+ * @return New unique device number.
+ *
+ */
+int device_assign_devno(void)
+{
+    return __SYSCALL0(SYS_DEVICE_ASSIGN_DEVNO);
+}
 /** Map piece of physical memory to task.
  *
  * Caller of this function must have the CAP_MEM_MANAGER capability.
  *
- * @param pf Physical address of the starting frame.
- * @param vp Virtual address of the sterting page.
- * @param pages Number of pages to map.
- * @param flags Flags for the new address space area.
+ * @param pf        Physical address of the starting frame.
+ * @param vp        Virtual address of the starting page.
+ * @param pages     Number of pages to map.
+ * @param flags     Flags for the new address space area.
  *
- * @return 0 on success, EPERM if the caller lacks the CAP_MEM_MANAGER capability,
- *     ENOENT if there is no task with specified ID and ENOMEM if there
- *     was some problem in creating address space area.
+ * @return      0 on success, EPERM if the caller lacks the
+ *          CAP_MEM_MANAGER capability, ENOENT if there is no task
+ *          with specified ID and ENOMEM if there was some problem
+ *          in creating address space area.
  */
 int physmem_map(void *pf, void *vp, unsigned long pages, int flags)
 {
-    return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) pf, (sysarg_t) vp, pages, flags);
+    return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) pf, (sysarg_t) vp, pages,
+        flags);
 }
 /** Enable I/O space range to task.
 ,13 → 75,14
  *
  * Caller of this function must have the IO_MEM_MANAGER capability.
  *
- * @param id Task ID.
- * @param ioaddr Starting address of the I/O range.
- * @param size Size of the range.
+ * @param id        Task ID.
+ * @param ioaddr    Starting address of the I/O range.
+ * @param size      Size of the range.
  *
- * @return 0 on success, EPERM if the caller lacks the CAP_IO_MANAGER capability,
- *     ENOENT if there is no task with specified ID and ENOMEM if there
- *     was some problem in allocating memory.
+ * @return      0 on success, EPERM if the caller lacks the
+ *          CAP_IO_MANAGER capability, ENOENT if there is no task
+ *          with specified ID and ENOMEM if there was some problem
+ *          in allocating memory.
  */
 int iospace_enable(task_id_t id, void *ioaddr, unsigned long size)
 {
 ,7 → 97,7
 /** Interrupt control
  *
- * @param enable 1 - enable interrupts, 0 - disable interrupts
+ * @param enable    1 - enable interrupts, 0 - disable interrupts
  */
 int preemption_control(int enable)
 {
 ,5 → 104,36
     return __SYSCALL1(SYS_PREEMPT_CONTROL, (sysarg_t) enable);
 }
+/** Enable PIO for specified I/O range.
+ *
+ * @param pio_addr  I/O start address.
+ * @param size      Size of the I/O region.
+ * @param use_addr  Address where the final address for application's PIO
+ *          will be stored.
+ *
+ * @return      Zero on success or negative error code.
+ */
+int pio_enable(void *pio_addr, size_t size, void **use_addr)
+{
+    void *phys;
+    void *virt;
+    size_t offset;
+    unsigned int pages;
+#ifdef IO_SPACE_BOUNDARY
+    if (pio_addr < IO_SPACE_BOUNDARY) {
+        *use_addr = pio_addr;
+        return iospace_enable(task_get_id(), pio_addr, size);
+    }
+#endif
+    phys = ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
+    offset = pio_addr - phys;
+    pages = ALIGN_UP(offset + size, PAGE_SIZE) >> PAGE_WIDTH;
+    virt = as_get_mappable_page(pages);
+    *use_addr = virt + offset;
+    return physmem_map(phys, virt, pages, AS_AREA_READ | AS_AREA_WRITE);
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/kbd.c
 ,0 → 1,61
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <stdio.h>
+#include <io/stream.h>
+#include <kbd/kbd.h>
+#include <ipc/ipc.h>
+#include <ipc/console.h>
+#include <async.h>
+int kbd_get_event(kbd_event_t *ev)
+{
+    int console_phone = get_console_phone();
+    ipcarg_t r0, r1, r2, r3;
+    int rc;
+    rc = async_req_0_4(console_phone, CONSOLE_GETKEY, &r0, &r1, &r2, &r3);
+    if (rc < 0)
+        return -1;
+    ev->type = r0;
+    ev->key = r1;
+    ev->mods = r2;
+    ev->c = r3;
+    return 0;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/task.c
 ,14 → 34,11
  */
 #include <task.h>
-#include <ipc/ipc.h>
-#include <ipc/loader.h>
 #include <libc.h>
-#include <string.h>
 #include <stdlib.h>
-#include <async.h>
 #include <errno.h>
-#include <vfs/vfs.h>
+#include <loader/loader.h>
+#include <string.h>
 task_id_t task_get_id(void)
 {
 ,134 → 49,72
     return task_id;
 }
-static int task_spawn_loader(void)
+/** Set the task name.
+ *
+ * @param name  The new name, typically the command used to execute the
+ *      program.
+ * @return  Zero on success or negative error code.
+ */
+int task_set_name(const char *name)
 {
-    int phone_id, rc;
-    rc = __SYSCALL1(SYS_PROGRAM_SPAWN_LOADER, (sysarg_t) &phone_id);
-    if (rc != 0)
-        return rc;
-    return phone_id;
+    return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, strlen(name));
 }
-static int loader_set_args(int phone_id, const char *argv[])
-{
-    aid_t req;
-    ipc_call_t answer;
-    ipcarg_t rc;
-    const char **ap;
-    char *dp;
-    char *arg_buf;
-    size_t buffer_size;
-    size_t len;
-    /*
-     * Serialize the arguments into a single array. First
-     * compute size of the buffer needed.
-     */
-    ap = argv;
-    buffer_size = 0;
-    while (*ap != NULL) {
-        buffer_size += strlen(*ap) + 1;
-        ++ap;
-    }
-    arg_buf = malloc(buffer_size);
-    if (arg_buf == NULL) return ENOMEM;
-    /* Now fill the buffer with null-terminated argument strings */
-    ap = argv;
-    dp = arg_buf;
-    while (*ap != NULL) {
-        strcpy(dp, *ap);
-        dp += strlen(*ap) + 1;
-        ++ap;
-    }
-    /* Send serialized arguments to the loader */
-    req = async_send_0(phone_id, LOADER_SET_ARGS, &answer);
-    rc = ipc_data_write_start(phone_id, (void *)arg_buf, buffer_size);
-    if (rc != EOK) {
-        async_wait_for(req, NULL);
-        return rc;
-    }
-    async_wait_for(req, &rc);
-    if (rc != EOK) return rc;
-    /* Free temporary buffer */
-    free(arg_buf);
-    return EOK;
-}
-/** Create a new task by running an executable from VFS.
+/** Create a new task by running an executable from the filesystem.
  *
+ * This is really just a convenience wrapper over the more complicated
+ * loader API.
+ *
  * @param path  pathname of the binary to execute
  * @param argv  command-line arguments
  * @return  ID of the newly created task or zero on error.
  */
-task_id_t task_spawn(const char *path, const char *argv[])
+task_id_t task_spawn(const char *path, char *const argv[])
 {
-    int phone_id;
-    ipc_call_t answer;
-    aid_t req;
+    loader_t *ldr;
+    task_id_t task_id;
     int rc;
-    ipcarg_t retval;
-    char *pa;
-    size_t pa_len;
-    pa = absolutize(path, &pa_len);
-    if (!pa)
+    /* Connect to a program loader. */
+    ldr = loader_connect();
+    if (ldr == NULL)
         return 0;
-    /* Spawn a program loader */
-    phone_id = task_spawn_loader();
-    if (phone_id < 0)
-        return 0;
+    /* Get task ID. */
+    rc = loader_get_task_id(ldr, &task_id);
+    if (rc != EOK)
+        goto error;
-    /*
-     * Say hello so that the loader knows the incoming connection's
-     * phone hash.
-     */
-    rc = async_req_0_0(phone_id, LOADER_HELLO);
+    /* Send program pathname. */
+    rc = loader_set_pathname(ldr, path);
     if (rc != EOK)
-        return 0;
+        goto error;
-    /* Send program pathname */
-    req = async_send_0(phone_id, LOADER_SET_PATHNAME, &answer);
-    rc = ipc_data_write_start(phone_id, (void *)pa, pa_len);
-    if (rc != EOK) {
-        async_wait_for(req, NULL);
-        return 1;
-    }
-    async_wait_for(req, &retval);
-    if (retval != EOK)
+    /* Send arguments. */
+    rc = loader_set_args(ldr, argv);
+    if (rc != EOK)
         goto error;
-    /* Send arguments */
-    rc = loader_set_args(phone_id, argv);
+    /* Load the program. */
+    rc = loader_load_program(ldr);
     if (rc != EOK)
         goto error;
-    /* Request loader to start the program */
-    rc = async_req_0_0(phone_id, LOADER_RUN);
+    /* Run it. */
+    rc = loader_run(ldr);
     if (rc != EOK)
         goto error;
     /* Success */
-    ipc_hangup(phone_id);
-    return 1;
+    free(ldr);
+    return task_id;
     /* Error exit */
 error:
-    ipc_hangup(phone_id);
+    loader_abort(ldr);
+    free(ldr);
     return 0;
 }

 /branches/network/uspace/lib/libc/generic/tls.c
 ,7 → 116,7
     tcb_t *tcb;
     size = ALIGN_UP(size, &_tls_alignment);
-    *data = memalign(&_tls_alignment, sizeof(tcb_t) + size);
+    *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);
     tcb = (tcb_t *) (*data + size);
     tcb->self = tcb;

 /branches/network/uspace/lib/libc/generic/console.c
 ,0 → 1,97
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <async.h>
+#include <io/stream.h>
+#include <ipc/console.h>
+#include <console.h>
+void console_clear(void)
+{
+    int cons_phone = get_console_phone();
+    async_msg_0(cons_phone, CONSOLE_CLEAR);
+}
+void console_goto(int row, int col)
+{
+    int cons_phone = get_console_phone();
+    async_msg_2(cons_phone, CONSOLE_GOTO, row, col);
+}
+void console_flush(void)
+{
+    int cons_phone = get_console_phone();
+    async_msg_0(cons_phone, CONSOLE_FLUSH);
+}
+int console_get_size(int *rows, int *cols)
+{
+    int cons_phone = get_console_phone();
+    ipcarg_t r, c;
+    int rc;
+    rc = async_req_0_2(cons_phone, CONSOLE_GETSIZE, &r, &c);
+    *rows = (int) r;
+    *cols = (int) c;
+    return rc;
+}
+void console_set_style(int style)
+{
+    int cons_phone = get_console_phone();
+    async_msg_1(cons_phone, CONSOLE_SET_STYLE, style);
+}
+void console_set_color(int fg_color, int bg_color, int flags)
+{
+    int cons_phone = get_console_phone();
+    async_msg_3(cons_phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
+}
+void console_set_rgb_color(int fg_color, int bg_color)
+{
+    int cons_phone = get_console_phone();
+    async_msg_2(cons_phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
+}
+void console_cursor_visibility(int show)
+{
+    int cons_phone = get_console_phone();
+    async_msg_1(cons_phone, CONSOLE_CURSOR_VISIBILITY, show != 0);
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/string.c
 ,5 → 1,6
 /*
  * Copyright (c) 2005 Martin Decky
+ * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,96 → 34,11
  */
 #include <string.h>
-#include <unistd.h>
+#include <stdlib.h>
+#include <limits.h>
 #include <ctype.h>
-#include <limits.h>
-#include <align.h>
-#include <sys/types.h>
 #include <malloc.h>
-/* Dummy implementation of mem/ functions */
-void *memset(void *s, int c, size_t n)
-{
-    char *os = s;
-    while (n--)
-        *(os++) = c;
-    return s;
-}
-struct along {
-    unsigned long n;
-} __attribute__ ((packed));
-static void *unaligned_memcpy(void *dst, const void *src, size_t n)
-{
-    int i, j;
-    struct along *adst = dst;
-    const struct along *asrc = src;
-    for (i = 0; i < n / sizeof(unsigned long); i++)
-        adst[i].n = asrc[i].n;
-    for (j = 0; j < n % sizeof(unsigned long); j++)
-        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
-            ((unsigned char *) (((unsigned long *) src) + i))[j];
-    return (char *) dst;
-}
-void *memcpy(void *dst, const void *src, size_t n)
-{
-    int i, j;
-    if (((long) dst & (sizeof(long) - 1)) ||
-        ((long) src & (sizeof(long) - 1)))
-        return unaligned_memcpy(dst, src, n);
-    for (i = 0; i < n / sizeof(unsigned long); i++)
-        ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
-    for (j = 0; j < n % sizeof(unsigned long); j++)
-        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
-            ((unsigned char *) (((unsigned long *) src) + i))[j];
-    return (char *) dst;
-}
-void *memmove(void *dst, const void *src, size_t n)
-{
-    int i, j;
-    if (src > dst)
-        return memcpy(dst, src, n);
-    for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
-        ((unsigned char *) ((unsigned long *) dst))[j] =
-            ((unsigned char *) ((unsigned long *) src))[j];
-    for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
-        ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
-    return (char *) dst;
-}
-/** Compare two memory areas.
- *
- * @param s1        Pointer to the first area to compare.
- * @param s2        Pointer to the second area to compare.
- * @param len       Size of the first area in bytes. Both areas must have
- *          the same length.
- * @return      If len is 0, return zero. If the areas match, return
- *          zero. Otherwise return non-zero.
- */
-int bcmp(const char *s1, const char *s2, size_t len)
-{
-    for (; len && *s1++ == *s2++; len--)
-        ;
-    return len;
-}
 /** Count the number of characters in the string, not including terminating 0.
  *
  * @param str       String.
 ,5 → 312,37
     return (char *) memcpy(ret, s1, len);
 }
+char *strtok(char *s, const char *delim)
+{
+    static char *next;
+    return strtok_r(s, delim, &next);
+}
+char *strtok_r(char *s, const char *delim, char **next)
+{
+    char *start, *end;
+    if (s == NULL)
+        s = *next;
+    /* Skip over leading delimiters. */
+    while (*s && (strchr(delim, *s) != NULL)) ++s;
+    start = s;
+    /* Skip over token characters. */
+    while (*s && (strchr(delim, *s) == NULL)) ++s;
+    end = s;
+    *next = (*s ? s + 1 : s);
+    if (start == end) {
+        return NULL;    /* No more tokens. */
+    }
+    /* Overwrite delimiter with NULL terminator. */
+    *end = '\0';
+    return start;
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/loader.c
 ,0 → 1,264
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <ipc/ipc.h>
+#include <ipc/loader.h>
+#include <ipc/services.h>
+#include <libc.h>
+#include <task.h>
+#include <string.h>
+#include <stdlib.h>
+#include <async.h>
+#include <errno.h>
+#include <vfs/vfs.h>
+#include <loader/loader.h>
+/** Connect to a new program loader.
+ *
+ * Spawns a new program loader task and returns the connection structure.
+ * @param name  Symbolic name to set on the newly created task.
+ * @return  Pointer to the loader connection structure (should be
+ *      de-allocated using free() after use).
+ */
+int loader_spawn(const char *name)
+{
+    return __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER,
+        (sysarg_t) name, strlen(name));
+}
+loader_t *loader_connect(void)
+{
+    loader_t *ldr;
+    int phone_id;
+    phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0);
+    if (phone_id < 0)
+        return NULL;
+    ldr = malloc(sizeof(loader_t));
+    if (ldr == NULL)
+        return NULL;
+    ldr->phone_id = phone_id;
+    return ldr;
+}
+/** Get ID of the new task.
+ *
+ * Retrieves the ID of the new task from the loader.
+ *
+ * @param ldr       Loader connection structure.
+ * @param task_id   Points to a variable where the ID should be stored.
+ * @return      Zero on success or negative error code.
+ */
+int loader_get_task_id(loader_t *ldr, task_id_t *task_id)
+{
+    ipc_call_t answer;
+    aid_t req;
+    int rc;
+    ipcarg_t retval;
+    /* Get task ID. */
+    req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
+    rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    async_wait_for(req, &retval);
+    return (int)retval;
+}
+/** Set pathname of the program to load.
+ *
+ * Sets the name of the program file to load. The name can be relative
+ * to the current working directory (it will be absolutized before
+ * sending to the loader).
+ *
+ * @param ldr       Loader connection structure.
+ * @param path      Pathname of the program file.
+ * @return      Zero on success or negative error code.
+ */
+int loader_set_pathname(loader_t *ldr, const char *path)
+{
+    ipc_call_t answer;
+    aid_t req;
+    int rc;
+    ipcarg_t retval;
+    char *pa;
+    size_t pa_len;
+    pa = absolutize(path, &pa_len);
+    if (!pa)
+        return 0;
+    /* Send program pathname */
+    req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
+    rc = ipc_data_write_start(ldr->phone_id, (void *)pa, pa_len);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    free(pa);
+    async_wait_for(req, &retval);
+    return (int)retval;
+}
+/** Set command-line arguments for the program.
+ *
+ * Sets the vector of command-line arguments to be passed to the loaded
+ * program. By convention, the very first argument is typically the same as
+ * the command used to execute the program.
+ *
+ * @param ldr       Loader connection structure.
+ * @param argv      NULL-terminated array of pointers to arguments.
+ * @return      Zero on success or negative error code.
+ */
+int loader_set_args(loader_t *ldr, char *const argv[])
+{
+    aid_t req;
+    ipc_call_t answer;
+    ipcarg_t rc;
+    char *const *ap;
+    char *dp;
+    char *arg_buf;
+    size_t buffer_size;
+    /*
+     * Serialize the arguments into a single array. First
+     * compute size of the buffer needed.
+     */
+    ap = argv;
+    buffer_size = 0;
+    while (*ap != NULL) {
+        buffer_size += strlen(*ap) + 1;
+        ++ap;
+    }
+    arg_buf = malloc(buffer_size);
+    if (arg_buf == NULL) return ENOMEM;
+    /* Now fill the buffer with null-terminated argument strings */
+    ap = argv;
+    dp = arg_buf;
+    while (*ap != NULL) {
+        strcpy(dp, *ap);
+        dp += strlen(*ap) + 1;
+        ++ap;
+    }
+    /* Send serialized arguments to the loader */
+    req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
+    rc = ipc_data_write_start(ldr->phone_id, (void *)arg_buf, buffer_size);
+    if (rc != EOK) {
+        async_wait_for(req, NULL);
+        return rc;
+    }
+    async_wait_for(req, &rc);
+    if (rc != EOK) return rc;
+    /* Free temporary buffer */
+    free(arg_buf);
+    return EOK;
+}
+/** Instruct loader to load the program.
+ *
+ * If this function succeeds, the program has been successfully loaded
+ * and is ready to be executed.
+ *
+ * @param ldr       Loader connection structure.
+ * @return      Zero on success or negative error code.
+ */
+int loader_load_program(loader_t *ldr)
+{
+    int rc;
+    rc = async_req_0_0(ldr->phone_id, LOADER_LOAD);
+    if (rc != EOK)
+        return rc;
+    return EOK;
+}
+/** Instruct loader to execute the program.
+ *
+ * Note that this function blocks until the loader actually replies
+ * so you cannot expect this function to return if you are debugging
+ * the task and its thread is stopped.
+ *
+ * After using this function, no further operations must be performed
+ * on the loader structure. It should be de-allocated using free().
+ *
+ * @param ldr       Loader connection structure.
+ * @return      Zero on success or negative error code.
+ */
+int loader_run(loader_t *ldr)
+{
+    int rc;
+    rc = async_req_0_0(ldr->phone_id, LOADER_RUN);
+    if (rc != EOK)
+        return rc;
+    return EOK;
+}
+/** Cancel the loader session.
+ *
+ * Tells the loader not to load any program and terminate.
+ * After using this function, no further operations must be performed
+ * on the loader structure. It should be de-allocated using free().
+ *
+ * @param ldr       Loader connection structure.
+ * @return      Zero on success or negative error code.
+ */
+void loader_abort(loader_t *ldr)
+{
+    ipc_hangup(ldr->phone_id);
+    ldr->phone_id = 0;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/thread.c
 ,8 → 108,8
     uarg->uspace_thread_arg = arg;
     uarg->uspace_uarg = uarg;
-    rc = __SYSCALL3(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
-        (sysarg_t) tid);
+    rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
+        (sysarg_t) strlen(name), (sysarg_t) tid);
     if (rc) {
         /*

 /branches/network/uspace/lib/libc/generic/libc.c
 ,6 → 53,8
 extern char _heap;
 extern int main(int argc, char *argv[]);
+int _errno;
 void _exit(int status)
 {
     thread_exit(status);
 ,8 → 71,6
     f = fibril_setup();
     __tcb_set(f->tcb);
-    open_console();
     /* Save the PCB pointer */
     __pcb = (pcb_t *)pcb_ptr;

 /branches/network/uspace/lib/libc/generic/ipc.c
 ,7 → 598,7
     ipcarg_t newphid;
     int res;
-    res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+    res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
         NULL, NULL, NULL, NULL, &newphid);
     if (res)
         return res;
 ,6 → 605,30
     return newphid;
 }
+/** Ask through phone for a new connection to some service.
+ *
+ * If the connection is not available at the moment, the
+ * call will block.
+ *
+ * @param phoneid   Phone handle used for contacting the other side.
+ * @param arg1      User defined argument.
+ * @param arg2      User defined argument.
+ * @param arg3      User defined argument.
+ *
+ * @return      New phone handle on success or a negative error code.
+ */
+int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3)
+{
+    ipcarg_t newphid;
+    int res;
+    res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+        IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
+    if (res)
+        return res;
+    return newphid;
+}
 /** Hang up a phone.
  *
  * @param phoneid   Handle of the phone to be hung up.
 ,6 → 690,23
         arg2, mode);
 }
+int ipc_forward_slow(ipc_callid_t callid, int phoneid, int method,
+    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
+    int mode)
+{
+    ipc_call_t data;
+    IPC_SET_METHOD(data, method);
+    IPC_SET_ARG1(data, arg1);
+    IPC_SET_ARG2(data, arg2);
+    IPC_SET_ARG3(data, arg3);
+    IPC_SET_ARG4(data, arg4);
+    IPC_SET_ARG5(data, arg5);
+    return __SYSCALL3(SYS_IPC_FORWARD_SLOW, callid, (sysarg_t) &data, mode);
+}
 /** Wrapper for making IPC_M_SHARE_IN calls.
  *
  * @param phoneid   Phone that will be used to contact the receiving side.
 ,7 → 888,7
  *
  * @return      Zero on success or a value from @ref errno.h on failure.
  */
-int ipc_data_read_finalize(ipc_callid_t callid, void *src, size_t size)
+int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
 {
     return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size);
 }
 ,7 → 901,7
  *
  * @return      Zero on success or a negative error code from errno.h.
  */
-int ipc_data_write_start(int phoneid, void *src, size_t size)
+int ipc_data_write_start(int phoneid, const void *src, size_t size)
 {
     return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
         (ipcarg_t) size);
 ,6 → 950,18
 {
     return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size);
 }
+#include <kernel/syscall/sysarg64.h>
+/** Connect to a task specified by id.
+ */
+int ipc_connect_kbox(task_id_t id)
+{
+    sysarg64_t arg;
+    arg.value = (unsigned long long) id;
+    return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg);
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/generic/udebug.c
 ,0 → 1,103
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <udebug.h>
+#include <sys/types.h>
+#include <ipc/ipc.h>
+#include <async.h>
+int udebug_begin(int phoneid)
+{
+    return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_BEGIN);
+}
+int udebug_end(int phoneid)
+{
+    return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_END);
+}
+int udebug_set_evmask(int phoneid, udebug_evmask_t mask)
+{
+    return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_SET_EVMASK,
+        mask);
+}
+int udebug_thread_read(int phoneid, void *buffer, size_t n,
+    size_t *copied, size_t *needed)
+{
+    ipcarg_t a_copied, a_needed;
+    int rc;
+    rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_THREAD_READ,
+        (sysarg_t)buffer, n, NULL, &a_copied, &a_needed);
+    *copied = (size_t)a_copied;
+    *needed = (size_t)a_needed;
+    return rc;
+}
+int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n)
+{
+    return async_req_4_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_MEM_READ,
+        (sysarg_t)buffer, addr, n);
+}
+int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer)
+{
+    return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_ARGS_READ,
+        tid, (sysarg_t)buffer);
+}
+int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
+    sysarg_t *val0, sysarg_t *val1)
+{
+    ipcarg_t a_ev_type;
+    int rc;
+    rc =  async_req_2_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_GO,
+        tid, &a_ev_type, val0, val1);
+    *ev_type = a_ev_type;
+    return rc;
+}
+int udebug_stop(int phoneid, thash_t tid)
+{
+    return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_STOP,
+        tid);
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/async.c
 ,7 → 483,7
 {
     connection_t *conn;
     unsigned long key;
     conn = malloc(sizeof(*conn));
     if (!conn) {
         if (callid)
 ,7 → 498,7
         conn->call = *call;
     conn->wdata.active = 1; /* We will activate the fibril ASAP */
     conn->cfibril = cfibril;
     conn->wdata.fid = fibril_create(connection_fibril, conn);
     if (!conn->wdata.fid) {
         free(conn);
 ,14 → 506,15
             ipc_answer_0(callid, ENOMEM);
         return NULL;
     }
     /* Add connection to the connection hash table */
     key = conn->in_phone_hash;
     futex_down(&async_futex);
     hash_table_insert(&conn_hash_table, &key, &conn->link);
     futex_up(&async_futex);
     fibril_add_ready(conn->wdata.fid);
     return conn->wdata.fid;
 }
 ,6 → 525,7
  *
  * @param callid    Hash of the incoming call.
  * @param call      Data of the incoming call.
+ *
  */
 static void handle_call(ipc_callid_t callid, ipc_call_t *call)
 {
 ,8 → 535,8
         (*interrupt_received)(callid, call);
         _in_interrupt_handler = 0;
         return;
-    }
+    }
     switch (IPC_GET_METHOD(*call)) {
     case IPC_M_CONNECT_ME_TO:
         /* Open new connection with fibril etc. */
 ,11 → 544,11
             client_connection);
         return;
     }
     /* Try to route the call through the connection hash table */
     if (route_call(callid, call))
         return;
     /* Unknown call from unknown phone - hang it up */
     ipc_answer_0(callid, EHANGUP);
 }
 ,23 → 741,17
     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
 {
     amsg_t *msg;
-    if (_in_interrupt_handler) {
-        printf("Cannot send asynchronous request in interrupt "
-            "handler.\n");
-        _exit(1);
-    }
     msg = malloc(sizeof(*msg));
     msg->done = 0;
     msg->dataptr = dataptr;
     /* We may sleep in the next method, but it will use its own mechanism */
     msg->wdata.active = 1;
     ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg,
-        reply_received, 1);
+        reply_received, !_in_interrupt_handler);
     return (aid_t) msg;
 }
 ,23 → 777,17
     ipc_call_t *dataptr)
 {
     amsg_t *msg;
-    if (_in_interrupt_handler) {
-        printf("Cannot send asynchronous request in interrupt "
-            "handler.\n");
-        _exit(1);
-    }
     msg = malloc(sizeof(*msg));
     msg->done = 0;
     msg->dataptr = dataptr;
     /* We may sleep in next method, but it will use its own mechanism */
     msg->wdata.active = 1;
     ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg,
-        reply_received, 1);
+        reply_received, !_in_interrupt_handler);
     return (aid_t) msg;
 }
 ,21 → 874,16
 {
     amsg_t *msg;
-    if (_in_interrupt_handler) {
-        printf("Cannot call async_usleep in interrupt handler.\n");
-        _exit(1);
-    }
     msg = malloc(sizeof(*msg));
     if (!msg)
         return;
     msg->wdata.fid = fibril_get_id();
     msg->wdata.active = 0;
     gettimeofday(&msg->wdata.expires, NULL);
     tv_add(&msg->wdata.expires, timeout);
     futex_down(&async_futex);
     insert_timeout(&msg->wdata);
     /* Leave the async_futex locked when entering this function */

 /branches/network/uspace/lib/libc/generic/vfs/vfs.c
 ,7 → 31,7
  */
 /** @file
  */
 #include <vfs/vfs.h>
 #include <vfs/canonify.h>
 #include <stdlib.h>
 ,7 → 49,7
 #include <errno.h>
 #include <string.h>
 #include <ipc/devmap.h>
-#include "../../srv/vfs/vfs.h"
+#include "../../../srv/vfs/vfs.h"
 int vfs_phone = -1;
 futex_t vfs_phone_futex = FUTEX_INITIALIZER;
 ,7 → 57,7
 futex_t cwd_futex = FUTEX_INITIALIZER;
 DIR *cwd_dir = NULL;
 char *cwd_path = NULL;
-size_t cwd_len = 0;
+size_t cwd_len = 0;
 char *absolutize(const char *path, size_t *retlen)
 {
 ,34 → 109,39
     return ncwd_path;
 }
-static int vfs_connect(void)
+static void vfs_connect(void)
 {
-    if (vfs_phone < 0)
-        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
-    return vfs_phone;
+    while (vfs_phone < 0)
+        vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
 }
-static int device_get_handle(char *name, dev_handle_t *handle)
+static int device_get_handle(const char *name, dev_handle_t *handle,
+    const unsigned int flags)
 {
-    int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
-);
+    int phone;
+    if (flags & IPC_FLAG_BLOCKING)
+        phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+    else
+        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
     if (phone < 0)
         return phone;
     ipc_call_t answer;
-    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
+    aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
         &answer);
     ipcarg_t retval = ipc_data_write_start(phone, name, strlen(name) + 1);
     if (retval != EOK) {
         async_wait_for(req, NULL);
         ipc_hangup(phone);
         return retval;
     }
     async_wait_for(req, &retval);
     if (handle != NULL)
         *handle = -1;
 ,7 → 154,8
     return retval;
 }
-int mount(const char *fs_name, const char *mp, const char *dev)
+int mount(const char *fs_name, const char *mp, const char *dev,
+    const unsigned int flags)
 {
     int res;
     ipcarg_t rc;
 ,7 → 162,7
     aid_t req;
     dev_handle_t dev_handle;
-    res = device_get_handle(dev, &dev_handle);
+    res = device_get_handle(dev, &dev_handle, flags);
     if (res != EOK)
         return res;
 ,20 → 170,13
     char *mpa = absolutize(mp, &mpa_len);
     if (!mpa)
         return ENOMEM;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(mpa);
-            return res;
-        }
-    }
-    req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
-    rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
+    vfs_connect();
+    req = async_send_2(vfs_phone, VFS_MOUNT, dev_handle, flags, NULL);
+    rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_len);
     if (rc != EOK) {
         async_wait_for(req, NULL);
         async_serialize_end();
 ,8 → 184,8
         free(mpa);
         return (int) rc;
     }
-    /* Ask VFS whether it likes fs_name. */
-    rc = async_req_0_0(vfs_phone, IPC_M_PING);
+    rc = ipc_data_write_start(vfs_phone, (void *) fs_name, strlen(fs_name));
     if (rc != EOK) {
         async_wait_for(req, NULL);
         async_serialize_end();
 ,24 → 193,17
         free(mpa);
         return (int) rc;
     }
-    rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
-    if (rc != EOK) {
-        async_wait_for(req, NULL);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        free(mpa);
-        return (int) rc;
-    }
     async_wait_for(req, &rc);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
     free(mpa);
     return (int) rc;
 }
 static int _open(const char *path, int lflag, int oflag, ...)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,15 → 215,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_3(vfs_phone, VFS_OPEN, lflag, oflag, 0, &answer);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,22 → 243,14
 int close(int fildes)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     rc = async_req_1_0(vfs_phone, VFS_CLOSE, fildes);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 259,6
 ssize_t read(int fildes, void *buf, size_t nbyte)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,14 → 265,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
     rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
     if (rc != EOK) {
 ,7 → 286,6
 ssize_t write(int fildes, const void *buf, size_t nbyte)
 {
-    int res;
     ipcarg_t rc;
     ipc_call_t answer;
     aid_t req;
 ,14 → 292,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
     rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
     if (rc != EOK) {
 ,23 → 313,15
 off_t lseek(int fildes, off_t offset, int whence)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
-    off_t newoffs;
+    vfs_connect();
+    ipcarg_t newoffs;
     rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
-        (ipcarg_t)&newoffs);
+        &newoffs);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,24 → 329,17
     if (rc != EOK)
         return (off_t) -1;
-    return newoffs;
+    return (off_t) newoffs;
 }
 int ftruncate(int fildes, off_t length)
 {
-    int res;
     ipcarg_t rc;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            return res;
-        }
-    }
+    vfs_connect();
     rc = async_req_2_0(vfs_phone, VFS_TRUNCATE, fildes, length);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 381,6
 int mkdir(const char *path, mode_t mode)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,18 → 388,11
     char *pa = absolutize(path, &pa_len);
     if (!pa)
         return ENOMEM;
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_1(vfs_phone, VFS_MKDIR, mode, NULL);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,7 → 411,6
 static int _unlink(const char *path, int lflag)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,15 → 421,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(pa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_0(vfs_phone, VFS_UNLINK, NULL);
     rc = ipc_data_write_start(vfs_phone, pa, pa_len);
     if (rc != EOK) {
 ,7 → 451,6
 int rename(const char *old, const char *new)
 {
-    int res;
     ipcarg_t rc;
     aid_t req;
 ,16 → 468,8
     futex_down(&vfs_phone_futex);
     async_serialize_start();
-    if (vfs_phone < 0) {
-        res = vfs_connect();
-        if (res < 0) {
-            async_serialize_end();
-            futex_up(&vfs_phone_futex);
-            free(olda);
-            free(newa);
-            return res;
-        }
-    }
+    vfs_connect();
     req = async_send_0(vfs_phone, VFS_RENAME, NULL);
     rc = ipc_data_write_start(vfs_phone, olda, olda_len);
     if (rc != EOK) {
 ,6 → 522,7
     cwd_path = pa;
     cwd_len = pa_len;
     futex_up(&cwd_futex);
+    return EOK;
 }
 char *getcwd(char *buf, size_t size)

/branches/network/uspace/lib/libc/generic/vfs/canonify.c
36,6 → 36,7
*/

#include <stdlib.h>
#include <vfs/canonify.h>

/** Token types used for tokenization of path. */
typedef enum {

 /branches/network/uspace/lib/libc/generic/mem.c
 ,0 → 1,239
+/*
+ * Copyright (c) 2005 Martin Decky
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <mem.h>
+#include <stdlib.h>
+#include <sys/types.h>
+/** Fill memory block with a constant value. */
+void *memset(void *dest, int b, size_t n)
+{
+    char *pb;
+    unsigned long *pw;
+    size_t word_size;
+    size_t n_words;
+    unsigned long pattern;
+    size_t i;
+    size_t fill;
+    /* Fill initial segment. */
+    word_size = sizeof(unsigned long);
+    fill = word_size - ((uintptr_t) dest & (word_size - 1));
+    if (fill > n) fill = n;
+    pb = dest;
+    i = fill;
+    while (i-- != 0)
+        *pb++ = b;
+    /* Compute remaining size. */
+    n -= fill;
+    if (n == 0) return dest;
+    n_words = n / word_size;
+    n = n % word_size;
+    pw = (unsigned long *) pb;
+    /* Create word-sized pattern for aligned segment. */
+    pattern = 0;
+    i = word_size;
+    while (i-- != 0)
+        pattern = (pattern << 8) | (uint8_t) b;
+    /* Fill aligned segment. */
+    i = n_words;
+    while (i-- != 0)
+        *pw++ = pattern;
+    pb = (char *) pw;
+    /* Fill final segment. */
+    i = n;
+    while (i-- != 0)
+        *pb++ = b;
+    return dest;
+}
+struct along {
+    unsigned long n;
+} __attribute__ ((packed));
+static void *unaligned_memcpy(void *dst, const void *src, size_t n)
+{
+    int i, j;
+    struct along *adst = dst;
+    const struct along *asrc = src;
+    for (i = 0; i < n / sizeof(unsigned long); i++)
+        adst[i].n = asrc[i].n;
+    for (j = 0; j < n % sizeof(unsigned long); j++)
+        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
+            ((unsigned char *) (((unsigned long *) src) + i))[j];
+    return (char *) dst;
+}
+/** Copy memory block. */
+void *memcpy(void *dst, const void *src, size_t n)
+{
+    size_t i;
+    size_t mod, fill;
+    size_t word_size;
+    size_t n_words;
+    const unsigned long *srcw;
+    unsigned long *dstw;
+    const uint8_t *srcb;
+    uint8_t *dstb;
+    word_size = sizeof(unsigned long);
+    /*
+     * Are source and destination addresses congruent modulo word_size?
+     * If not, use unaligned_memcpy().
+     */
+    if (((uintptr_t) dst & (word_size - 1)) !=
+        ((uintptr_t) src & (word_size - 1)))
+        return unaligned_memcpy(dst, src, n);
+    /*
+     * mod is the address modulo word size. fill is the length of the
+     * initial buffer segment before the first word boundary.
+     * If the buffer is very short, use unaligned_memcpy(), too.
+     */
+    mod = (uintptr_t) dst & (word_size - 1);
+    fill = word_size - mod;
+    if (fill > n) fill = n;
+    /* Copy the initial segment. */
+    srcb = src;
+    dstb = dst;
+    i = fill;
+    while (i-- != 0)
+        *dstb++ = *srcb++;
+    /* Compute remaining length. */
+    n -= fill;
+    if (n == 0) return dst;
+    /* Pointers to aligned segment. */
+    dstw = (unsigned long *) dstb;
+    srcw = (const unsigned long *) srcb;
+    n_words = n / word_size;    /* Number of whole words to copy. */
+    n -= n_words * word_size;   /* Remaining bytes at the end. */
+    /* "Fast" copy. */
+    i = n_words;
+    while (i-- != 0)
+        *dstw++ = *srcw++;
+    /*
+     * Copy the rest.
+     */
+    srcb = (const uint8_t *) srcw;
+    dstb = (uint8_t *) dstw;
+    i = n;
+    while (i-- != 0)
+        *dstb++ = *srcb++;
+    return dst;
+}
+/** Move memory block with possible overlapping. */
+void *memmove(void *dst, const void *src, size_t n)
+{
+    const uint8_t *sp;
+    uint8_t *dp;
+    /* Nothing to do? */
+    if (src == dst)
+        return dst;
+    /* Non-overlapping? */
+    if (dst >= src + n || src >= dst + n) {
+        return memcpy(dst, src, n);
+    }
+    /* Which direction? */
+    if (src > dst) {
+        /* Forwards. */
+        sp = src;
+        dp = dst;
+        while (n-- != 0)
+            *dp++ = *sp++;
+    } else {
+        /* Backwards. */
+        sp = src + (n - 1);
+        dp = dst + (n - 1);
+        while (n-- != 0)
+            *dp-- = *sp--;
+    }
+    return dst;
+}
+/** Compare two memory areas.
+ *
+ * @param s1        Pointer to the first area to compare.
+ * @param s2        Pointer to the second area to compare.
+ * @param len       Size of the first area in bytes. Both areas must have
+ *          the same length.
+ * @return      If len is 0, return zero. If the areas match, return
+ *          zero. Otherwise return non-zero.
+ */
+int bcmp(const char *s1, const char *s2, size_t len)
+{
+    for (; len && *s1++ == *s2++; len--)
+        ;
+    return len;
+}
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

/branches/network/uspace/lib/libc/generic/smc.c
34,6 → 34,7

#include <libc.h>
#include <sys/types.h>
#include <smc.h>

int smc_coherence(void *address, size_t size)
{

 /branches/network/uspace/lib/libc/generic/io/stdio.c
 ,0 → 1,278
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/**
+ * @file
+ * @brief ANSI C Stream I/O.
+ */
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <bool.h>
+#include <stdio.h>
+FILE *stdin, *stdout, *stderr;
+/**
+ * Open a stream.
+ *
+ * @param file_name Name of the file to open.
+ * @param mode      Mode string, (r|w|a)[b|t][+].
+ */
+FILE *fopen(const char *file_name, const char *mode)
+{
+    FILE *f;
+    int flags;
+    bool plus;
+    const char *mp;
+    /* Parse mode except first character. */
+    mp = mode;
+    if (*mp++ == '\0') {
+        errno = EINVAL;
+        return NULL;
+    }
+    if (*mp == 'b' || *mp == 't') ++mp;
+    if (*mp == '+') {
+        ++mp;
+        plus = true;
+    } else {
+        plus = false;
+    }
+    if (*mp != '\0') {
+        errno = EINVAL;
+        return NULL;
+    }
+    /* Parse first character of mode and determine flags for open(). */
+    switch (mode[0]) {
+    case 'r':
+        flags = plus ? O_RDWR : O_RDONLY;
+        break;
+    case 'w':
+        flags = (O_TRUNC | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
+        break;
+    case 'a':
+        /* TODO: a+ must read from beginning, append to the end. */
+        if (plus) {
+            errno = ENOTSUP;
+            return NULL;
+        }
+        flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
+    default:
+        errno = EINVAL;
+        return NULL;
+    }
+    /* Open file. */
+    f = malloc(sizeof(FILE));
+    if (f == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    f->fd = open(file_name, flags, 0666);
+    if (f->fd < 0) {
+        free(f);
+        return NULL; /* errno was set by open() */
+    }
+    f->error = 0;
+    f->eof = 0;
+    return f;
+}
+/** Close a stream.
+ *
+ * @param f Pointer to stream.
+ * @return  0 on success, EOF on error.
+ */
+int fclose(FILE *f)
+{
+    int rc;
+    rc = close(f->fd);
+    free(f);
+    if (rc != 0)
+        return EOF; /* errno was set by close() */
+    return 0;
+}
+/** Read from a stream.
+ *
+ * @param buf   Destination buffer.
+ * @param size  Size of each record.
+ * @param nmemb Number of records to read.
+ * @param f Pointer to the stream.
+ */
+size_t fread(void *buf, size_t size, size_t nmemb, FILE *f)
+{
+    size_t left, done, n;
+    left = size * nmemb;
+    done = 0;
+    while (left > 0 && !f->error && !f->eof) {
+        n = read(f->fd, buf + done, left);
+        if (n < 0) {
+            f->error = 1;
+        } else if (n == 0) {
+            f->eof = 1;
+        } else {
+            left -= n;
+            done += n;
+        }
+    }
+    return done / size;
+}
+/** Write to a stream.
+ *
+ * @param buf   Source buffer.
+ * @param size  Size of each record.
+ * @param nmemb Number of records to write.
+ * @param f Pointer to the stream.
+ */
+size_t fwrite(const void *buf, size_t size, size_t nmemb, FILE *f)
+{
+    size_t left, done, n;
+    left = size * nmemb;
+    done = 0;
+    while (left > 0 && !f->error) {
+        n = write(f->fd, buf + done, left);
+        if (n <= 0) {
+            f->error = 1;
+        } else {
+            left -= n;
+            done += n;
+        }
+    }
+    return done / size;
+}
+/** Return the end-of-file indicator of a stream. */
+int feof(FILE *f)
+{
+    return f->eof;
+}
+/** Return the error indicator of a stream. */
+int ferror(FILE *f)
+{
+    return f->error;
+}
+/** Clear the error and end-of-file indicators of a stream. */
+void clearerr(FILE *f)
+{
+    f->eof = 0;
+    f->error = 0;
+}
+/** Read character from a stream. */
+int fgetc(FILE *f)
+{
+    unsigned char c;
+    size_t n;
+    n = fread(&c, sizeof(c), 1, f);
+    if (n < 1) return EOF;
+    return (int) c;
+}
+/** Write character to a stream. */
+int fputc(int c, FILE *f)
+{
+    unsigned char cc;
+    size_t n;
+    cc = (unsigned char) c;
+    n = fwrite(&cc, sizeof(cc), 1, f);
+    if (n < 1) return EOF;
+    return (int) cc;
+}
+/** Write string to a stream. */
+int fputs(const char *s, FILE *f)
+{
+    int rc;
+    rc = 0;
+    while (*s && rc >= 0) {
+        rc = fputc(*s++, f);
+    }
+    if (rc < 0) return EOF;
+    return 0;
+}
+/** Seek to position in stream. */
+int fseek(FILE *f, long offset, int origin)
+{
+    off_t rc;
+    rc = lseek(f->fd, offset, origin);
+    if (rc == (off_t) (-1)) {
+        /* errno has been set by lseek. */
+        return -1;
+    }
+    f->eof = 0;
+    return 0;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/io/fprintf.c
 ,0 → 1,69
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/**
+ * @file
+ * @brief fprintf, vfprintf
+ */
+#include <stdio.h>
+#include <sys/types.h>
+#include <io/printf_core.h>
+static int vfprintf_write(const char *s, size_t count, void *f)
+{
+    return fwrite(s, 1, count, (FILE *) f);
+}
+int vfprintf(FILE *f, const char *fmt, va_list ap)
+{
+    struct printf_spec ps = {
+        (int (*)(void *, size_t, void *)) vfprintf_write,
+        (void *) f
+    };
+    return printf_core(fmt, &ps, ap);
+}
+int fprintf(FILE *f, const char *fmt, ...)
+{
+    int rv;
+    va_list args;
+    va_start(args, fmt);
+    rv = vfprintf(f, fmt, args);
+    va_end(args);
+    return rv;
+}
+/** @}
+ */

 /branches/network/uspace/lib/libc/generic/io/stream.c
 ,7 → 42,8
 #include <ipc/ns.h>
 #include <ipc/fb.h>
 #include <ipc/services.h>
-#include <console.h>
+#include <ipc/console.h>
+#include <kbd/kbd.h>
 #include <unistd.h>
 #include <async.h>
 #include <sys/types.h>
 ,13 → 59,17
 {
     open_console();
     if (console_phone >= 0) {
-        ipcarg_t r0, r1;
+        kbd_event_t ev;
+        int rc;
         size_t i = 0;
         while (i < count) {
-            if (async_req_0_2(console_phone, CONSOLE_GETCHAR, &r0, &r1) < 0)
-                return -1;
-            ((char *) buf)[i++] = r0;
+            do {
+                rc = kbd_get_event(&ev);
+                if (rc < 0) return -1;
+            } while (ev.c == 0 || ev.type == KE_RELEASE);
+            ((char *) buf)[i++] = ev.c;
         }
         return i;
     } else {
 ,11 → 115,19
     (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
 }
-int get_cons_phone(void)
+int get_console_phone(void)
 {
-    open_console();
+    if (console_phone < 0)
+        console_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_CONSOLE, 0, 0);
     return console_phone;
 }
+void console_wait(void)
+{
+    while (console_phone < 0)
+        get_console_phone();
+}
 /** @}
  */

 /branches/network/uspace/lib/libc/Makefile
 ,7 → 31,6
 LIBC_PREFIX = $(shell pwd)
 SOFTINT_PREFIX = ../softint
-CONSOLE_PREFIX = ../../srv/console
 ## Setup toolchain
 #
 ,17 → 37,17
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I$(CONSOLE_PREFIX)
 ## Sources
 #
 GENERIC_SOURCES = \
     generic/libc.c \
     generic/ddi.c \
     generic/as.c \
     generic/cap.c \
+    generic/console.c \
+    generic/mem.c \
     generic/string.c \
     generic/fibril.c \
     generic/pcb.c \
 ,6 → 59,8
     generic/io/asprintf.c \
     generic/io/io.c \
     generic/io/printf.c \
+    generic/io/fprintf.c \
+    generic/io/stdio.c \
     generic/io/stream.c \
     generic/io/sprintf.c \
     generic/io/snprintf.c \
 ,6 → 72,7
     generic/sysinfo.c \
     generic/ipc.c \
     generic/async.c \
+    generic/loader.c \
     generic/getopt.c \
     generic/libadt/list.o \
     generic/libadt/hash_table.o \
 ,39 → 79,42
     generic/time.c \
     generic/err.c \
     generic/stdlib.c \
+    generic/kbd.c \
     generic/mman.c \
+    generic/udebug.c \
     generic/vfs/vfs.c \
     generic/vfs/canonify.c
 ARCH_SOURCES += \
-    arch/$(ARCH)/src/entry.s \
-    arch/$(ARCH)/src/thread_entry.s
+    arch/$(UARCH)/src/entry.s \
+    arch/$(UARCH)/src/thread_entry.s
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))
 ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
+OBJECTS := $(GENERIC_OBJECTS) $(ARCH_OBJECTS)
 .PHONY: all clean depend kerninc
-all: kerninc libc.a arch/$(ARCH)/_link.ld
+all: kerninc libc.a arch/$(UARCH)/_link.ld
 kerninc:
     ln -sfn ../../../../kernel/generic/include include/kernel
     ln -sfn kernel/arch include/arch
-    ln -sfn ../arch/$(ARCH)/include include/libarch
+    ln -sfn ../arch/$(UARCH)/include include/libarch
 -include Makefile.depend
 clean:
-    -rm -f include/kernel include/arch include/libarch libc.a arch/$(ARCH)/_link.ld Makefile.depend
-    find generic/ arch/$(ARCH)/ -name '*.o' -follow -exec rm \{\} \;
+    -rm -f include/kernel include/arch include/libarch libc.a arch/$(UARCH)/_link.ld Makefile.depend
+    find generic/ arch/$(UARCH)/ malloc -name '*.o' -follow -exec rm \{\} \;
 depend: kerninc
-    -makedepend $(DEFS) $(CFLAGS) -f - $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
 libc.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libc.a $(LIBS) $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
-arch/$(ARCH)/_link.ld: arch/$(ARCH)/_link.ld.in
+arch/$(UARCH)/_link.ld: arch/$(UARCH)/_link.ld.in
     $(CC) $(DEFS) $(CFLAGS) -DLIBC_PREFIX=$(LIBC_PREFIX) -E -x c $< | grep -v "^\#" > $@
 %.o: %.S

/branches/network/uspace/lib/libc/arch/sparc64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/network/uspace/lib/libc/arch/sparc64/include/syscall.h
 ,6 → 38,14
 #include <sys/types.h>
 #include <kernel/syscall/syscall.h>
+#define __syscall0  __syscall
+#define __syscall1  __syscall
+#define __syscall2  __syscall
+#define __syscall3  __syscall
+#define __syscall4  __syscall
+#define __syscall5  __syscall
+#define __syscall6  __syscall
 static inline sysarg_t
 __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3,
     const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, const syscall_t id)

 /branches/network/uspace/lib/libc/arch/sparc64/include/ddi.h
 ,0 → 1,92
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libsparc64
+ */
+#ifndef LIBC_sparc64_DDI_H_
+#define LIBC_sparc64_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline memory_barrier(void)
+{
+    asm volatile ("membar #LoadLoad | #StoreStore\n" ::: "memory");
+}
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+    memory_barrier();
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    uint8_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    uint16_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    uint32_t rv;
+    rv = *port;
+    memory_barrier();
+    return rv;
+}
+#endif

 /branches/network/uspace/lib/libc/arch/sparc64/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 TARGET = sparc64-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/sparc64/bin
-ARCH_SOURCES += arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
 CFLAGS += -mcpu=ultrasparc -m64
 LFLAGS += -no-check-sections -N

/branches/network/uspace/lib/libc/arch/ia64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/network/uspace/lib/libc/arch/ia64/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_ia64_SYSCALL_H_
 #define LIBC_ia64_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/network/uspace/lib/libc/arch/ia64/include/ddi.h
 ,0 → 1,115
+/*
+ * Copyright (c) 2005 Jakub Vana
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libcia64
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_ia64_DDI_H_
+#define LIBC_ia64_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+#define IO_SPACE_BOUNDARY   (64 * 1024)
+uint64_t get_ia64_iospace_address(void);
+extern uint64_t ia64_iospace_address;
+#define IA64_IOSPACE_ADDRESS \
+    (ia64_iospace_address ? \
+        ia64_iospace_address : \
+        (ia64_iospace_address = get_ia64_iospace_address()))
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    uintptr_t prt = (uintptr_t) port;
+    *((uint8_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+    asm volatile ("mf\n" ::: "memory");
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    uintptr_t prt = (uintptr_t) port;
+    *((uint16_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+    asm volatile ("mf\n" ::: "memory");
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    uintptr_t prt = (uintptr_t) port;
+    *((uint32_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
+    asm volatile ("mf\n" ::: "memory");
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    uintptr_t prt = (uintptr_t) port;
+    asm volatile ("mf\n" ::: "memory");
+    return *((uint8_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    uintptr_t prt = (uintptr_t) port;
+    asm volatile ("mf\n" ::: "memory");
+    return *((uint16_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    uintptr_t prt = (uintptr_t) port;
+    asm volatile ("mf\n" ::: "memory");
+    return *((uint32_t *)(IA64_IOSPACE_ADDRESS +
+        ((prt & 0xfff) | ((prt >> 2) << 12))));
+}
+#endif
+/** @}
+ */

 /branches/network/uspace/lib/libc/arch/ia64/Makefile.inc
 ,10 → 29,6
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 TARGET = ia64-pc-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/ia64/bin
 CFLAGS += -fno-unwind-tables -DMALLOC_ALIGNMENT_16
 ,9 → 35,10
 LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS +=
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c \
+    arch/$(UARCH)/src/ddi.c
 BFD_NAME = elf64-ia64-little
 BFD_ARCH = ia64-elf64

 /branches/network/uspace/lib/libc/arch/ia64/src/ddi.c
 ,0 → 1,13
+#include <libarch/ddi.h>
+#include <sysinfo.h>
+uint64_t ia64_iospace_address=0;
+uint64_t get_ia64_iospace_address(void)
+{
+    return sysinfo_value("ia64_iospace.address.virtual");
+}

 /branches/network/uspace/lib/libc/arch/ia64/src/entry.s
 ,7 → 38,7
 #
 __entry:
     alloc loc0 = ar.pfs, 0, 1, 2, 0
-    mov r1 = _gp
+    movl r1 = _gp
     # Pass PCB pointer as the first argument to __main
     mov out0 = r2

 /branches/network/uspace/lib/libc/arch/ia64/src/thread_entry.s
 ,7 → 36,7
 __thread_entry:
     alloc loc0 = ar.pfs, 0, 1, 1, 0
-    mov r1 = _gp
+    movl r1 = _gp
     #
     # r8 contains address of uarg structure.

/branches/network/uspace/lib/libc/arch/arm32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/network/uspace/lib/libc/arch/arm32/include/syscall.h
 ,12 → 30,14
  * @{
  */
 /** @file
- *  @brief Empty.
+ *  @brief
  */
 #ifndef LIBC_arm32_SYSCALL_H_
 #define LIBC_arm32_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/network/uspace/lib/libc/arch/arm32/include/ddi.h
 ,0 → 1,69
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libcarm32
+ */
+#ifndef LIBC_arm32_DDI_H_
+#define LIBC_arm32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/network/uspace/lib/libc/arch/arm32/Makefile.inc
 ,20 → 30,16
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 TARGET = arm-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm/bin
 CFLAGS += -ffixed-r9 -mtp=soft
 LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
-AFLAGS +=
+AFLAGS +=
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c \
-        arch/$(ARCH)/src/eabi.S
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c \
+    arch/$(UARCH)/src/eabi.S
 BFD_NAME = elf32-littlearm
 BFD_ARCH = arm

/branches/network/uspace/lib/libc/arch/mips32eb/include/ddi.h
0,0 → 1,0
link ../../mips32/include/ddi.h
Property changes:
Added: svn:special
+*
\ No newline at end of property

 /branches/network/uspace/lib/libc/arch/mips32eb/Makefile.inc
 ,19 → 29,15
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
-TARGET = mips-sgi-irix5
+TARGET = mips-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips/bin
-CFLAGS += -mips3
+CFLAGS += -mips3
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+        arch/$(UARCH)/src/fibril.S \
+        arch/$(UARCH)/src/tls.c
 LFLAGS += -N
 BFD_ARCH = mips
-BFD_NAME = elf32-big
+BFD_NAME = elf32-tradbigmips

/branches/network/uspace/lib/libc/arch/ppc32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/network/uspace/lib/libc/arch/ppc32/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_ppc32_SYSCALL_H_
 #define LIBC_ppc32_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/network/uspace/lib/libc/arch/ppc32/include/ddi.h
 ,0 → 1,69
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libcppc32
+ */
+#ifndef LIBC_ppc32_DDI_H_
+#define LIBC_ppc32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/network/uspace/lib/libc/arch/ppc32/Makefile.inc
 ,16 → 29,12
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 TARGET = ppc-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc/bin
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
 CFLAGS += -mcpu=powerpc -msoft-float -m32
 AFLAGS += -a32

 /branches/network/uspace/lib/libc/arch/ppc32/src/entry.s
 ,11 → 34,12
 ## User-space task entry point
 #
-# r3 contains the PCB pointer
+# r6 contains the PCB pointer
 #
 __entry:
     # Pass the PCB pointer to __main() as the first argument.
-    # Since the first argument is passed in r3, no operation is needed.
+    # The first argument is passed in r3.
+    mr %r3, %r6
     bl __main
     bl __exit

/branches/network/uspace/lib/libc/arch/amd64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/network/uspace/lib/libc/arch/amd64/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_amd64_SYSCALL_H_
 #define LIBC_amd64_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/network/uspace/lib/libc/arch/amd64/Makefile.inc
 ,16 → 29,12
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 TARGET = amd64-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/amd64/bin
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
 LFLAGS += -N

/branches/network/uspace/lib/libc/arch/mips32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/network/uspace/lib/libc/arch/mips32/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_mips32_SYSCALL_H_
 #define LIBC_mips32_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/network/uspace/lib/libc/arch/mips32/include/atomic.h
 ,13 → 59,14
     asm volatile (
         "1:\n"
         "   ll %0, %1\n"
-        "   addiu %0, %0, %3\n" /* same as addi, but never traps on overflow */
+        "   addu %0, %0, %3\n"  /* same as add, but never traps on overflow */
         "       move %2, %0\n"
         "   sc %0, %1\n"
         "   beq %0, %4, 1b\n"   /* if the atomic operation failed, try again */
         /*  nop */      /* nop is inserted automatically by compiler */
+        "   nop\n"
         : "=&r" (tmp), "+m" (val->count), "=&r" (v)
-        : "i" (i), "i" (0)
+        : "r" (i), "i" (0)
         );
     return v;

 /branches/network/uspace/lib/libc/arch/mips32/include/ddi.h
 ,0 → 1,69
+/*
+ * Copyright (c) 2009 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @file
+ * @ingroup libcmips32
+ */
+#ifndef LIBC_mips32_DDI_H_
+#define LIBC_mips32_DDI_H_
+#include <sys/types.h>
+#include <libarch/types.h>
+static inline void pio_write_8(ioport8_t *port, uint8_t v)
+{
+    *port = v;
+}
+static inline void pio_write_16(ioport16_t *port, uint16_t v)
+{
+    *port = v;
+}
+static inline void pio_write_32(ioport32_t *port, uint32_t v)
+{
+    *port = v;
+}
+static inline uint8_t pio_read_8(ioport8_t *port)
+{
+    return *port;
+}
+static inline uint16_t pio_read_16(ioport16_t *port)
+{
+    return *port;
+}
+static inline uint32_t pio_read_32(ioport32_t *port)
+{
+    return *port;
+}
+#endif

 /branches/network/uspace/lib/libc/arch/mips32/Makefile.inc
 ,23 → 29,13
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 TARGET = mipsel-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel/bin
 CFLAGS += -mips3
--include ../../Makefile.config
-ifeq ($(CONFIG_MIPS_FPU),y)
-    CFLAGS += -DCONFIG_MIPS_FPU
-endif
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.c \
-    arch/$(ARCH)/src/fibril.S \
-    arch/$(ARCH)/src/tls.c
 BFD_ARCH = mips
 BFD_NAME = elf32-tradlittlemips

/branches/network/uspace/lib/libc/arch/ia32/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

 /branches/network/uspace/lib/libc/arch/ia32/include/syscall.h
 ,8 → 36,25
 #ifndef LIBC_ia32_SYSCALL_H_
 #define LIBC_ia32_SYSCALL_H_
-#include <syscall.h>
+#include <sys/types.h>
+#include <kernel/syscall/syscall.h>
+#define __syscall0  __syscall_sysenter
+#define __syscall1  __syscall_sysenter
+#define __syscall2  __syscall_sysenter
+#define __syscall3  __syscall_sysenter
+#define __syscall4  __syscall_sysenter
+#define __syscall5  __syscall_int
+#define __syscall6  __syscall_int
+extern sysarg_t
+__syscall_sysenter(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t,
+     const sysarg_t, const sysarg_t, const syscall_t);
+extern sysarg_t
+__syscall_int(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t,
+     const sysarg_t, const sysarg_t, const syscall_t);
 #endif
 /** @}

 /branches/network/uspace/lib/libc/arch/ia32/include/ddi.h
 ,43 → 33,72
 #ifndef LIBC_ia32_DDI_H_
 #define LIBC_ia32_DDI_H_
-static inline void outb(int16_t port, uint8_t b)
+#include <sys/types.h>
+#include <libarch/types.h>
+#define IO_SPACE_BOUNDARY   ((void *) (64 * 1024))
+static inline uint8_t pio_read_8(ioport8_t *port)
 {
-    asm volatile ("outb %0, %1\n" :: "a" (b), "d" (port));
+    uint8_t val;
+    asm volatile (
+        "inb %w[port], %b[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline void outw(int16_t port, int16_t w)
+static inline uint16_t pio_read_16(ioport16_t *port)
 {
-    asm volatile ("outw %0, %1\n" :: "a" (w), "d" (port));
+    uint16_t val;
+    asm volatile (
+        "inw %w[port], %w[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline void outl(int16_t port, uint32_t l)
+static inline uint32_t pio_read_32(ioport32_t *port)
 {
-    asm volatile ("outl %0, %1\n" :: "a" (l), "d" (port));
+    uint32_t val;
+    asm volatile (
+        "inl %w[port], %[val]\n"
+        : [val] "=a" (val)
+        : [port] "d" (port)
+    );
+    return val;
 }
-static inline uint8_t inb(int16_t port)
+static inline void pio_write_8(ioport8_t *port, uint8_t val)
 {
-    uint8_t val;
-    asm volatile ("inb %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outb %b[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
-static inline int16_t inw(int16_t port)
+static inline void pio_write_16(ioport16_t *port, uint16_t val)
 {
-    int16_t val;
-    asm volatile ("inw %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outw %w[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
-static inline uint32_t inl(int16_t port)
+static inline void pio_write_32(ioport32_t *port, uint32_t val)
 {
-    uint32_t val;
-    asm volatile ("inl %1, %0 \n" : "=a" (val) : "d"(port));
-    return val;
+    asm volatile (
+        "outl %[val], %w[port]\n"
+        :: [val] "a" (val), [port] "d" (port)
+    );
 }
 #endif

 /branches/network/uspace/lib/libc/arch/ia32/Makefile.inc
 ,17 → 29,13
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 TARGET = i686-pc-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/i686/bin
-ARCH_SOURCES += arch/$(ARCH)/src/syscall.S \
-        arch/$(ARCH)/src/fibril.S \
-        arch/$(ARCH)/src/tls.c \
-        arch/$(ARCH)/src/setjmp.S
+ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \
+    arch/$(UARCH)/src/fibril.S \
+    arch/$(UARCH)/src/tls.c \
+    arch/$(UARCH)/src/setjmp.S
 LFLAGS += -N

 /branches/network/uspace/lib/libc/arch/ia32/src/syscall.S
 ,14 → 28,14
 .text
-/** Syscall wrapper.
+/** Syscall wrapper - INT $0x30 version.
  *
  * Mind the order of arguments. First two arguments and the syscall number go to
  * scratch registers. An optimized version of this wrapper for fewer arguments
  * could benefit from this and not save unused registers on the stack.
  */
-.global __syscall
-__syscall:
+.global __syscall_int
+__syscall_int:
     pushl %ebx
     pushl %esi
     pushl %edi
 ,3 → 53,38
     popl %esi
     popl %ebx
     ret
+/** Syscall wrapper - SYSENTER version.
+ *
+ * This is an optimized version of syscall for four or less arguments.  Note
+ * that EBP and EDI are used to remember user stack address and the return
+ * address. The kernel part doesn't save DS, ES and FS so the handler restores
+ * these to the selector immediately following CS (it must be the flat data
+ * segment, otherwise the SYSENTER wouldn't work in the first place).
+ */
+.global __syscall_sysenter
+__syscall_sysenter:
+    pushl %ebx
+    pushl %esi
+    pushl %edi
+    pushl %ebp
+    mov %esp, %ebp
+    lea ra, %edi
+    movl 20(%esp), %edx # First argument.
+    movl 24(%esp), %ecx # Second argument.
+    movl 28(%esp), %ebx # Third argument.
+    movl 32(%esp), %esi # Fourth argument.
+    movl 44(%esp), %eax # Syscall number.
+    sysenter
+ra:
+    movw %cs, %cx
+    addw $8, %cx
+    movw %cx, %ds
+    movw %cx, %es
+    movw %cx, %fs
+    popl %ebp
+    popl %edi
+    popl %esi
+    popl %ebx
+    ret

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4152 → Rev 4153