WebSVN – HelenOS – Path Comparison – / – /branches/sparc/uspace/lib Rev 3397 and /branches/sparc/uspace/lib Rev 3492

Ignore whitespace Rev 3397 → Rev 3492

 /branches/sparc/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/sparc/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/sparc/uspace/lib/softint/Makefile
 ,7 → 58,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
 libsoftint.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
     $(AR) rc libsoftint.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/sparc/uspace/lib/libc/include/string.h
 ,6 → 64,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/sparc/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/sparc/uspace/lib/libc/include/task.h
 ,7 → 40,7
 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 task_id_t task_spawn(const char *path, char *const argv[]);
 #endif

 /branches/sparc/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/sparc/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/sparc/uspace/lib/libc/include/loader/pcb.h
 ,7 → 40,8
 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.

 /branches/sparc/uspace/lib/libc/include/loader/loader.h
 ,0 → 1,59
+/*
+ * 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 loader_t *loader_spawn(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/sparc/uspace/lib/libc/include/ipc/ipc.h
 ,11 → 283,16
 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);
+#include <task.h>
+extern int ipc_connect_kbox(task_id_t id);
 #endif
 /** @}

 /branches/sparc/uspace/lib/libc/include/ipc/loader.h
 ,15 → 32,17
 /** @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;

 /branches/sparc/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/sparc/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/sparc/uspace/lib/libc/generic/task.c
 ,14 → 34,10
  */
 #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>
 task_id_t task_get_id(void)
 {
 ,134 → 48,62
     return task_id;
 }
-static int task_spawn_loader(void)
-{
-    int phone_id, rc;
-    rc = __SYSCALL1(SYS_PROGRAM_SPAWN_LOADER, (sysarg_t) &phone_id);
-    if (rc != 0)
-        return rc;
-    return phone_id;
-}
-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)
+    /* Spawn a program loader. */
+    ldr = loader_spawn();
+    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. */
+    /* Load the program. */
+    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/sparc/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/sparc/uspace/lib/libc/generic/string.c
 ,5 → 1,7
 /*
  * Copyright (c) 2005 Martin Decky
+ * Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
+ * Copyright (c) 1988, 1993 The Regents of the University of California.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,5 → 398,52
     return (char *) memcpy(ret, s1, len);
 }
+/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
+char * strtok_r(char *s, const char *delim, char **last)
+{
+    char *spanp, *tok;
+    int c, sc;
+    if (s == NULL && (s = *last) == NULL)
+        return (NULL);
+cont:
+    c = *s++;
+    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
+        if (c == sc)
+            goto cont;
+    }
+    if (c == 0) {       /* no non-delimiter characters */
+        *last = NULL;
+        return (NULL);
+    }
+    tok = s - 1;
+    for (;;) {
+        c = *s++;
+        spanp = (char *)delim;
+        do {
+            if ((sc = *spanp++) == c) {
+                if (c == 0)
+                    s = NULL;
+                else
+                    s[-1] = '\0';
+                *last = s;
+                return (tok);
+            }
+        } while (sc != 0);
+    }
+}
+/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
+char * strtok(char *s, const char *delim)
+{
+    static char *last;
+    return (strtok_r(s, delim, &last));
+}
 /** @}
  */

 /branches/sparc/uspace/lib/libc/generic/loader.c
 ,0 → 1,267
+/*
+ * 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 <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.
+ * @return  Pointer to the loader connection structure (should be
+ *      de-allocated using free() after use).
+ */
+loader_t *loader_spawn(void)
+{
+    int phone_id, rc;
+    loader_t *ldr;
+    /*
+     * Ask kernel to spawn a new loader task.
+     */
+    rc = __SYSCALL1(SYS_PROGRAM_SPAWN_LOADER, (sysarg_t) &phone_id);
+    if (rc != 0)
+        return NULL;
+    /*
+     * Say hello so that the loader knows the incoming connection's
+     * phone hash.
+     */
+    rc = async_req_0_0(phone_id, LOADER_HELLO);
+    if (rc != EOK)
+        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/sparc/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);
 ,6 → 909,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/sparc/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/sparc/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)
 ,6 → 599,7
     cwd_path = pa;
     cwd_len = pa_len;
     futex_up(&cwd_futex);
+    return EOK;
 }
 char *getcwd(char *buf, size_t size)

/branches/sparc/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/sparc/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/sparc/uspace/lib/libc/Makefile
71,6 → 71,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 \
78,6 → 79,7
generic/err.c \
generic/stdlib.c \
generic/mman.c \
generic/udebug.c \
generic/vfs/vfs.c \
generic/vfs/canonify.c

104,7 → 106,7
find generic/ arch/$(ARCH)/ -name '*.o' -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

libc.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS)
$(AR) rc libc.a $(LIBS) $(ARCH_OBJECTS) $(GENERIC_OBJECTS)

 /branches/sparc/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/sparc/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/sparc/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/sparc/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/sparc/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/sparc/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/sparc/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/sparc/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/sparc/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 3397 → Rev 3492