WebSVN – HelenOS – Path Comparison – / – /branches/dynload/uspace/lib/ Rev 3534 and /branches/dynload/uspace/lib/ Rev 3535

Ignore whitespace Rev 3534 → Rev 3535

 /branches/dynload/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>
 ,62 → 330,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/dynload/uspace/lib/libfs/libfs.h
 ,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/dynload/uspace/lib/libfs/Makefile
 ,7 → 57,7
     find . -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
 libfs.a: depend $(OBJECTS)
     $(AR) rc libfs.a $(OBJECTS)

 /branches/dynload/uspace/lib/softfloat/Makefile
 ,7 → 66,7
     find generic/ -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(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/dynload/uspace/lib/libblock/libblock.c
 ,0 → 1,298
+/*
+ * 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>
+/** Lock protecting the device connection list */
+static futex_t dcl_lock = FUTEX_INITIALIZER;
+/** Device connection list head. */
+static LIST_INITIALIZE(dcl_head);
+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;
+} 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, void *bb_buf, off_t bb_off, size_t bb_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 = bb_buf;
+    devcon->bb_off = bb_off;
+    devcon->bb_size = bb_size;
+    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, off_t bb_off,
+    size_t bb_size)
+{
+    int rc;
+    int dev_phone;
+    void *com_area;
+    void *bb_buf;
+    bb_buf = malloc(bb_size);
+    if (!bb_buf)
+        return ENOMEM;
+    com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
+        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+    if (!com_area) {
+        free(bb_buf);
+        return ENOMEM;
+    }
+    dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
+        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
+    if (dev_phone < 0) {
+        free(bb_buf);
+        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) {
+        free(bb_buf);
+            munmap(com_area, com_size);
+        ipc_hangup(dev_phone);
+        return rc;
+    }
+    rc = devcon_add(dev_handle, dev_phone, com_area, com_size, bb_buf,
+        bb_off, bb_size);
+    if (rc != EOK) {
+        free(bb_buf);
+        munmap(com_area, com_size);
+        ipc_hangup(dev_phone);
+        return rc;
+    }
+    off_t bufpos = 0;
+    size_t buflen = 0;
+    if (!block_read(dev_handle, &bufpos, &buflen, &bb_off,
+        bb_buf, bb_size, bb_size)) {
+        block_fini(dev_handle);
+        return EIO; /* XXX real error code */
+    }
+    return EOK;
+}
+void block_fini(dev_handle_t dev_handle)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    devcon_remove(devcon);
+    free(devcon->bb_buf);
+    munmap(devcon->com_area, devcon->com_size);
+    ipc_hangup(devcon->dev_phone);
+    free(devcon);
+}
+void *block_bb_get(dev_handle_t dev_handle)
+{
+    devcon_t *devcon = devcon_search(dev_handle);
+    assert(devcon);
+    return devcon->bb_buf;
+}
+/** 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      True on success, false on failure.
+ */
+bool
+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 false;
+            *bufpos = 0;
+            *buflen = block_size;
+        }
+    }
+    return true;
+}
+block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
+{
+    /* FIXME */
+    block_t *b;
+    off_t bufpos = 0;
+    size_t buflen = 0;
+    off_t pos = offset * bs;
+    b = malloc(sizeof(block_t));
+    if (!b)
+        return NULL;
+    b->data = malloc(bs);
+    if (!b->data) {
+        free(b);
+        return NULL;
+    }
+    b->size = bs;
+    if (!block_read(dev_handle, &bufpos, &buflen, &pos, b->data,
+        bs, bs)) {
+        free(b->data);
+        free(b);
+        return NULL;
+    }
+    return b;
+}
+void block_put(block_t *block)
+{
+    /* FIXME */
+    free(block->data);
+    free(block);
+}
+/** @}
+ */

 /branches/dynload/uspace/lib/libblock/libblock.h
 ,0 → 1,83
+/*
+ * 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>
+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. */
+    off_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, off_t, size_t);
+extern void block_fini(dev_handle_t);
+extern void *block_bb_get(dev_handle_t);
+extern block_t *block_get(dev_handle_t, off_t, size_t);
+extern void block_put(block_t *);
+extern bool block_read(int, off_t *, size_t *, off_t *, void *, size_t, size_t);
+#endif
+/** @}
+ */

 /branches/dynload/uspace/lib/libblock/Makefile
 ,0 → 1,66
+#
+# 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 - -- $(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/dynload/uspace/lib/softint/Makefile
 ,7 → 63,7
     find generic/ \( -name '*.o' -o -name '*.pio' \) -follow -exec rm \{\} \;
 depend:
-    -makedepend $(DEFS) $(CFLAGS) -f - $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
     -makedepend $(DEFS) $(PIC_CFLAGS) -o.pio -f - $(GENERIC_SOURCES) >> Makefile.depend 2> /dev/null
 libsoftint.a: depend $(OBJECTS)

 /branches/dynload/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/dynload/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/dynload/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/dynload/uspace/lib/libc/include/libc.h
 ,14 → 39,14
 #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/dynload/uspace/lib/libc/include/loader/loader.h
 ,6 → 36,8
 #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. */

 /branches/dynload/uspace/lib/libc/include/ipc/ipc.h
 ,8 → 283,9
 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_read_finalize(ipc_callid_t callid, const void *src,
+    size_t size);
+extern int ipc_data_write_start(int phoneid, const 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);

/branches/dynload/uspace/lib/libc/include/errno.h
46,6 → 46,7
#define EBADF (-262)
#define ERANGE (-263)
#define EXDEV (-264)
#define EIO (-265)

#endif

 /branches/dynload/uspace/lib/libc/Makefile.toolchain
 ,7 → 27,7
 #
 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 -I$(LIBC_PREFIX)/include -pipe
 LFLAGS = -M -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS =
 #-Werror

 /branches/dynload/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/dynload/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/dynload/uspace/lib/libc/generic/loader.c
 ,6 → 35,7
 #include <ipc/ipc.h>
 #include <ipc/loader.h>
 #include <libc.h>
+#include <task.h>
 #include <string.h>
 #include <stdlib.h>
 #include <async.h>
 ,7 → 94,7
     /* 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));
+    rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
     if (rc != EOK) {
         async_wait_for(req, NULL);
         return rc;

 /branches/dynload/uspace/lib/libc/generic/ipc.c
 ,7 → 847,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 → 860,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);

/branches/dynload/uspace/lib/libc/generic/udebug.c
34,7 → 34,6

#include <udebug.h>
#include <sys/types.h>
#include <syscall.h>
#include <ipc/ipc.h>
#include <async.h>

 /branches/dynload/uspace/lib/libc/generic/vfs/vfs.c
 ,7 → 116,7
     return vfs_phone;
 }
-static int device_get_handle(char *name, dev_handle_t *handle)
+static int device_get_handle(const char *name, dev_handle_t *handle)
 {
     int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
 );
 ,9 → 364,9
         }
     }
-    off_t newoffs;
+    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);
 ,7 → 374,7
     if (rc != EOK)
         return (off_t) -1;
-    return newoffs;
+    return (off_t) newoffs;
 }
 int ftruncate(int fildes, off_t length)

/branches/dynload/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/dynload/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/dynload/uspace/lib/libc/Makefile
 ,7 → 111,7
     find . \( -name '*.o' -o -name '*.pio' \) -follow -exec rm \{\} \;
 depend: kerninc
-    -makedepend $(DEFS) $(CFLAGS) -f - $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
     -makedepend $(DEFS) $(PIC_CFLAGS) -o.pio -f - $(ARCH_SOURCES) $(GENERIC_SOURCES) >> Makefile.depend 2> /dev/null
 libc.a: depend $(OBJECTS)

 /branches/dynload/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/dynload/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/dynload/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/dynload/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/dynload/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/dynload/uspace/lib/libc/arch/ppc64/include/syscall.h
 ,6 → 36,8
 #ifndef LIBC_ppc64_SYSCALL_H_
 #define LIBC_ppc64_SYSCALL_H_
+#define LIBARCH_SYSCALL_GENERIC
 #include <syscall.h>
 #endif

 /branches/dynload/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/dynload/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/dynload/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 3534 → Rev 3535