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

Ignore whitespace Rev 3492 → Rev 3491

/branches/sparc/uspace/app/trace/ipcp.c
File deleted

/branches/sparc/uspace/app/trace/errors.c
File deleted

/branches/sparc/uspace/app/trace/Makefile
File deleted

/branches/sparc/uspace/app/trace/syscalls.c
File deleted

/branches/sparc/uspace/app/trace/trace.c
File deleted

/branches/sparc/uspace/app/trace/ipc_desc.h
File deleted

/branches/sparc/uspace/app/trace/ipcp.h
File deleted

/branches/sparc/uspace/app/trace/errors.h
File deleted

/branches/sparc/uspace/app/trace/syscalls.h
File deleted

/branches/sparc/uspace/app/trace/proto.c
File deleted

/branches/sparc/uspace/app/trace/trace.h
File deleted

/branches/sparc/uspace/app/trace/proto.h
File deleted

/branches/sparc/uspace/app/trace/ipc_desc.c
File deleted

 /branches/sparc/uspace/app/init/init.c
 ,15 → 104,15
         return -1;
     }
-    // FIXME: spawn("/srv/pci");
-    //spawn("/srv/fb");
-    spawn("/srv/kbd");
-    spawn("/srv/console");
+    // FIXME: spawn("/sbin/pci");
+    //spawn("/sbin/fb");
+    spawn("/sbin/kbd");
+    spawn("/sbin/console");
     console_wait();
     version_print();
-    spawn("/app/bdsh");
+    spawn("/sbin/bdsh");
     return 0;
 }

 /branches/sparc/uspace/app/bdsh/scli.c
 ,8 → 53,8
 const char *progname = PACKAGE_NAME;
 /* These are not exposed, even to builtins */
-static int cli_init(cliuser_t *);
-static void cli_finit(cliuser_t *);
+static int cli_init(cliuser_t *usr);
+static void cli_finit(cliuser_t *usr);
 /* Constructor */
 static int cli_init(cliuser_t *usr)

 /branches/sparc/uspace/app/bdsh/cmds/builtins/cd/cd.c
 ,7 → 42,7
 static char * cmdname = "cd";
-void help_cmd_cd(unsigned int level)
+void * help_cmd_cd(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' changes the current working directory.\n", cmdname);
 ,12 → 53,12
             cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
-int cmd_cd(char **argv, cliuser_t *usr)
+int * cmd_cd(char **argv, cliuser_t *usr)
 {
     int argc, rc = 0;

 /branches/sparc/uspace/app/bdsh/cmds/builtins/cd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the cd command */
-extern void help_cmd_cd(unsigned int);
-extern int cmd_cd(char **, cliuser_t *);
+extern void * help_cmd_cd(unsigned int);
+extern int * cmd_cd(char **, cliuser_t *);
 #endif

/branches/sparc/uspace/app/bdsh/cmds/modules/cp/cp.c
File deleted

/branches/sparc/uspace/app/bdsh/cmds/modules/cp/cp_def.h
File deleted

/branches/sparc/uspace/app/bdsh/cmds/modules/cp/entry.h
File deleted

/branches/sparc/uspace/app/bdsh/cmds/modules/cp/cp.h
File deleted

/branches/sparc/uspace/app/bdsh/cmds/modules/sleep/sleep_def.h
File deleted

/branches/sparc/uspace/app/bdsh/cmds/modules/sleep/sleep.h
File deleted

/branches/sparc/uspace/app/bdsh/cmds/modules/sleep/entry.h
File deleted

/branches/sparc/uspace/app/bdsh/cmds/modules/sleep/sleep.c
File deleted

 /branches/sparc/uspace/app/bdsh/cmds/modules/touch/touch.c
 ,7 → 48,7
 static char *cmdname = "touch";
 /* Dispays help for touch in various levels */
-void help_cmd_touch(unsigned int level)
+void * help_cmd_touch(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' updates access times for files\n", cmdname);
 ,11 → 58,11
                 "created\n", cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* Main entry point for touch, accepts an array of arguments */
-int cmd_touch(char **argv)
+int * cmd_touch(char **argv)
 {
     unsigned int argc, i = 0, ret = 0;
     int fd;

 /branches/sparc/uspace/app/bdsh/cmds/modules/touch/entry.h
 ,8 → 2,8
 #define TOUCH_ENTRY_H
 /* Entry points for the touch command */
-extern int cmd_touch(char **);
-extern void help_cmd_touch(unsigned int);
+extern int * cmd_touch(char **);
+extern void * help_cmd_touch(unsigned int);
 #endif /* TOUCH_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,7 → 60,7
 };
-void help_cmd_mkdir(unsigned int level)
+void * help_cmd_mkdir(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' creates a new directory\n", cmdname);
 ,7 → 79,7
         cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* This is kind of clunky, but effective for now */
 ,7 → 181,7
     return ret;
 }
-int cmd_mkdir(char **argv)
+int * cmd_mkdir(char **argv)
 {
     unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
     unsigned int verbose = 0;

 /branches/sparc/uspace/app/bdsh/cmds/modules/mkdir/entry.h
 ,8 → 2,8
 #define MKDIR_ENTRY_H
 /* Entry points for the mkdir command */
-extern int cmd_mkdir(char **);
-extern void help_cmd_mkdir(unsigned int);
+extern int * cmd_mkdir(char **);
+extern void * help_cmd_mkdir(unsigned int);
 #endif /* MKDIR_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/cat/cat.c
 ,7 → 59,7
 };
 /* Dispays help for cat in various levels */
-void help_cmd_cat(unsigned int level)
+void * help_cmd_cat(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' shows the contents of files\n", cmdname);
 ,7 → 78,7
         cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 static unsigned int cat_file(const char *fname, size_t blen)
 ,6 → 121,12
         return 1;
     }
+    /* Debug stuff, newline not added purposefully */
+    printf("** %s is a file with the size of %ld bytes\n",
+        fname, total);
+    printf( "** %d bytes were read in a buffer of %d bytes in %d reads\n",
+        count, blen, reads);
+    printf("** Read %s\n", count == total ? "Succeeded" : "Failed");
     free(buff);
     return 0;
 ,7 → 133,7
 }
 /* Main entry point for cat, accepts an array of arguments */
-int cmd_cat(char **argv)
+int * cmd_cat(char **argv)
 {
     unsigned int argc, i, ret = 0, buffer = 0;
     int c, opt_ind;

 /branches/sparc/uspace/app/bdsh/cmds/modules/cat/entry.h
 ,8 → 2,8
 #define CAT_ENTRY_H
 /* Entry points for the cat command */
-extern int cmd_cat(char **);
-extern void help_cmd_cat(unsigned int);
+extern int * cmd_cat(char **);
+extern void * help_cmd_cat(unsigned int);
 #endif /* CAT_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/help/help.c
 ,7 → 69,7
     return HELP_IS_RUBBISH;
 }
-void help_cmd_help(unsigned int level)
+void *help_cmd_help(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf(
 ,10 → 86,10
         cmdname, cmdname, cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
-int cmd_help(char *argv[])
+int *cmd_help(char *argv[])
 {
     module_t *mod;
     builtin_t *cmd;

 /branches/sparc/uspace/app/bdsh/cmds/modules/help/entry.h
 ,7 → 2,7
 #define HELP_ENTRY_H_
 /* Entry points for the help command */
-extern void help_cmd_help(unsigned int);
-extern int cmd_help(char *[]);
+extern void * help_cmd_help(unsigned int);
+extern int * cmd_help(char *[]);
 #endif

 /branches/sparc/uspace/app/bdsh/cmds/modules/ls/ls.c
 ,7 → 132,7
     return;
 }
-void help_cmd_ls(unsigned int level)
+void * help_cmd_ls(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' lists files and directories.\n", cmdname);
 ,10 → 142,10
                 "working directory is used.\n", cmdname);
     }
-    return;
+    return CMD_VOID;
 }
-int cmd_ls(char **argv)
+int * cmd_ls(char **argv)
 {
     unsigned int argc;
     unsigned int scope;

 /branches/sparc/uspace/app/bdsh/cmds/modules/ls/entry.h
 ,8 → 2,8
 #define LS_ENTRY_H
 /* Entry points for the ls command */
-extern int cmd_ls(char **);
-extern void help_cmd_ls(unsigned int);
+extern int * cmd_ls(char **);
+extern void * help_cmd_ls(unsigned int);
 #endif /* LS_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,7 → 144,7
 }
 /* Dispays help for rm in various levels */
-void help_cmd_rm(unsigned int level)
+void * help_cmd_rm(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' removes files and directories.\n", cmdname);
 ,11 → 161,11
         "Currently, %s is under development, some options don't work.\n",
         cmdname, cmdname);
     }
-    return;
+    return CMD_VOID;
 }
 /* Main entry point for rm, accepts an array of arguments */
-int cmd_rm(char **argv)
+int * cmd_rm(char **argv)
 {
     unsigned int argc;
     unsigned int i, scope, ret = 0;

 /branches/sparc/uspace/app/bdsh/cmds/modules/rm/entry.h
 ,8 → 2,8
 #define RM_ENTRY_H
 /* Entry points for the rm command */
-extern int cmd_rm(char **);
-extern void help_cmd_rm(unsigned int);
+extern int * cmd_rm(char **);
+extern void * help_cmd_rm(unsigned int);
 #endif /* RM_ENTRY_H */

 /branches/sparc/uspace/app/bdsh/cmds/modules/quit/quit.c
 ,15 → 39,15
 extern volatile unsigned int cli_quit;
 extern const char *progname;
-void help_cmd_quit(unsigned int level)
+void * help_cmd_quit(unsigned int level)
 {
     printf("Type `%s' to exit %s\n", cmdname, progname);
-    return;
+    return CMD_VOID;
 }
 /* Quits the program and returns the status of whatever command
  * came before invoking 'quit' */
-int cmd_quit(char *argv[])
+int * cmd_quit(char *argv[])
 {
     /* Inform that we're outta here */
     cli_quit = 1;

 /branches/sparc/uspace/app/bdsh/cmds/modules/quit/entry.h
 ,8 → 2,8
 #define QUIT_ENTRY_H_
 /* Entry points for the quit command */
-extern void help_cmd_quit(unsigned int);
-extern int cmd_quit(char *[]);
+extern void * help_cmd_quit(unsigned int);
+extern int * cmd_quit(char *[]);
 #endif

 /branches/sparc/uspace/app/bdsh/cmds/modules/pwd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the pwd command */
-extern void help_cmd_pwd(unsigned int);
-extern int cmd_pwd(char **);
+extern void * help_cmd_pwd(unsigned int);
+extern int * cmd_pwd(char **);
 #endif

 /branches/sparc/uspace/app/bdsh/cmds/modules/pwd/pwd.c
 ,13 → 39,13
 static char * cmdname = "pwd";
-void help_cmd_pwd(unsigned int level)
+void * help_cmd_pwd(unsigned int level)
 {
     printf("`%s' prints your current working directory.\n", cmdname);
-    return;
+    return CMD_VOID;
 }
-int cmd_pwd(char *argv[])
+int * cmd_pwd(char *argv[])
 {
     char *buff;

 /branches/sparc/uspace/app/bdsh/cmds/modules/modules.h
 ,8 → 25,6
 #include "touch/entry.h"
 #include "ls/entry.h"
 #include "pwd/entry.h"
-#include "sleep/entry.h"
-#include "cp/entry.h"
 /* Each .def function fills the module_t struct with the individual name, entry
  * point, help entry point, etc. You can use config.h to control what modules
 ,8 → 39,6
 #include "touch/touch_def.h"
 #include "ls/ls_def.h"
 #include "pwd/pwd_def.h"
-#include "sleep/sleep_def.h"
-#include "cp/cp_def.h"
     {NULL, NULL, NULL, NULL}
 };

 /branches/sparc/uspace/app/bdsh/cmds/mknewcmd
 ,8 → 120,8
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/entry.h
 /* Entry points for the ${CMDNAME} command */
-extern int ${CMDENTRY}(char **);
-extern void ${HELPENTRY}(unsigned int);
+extern int * ${CMDENTRY}(char **);
+extern void * ${HELPENTRY}(unsigned int);
 #endif /* ${defname}_ENTRY_H */
 ,22 → 170,22
 static char *cmdname = "${CMDNAME}";
 /* Dispays help for ${CMDNAME} in various levels */
-void ${HELPENTRY}(unsigned int level)
+void * ${HELPENTRY}(unsigned int level)
 {
     printf("This is the %s help for '%s'.\n",
         level ? EXT_HELP : SHORT_HELP, cmdname);
-    return;
+    return CMD_VOID;
 }
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 /* Main entry point for ${CMDNAME}, accepts an array of arguments */
-int ${CMDENTRY}(char **argv)
+int * ${CMDENTRY}(char **argv)
 EOF
     [ "${CMDTYPE}" = "builtin" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 /* Main entry point for ${CMDNAME}, accepts an array of arguments and a
  * pointer to the cliuser_t structure */
-int ${CMDENTRY}(char **argv, cliuser_t *usr)
+int * ${CMDENTRY}(char **argv, cliuser_t *usr)
 EOF
     cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 {

 /branches/sparc/uspace/app/bdsh/cmds/cmds.h
 ,16 → 19,17
 #define BUFF_SMALL  255
 /* Return macros for int type entry points */
-#define CMD_FAILURE 1
+#define CMD_FAILURE (int*)1
 #define CMD_SUCCESS 0
+#define CMD_VOID (void *)NULL
 /* Types for module command entry and help */
-typedef int (* mod_entry_t)(char **);
-typedef void (* mod_help_t)(unsigned int);
+typedef int * (* mod_entry_t)(char **);
+typedef void * (* mod_help_t)(unsigned int);
 /* Built-in commands need to be able to modify cliuser_t */
-typedef int (* builtin_entry_t)(char **, cliuser_t *);
-typedef void (* builtin_help_t)(unsigned int);
+typedef int * (* builtin_entry_t)(char **, cliuser_t *);
+typedef void * (* builtin_help_t)(unsigned int);
 /* Module structure */
 typedef struct {

 /branches/sparc/uspace/app/bdsh/util.c
 ,6 → 70,125
     return (char *) memcpy(ret, s1, len);
 }
+/*
+ * Take a previously allocated string (s1), re-size it to accept s2 and copy
+ * the contents of s2 into s1.
+ * Return -1 on failure, or the length of the copied string on success.
+ */
+int cli_redup(char **s1, const char *s2)
+{
+    size_t len = strlen(s2) + 1;
+    if (! len)
+        return -1;
+    *s1 = realloc(*s1, len);
+    if (*s1 == NULL) {
+        cli_errno = CL_ENOMEM;
+        return -1;
+    }
+    memset(*s1, 0, sizeof(*s1));
+    memcpy(*s1, s2, len);
+    cli_errno = CL_EOK;
+    return (int) len;
+}
+/* An asprintf() for formatting paths, similar to asprintf() but ensures
+ * the returned allocated string is <= PATH_MAX. On failure, an attempt
+ * is made to return the original string (if not null) unmodified.
+ *
+ * Returns: Length of the new string on success, 0 if the string was handed
+ * back unmodified, -1 on failure. On failure, cli_errno is set.
+ *
+ * We do not use POSIX_PATH_MAX, as it is typically much smaller than the
+ * PATH_MAX defined by the kernel.
+ *
+ * Use this like:
+ * if (1 > cli_psprintf(&char, "%s/%s", foo, bar)) {
+ *   cli_error(cli_errno, "Failed to format path");
+ *   stop_what_your_doing_as_your_out_of_memory();
+ * }
+ */
+int cli_psprintf(char **s1, const char *fmt, ...)
+{
+    va_list ap;
+    size_t needed, base = PATH_MAX + 1;
+    int skipped = 0;
+    char *orig = NULL;
+    char *tmp = (char *) malloc(base);
+    /* Don't even touch s1, not enough memory */
+    if (NULL == tmp) {
+        cli_errno = CL_ENOMEM;
+        return -1;
+    }
+    /* If re-allocating s1, save a copy in case we fail */
+    if (NULL != *s1)
+        orig = cli_strdup(*s1);
+    /* Print the string to tmp so we can determine the size that
+     * we actually need */
+    memset(tmp, 0, sizeof(tmp));
+    va_start(ap, fmt);
+    /* vsnprintf will return the # of bytes not written */
+    skipped = vsnprintf(tmp, base, fmt, ap);
+    va_end(ap);
+    /* realloc/alloc s1 to be just the size that we need */
+    needed = strlen(tmp) + 1;
+    *s1 = realloc(*s1, needed);
+    if (NULL == *s1) {
+        /* No string lived here previously, or we failed to
+         * make a copy of it, either way there's nothing we
+         * can do. */
+        if (NULL == *orig) {
+            cli_errno = CL_ENOMEM;
+            return -1;
+        }
+        /* We can't even allocate enough size to restore the
+         * saved copy, just give up */
+        *s1 = realloc(*s1, strlen(orig) + 1);
+        if (NULL == *s1) {
+            free(tmp);
+            free(orig);
+            cli_errno = CL_ENOMEM;
+            return -1;
+        }
+        /* Give the string back as we found it */
+        memset(*s1, 0, sizeof(*s1));
+        memcpy(*s1, orig, strlen(orig) + 1);
+        free(tmp);
+        free(orig);
+        cli_errno = CL_ENOMEM;
+        return 0;
+    }
+    /* Ok, great, we have enough room */
+    memset(*s1, 0, sizeof(*s1));
+    memcpy(*s1, tmp, needed);
+    free(tmp);
+    /* Free tmp only if s1 was reallocated instead of allocated */
+    if (NULL != orig)
+        free(orig);
+    if (skipped) {
+        /* s1 was bigger than PATH_MAX when expanded, however part
+         * of the string was printed. Tell the caller not to use it */
+        cli_errno = CL_ETOOBIG;
+        return -1;
+    }
+    /* Success! */
+    cli_errno = CL_EOK;
+    return (int) needed;
+}
 /* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
 char * cli_strtok_r(char *s, const char *delim, char **last)
 {
 ,7 → 273,10
     if (NULL == usr->cwd)
         snprintf(usr->cwd, PATH_MAX, "(unknown)");
-    asprintf(&usr->prompt, "%s # ", usr->cwd);
+    if (1 < cli_psprintf(&usr->prompt, "%s # ", usr->cwd)) {
+        cli_error(cli_errno, "Failed to set prompt");
+        return 1;
+    }
     return 0;
 }

 /branches/sparc/uspace/app/bdsh/util.h
 ,6 → 5,8
 /* Internal string handlers */
 extern char * cli_strdup(const char *);
+extern int cli_redup(char **, const char *);
+extern int cli_psprintf(char **, const char *, ...);
 extern char * cli_strtok_r(char *, const char *, char **);
 extern char * cli_strtok(char *, const char *);

 /branches/sparc/uspace/app/bdsh/Makefile
 ,8 → 64,6
     cmds/modules/touch/ \
     cmds/modules/ls/ \
     cmds/modules/pwd/ \
-    cmds/modules/sleep/ \
-    cmds/modules/cp/ \
     cmds/builtins/ \
     cmds/builtins/cd/
 ,8 → 76,6
     cmds/modules/touch/touch.c \
     cmds/modules/ls/ls.c \
     cmds/modules/pwd/pwd.c \
-    cmds/modules/sleep/sleep.c \
-    cmds/modules/cp/cp.c \
     cmds/builtins/cd/cd.c \
     cmds/mod_cmds.c \
     cmds/builtin_cmds.c \

 /branches/sparc/uspace/app/bdsh/exec.c
 ,13 → 46,13
 #include "errors.h"
 /* FIXME: Just have find_command() return an allocated string */
-static char *found;
+char *found;
 static char *find_command(char *);
-static int try_access(const char *);
+static unsigned int try_access(const char *);
 /* work-around for access() */
-static int try_access(const char *f)
+static unsigned int try_access(const char *f)
 {
     int fd;
 ,7 → 117,7
     tmp = cli_strdup(find_command(cmd));
     free(found);
-    tid = task_spawn((const char *)tmp, argv);
+    tid = task_spawn((const char *)tmp, (const char **)argv);
     free(tmp);
     if (tid == 0) {

 /branches/sparc/uspace/app/bdsh/README
 ,12 → 57,12
 They are typed as such (from cmds.h):
 /* Types for module command entry and help */
-typedef int (* mod_entry_t)(char **);
-typedef void (* mod_help_t)(unsigned int);
+typedef int * (* mod_entry_t)(char **);
+typedef void * (* mod_help_t)(unsigned int);
 /* Built-in commands need to be able to modify cliuser_t */
-typedef int (* builtin_entry_t)(char **, cliuser_t *);
-typedef void (* builtin_help_t)(unsigned int);
+typedef int * (* builtin_entry_t)(char **, cliuser_t *);
+typedef void * (* builtin_help_t)(unsigned int);
 As you can see, both modular and builtin commands expect an array of
 arguments, however bulitins also expect to be pointed to cliuser_t.
 ,7 → 153,9
 : Change your "usage()" command as shown:
      -- void usage(...)
-     ++ void help_cmd_foo(unsigned int level)
+     ++ void * help_cmd_foo(unsigned int level)
+     -- return;
+     ++ retrn CMD_VOID;
      'level' is either 0 or 1, indicating the level of help requested.
      If the help / usage function currently exits based on how it is
 ,19 → 163,33
 : Change the programs "main()" as shown:
      -- int main(int argc, char **argv)
-     ++ int cmd_foo(char **argv)
+     ++ int * cmd_foo(char **argv)
      -- return 1;
      ++ return CMD_FAILURE;
      -- return 0;
      ++ return CMD_SUCCESS;
+     If main() returns an int that is not 1 or 0 (e.g. 127), cast it as
+     such:
+     -- return 127;
+     ++ return (int *) 127;
+     NOTE: _ONLY_ the main and help entry points need to return int * or
+     void *, respectively. Also take note that argc has changed. The type
+     for entry points may soon change.
      NOTE: If main is void, you'll need to change it and ensure that its
      expecting an array of arguments, even if they'll never be read or
      used. I.e.:
      -- void main(void)
-     ++ int cmd_foo(char **argv)
+     ++ int * cmd_foo(char **argv)
+     Similararly, do not try to return CMD_VOID within the modules main
+     entry point. If somehow you escape the compiler yelling at you, you
+     will surely see pretty blue and yellow fireworks once its reached.
 : Don't expose more than the entry and help points:
      -- void my_function(int n)
      ++ static void my_function(int n)

 /branches/sparc/uspace/app/bdsh/config.h
 ,18 → 1,15
-/* Various things that are used in many places including a few
- * tidbits left over from autoconf prior to the HelenOS port */
+/* Various things that are used in many files
+ * Various temporary port work-arounds are addressed in __HELENOS__ , this
+ * serves as a convenience and later as a guide to make "phony.h" for future
+ * ports */
 /* Specific port work-arounds : */
-#ifndef PATH_MAX
 #define PATH_MAX 255
-#endif
-#ifndef EXIT_SUCCESS
 #define EXIT_SUCCESS 0
-#define EXIT_FAILURE 1
-#endif
+#define EXIT_FAILURE 0
 /* Work around for getenv() */
-#define PATH "/srv:/app"
+#define PATH "/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin"
 #define PATH_DELIM ":"
 /* Used in many places */
 ,7 → 26,7
 #define PACKAGE_BUGREPORT "echo@echoreply.us"
 #define PACKAGE_NAME "bdsh"
 #define PACKAGE_STRING "The brain dead shell"
-#define PACKAGE_TARNAME "bdsh"
+#define PACKAGE_TARNAME "scli"
 #define PACKAGE_VERSION "0.0.1"

 /branches/sparc/uspace/app/tester/tester.c
 ,7 → 133,7
                 if (c == 'a')
                     break;
-            if (test->name == NULL)
+            if (c > 'a')
                 printf("Unknown test\n\n");
             else
                 run_test(test);
 ,8 → 147,6
         }
     }
-    return 0;
 }
 /** @}

/branches/sparc/uspace/app/tester/ipc/send_sync.c
35,6 → 35,7
{
int phoneid;
int res;
static int msgid = 1;
char c;

printf("Select phoneid to send msg: 2-9 (q to skip)\n");

 /branches/sparc/uspace/lib/libc/include/string.h
 ,9 → 64,6
 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/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, char *const argv[]);
+extern task_id_t task_spawn(const char *path, const char *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) __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 __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 __SYSCALL6(id, p1, p2, p3, p4, p5, p6) \
-    __syscall6(p1, p2, p3, p4, p5, p6, id)
+    __syscall(p1, p2, p3, p4, p5, p6,id)
 extern void __main(void *pcb_ptr);
 extern void __exit(void);

 /branches/sparc/uspace/lib/libc/include/loader/pcb.h
 ,8 → 40,7
 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/ipc/loader.h
 ,17 → 32,15
 /** @file
  */
-#ifndef LIBC_IPC_LOADER_H_
-#define LIBC_IPC_LOADER_H_
+#ifndef LIBC_LOADER_H_
+#define LIBC_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/include/ipc/ipc.h
 ,16 → 283,11
 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, const void *src,
-    size_t size);
-extern int ipc_data_write_start(int phoneid, const void *src, 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);
-#include <task.h>
-extern int ipc_connect_kbox(task_id_t id);
 #endif
 /** @}

 /branches/sparc/uspace/lib/libc/include/syscall.h
 ,28 → 32,15
 /**
  * @file
  * @brief   Syscall function declaration for architectures that don't
- *      inline syscalls or architectures that handle syscalls
- *      according to the number of arguments.
+ *      inline syscalls.
  */
 #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/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, const void *src, size_t size)
+int ipc_data_read_finalize(ipc_callid_t callid, 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, const void *src, size_t size)
+int ipc_data_write_start(int phoneid, void *src, size_t size)
 {
     return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
         (ipcarg_t) size);
 ,18 → 909,6
 {
     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/vfs/canonify.c
36,7 → 36,6
*/

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

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

 /branches/sparc/uspace/lib/libc/generic/vfs/vfs.c
 ,7 → 116,7
     return vfs_phone;
 }
-static int device_get_handle(const char *name, dev_handle_t *handle)
+static int device_get_handle(char *name, dev_handle_t *handle)
 {
     int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
 );
 ,9 → 364,9
         }
     }
-    ipcarg_t newoffs;
+    off_t newoffs;
     rc = async_req_3_1(vfs_phone, VFS_SEEK, fildes, offset, whence,
-        &newoffs);
+        (ipcarg_t)&newoffs);
     async_serialize_end();
     futex_up(&vfs_phone_futex);
 ,7 → 374,7
     if (rc != EOK)
         return (off_t) -1;
-    return (off_t) newoffs;
+    return newoffs;
 }
 int ftruncate(int fildes, off_t length)
 ,7 → 599,6
     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/task.c
 ,10 → 34,14
  */
 #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 <loader/loader.h>
+#include <vfs/vfs.h>
 task_id_t task_get_id(void)
 {
 ,62 → 52,134
     return task_id;
 }
-/** Create a new task by running an executable from the filesystem.
+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.
  *
- * 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, char *const argv[])
+task_id_t task_spawn(const char *path, const char *argv[])
 {
-    loader_t *ldr;
-    task_id_t task_id;
+    int phone_id;
+    ipc_call_t answer;
+    aid_t req;
     int rc;
+    ipcarg_t retval;
-    /* Spawn a program loader. */
-    ldr = loader_spawn();
-    if (ldr == NULL)
+    char *pa;
+    size_t pa_len;
+    pa = absolutize(path, &pa_len);
+    if (!pa)
         return 0;
-    /* Get task ID. */
-    rc = loader_get_task_id(ldr, &task_id);
-    if (rc != EOK)
-        goto error;
+    /* Spawn a program loader */
+    phone_id = task_spawn_loader();
+    if (phone_id < 0)
+        return 0;
-    /* Send program pathname. */
-    rc = loader_set_pathname(ldr, path);
+    /*
+     * 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)
-        goto error;
+        return 0;
-    /* Send arguments. */
-    rc = loader_set_args(ldr, argv);
-    if (rc != EOK)
+    /* 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)
         goto error;
-    /* Load the program. */
-    rc = loader_load_program(ldr);
+    /* Send arguments */
+    rc = loader_set_args(phone_id, argv);
     if (rc != EOK)
         goto error;
-    /* Run it. */
-    /* Load the program. */
-    rc = loader_run(ldr);
+    /* Request loader to start the program */
+    rc = async_req_0_0(phone_id, LOADER_RUN);
     if (rc != EOK)
         goto error;
     /* Success */
+    ipc_hangup(phone_id);
+    return 1;
-    free(ldr);
-    return task_id;
     /* Error exit */
 error:
-    loader_abort(ldr);
-    free(ldr);
+    ipc_hangup(phone_id);
     return 0;
 }

 /branches/sparc/uspace/lib/libc/generic/string.c
 ,7 → 1,5
 /*
  * 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
 ,52 → 396,5
     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/smc.c
34,7 → 34,6

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

int smc_coherence(void *address, size_t size)
{

 /branches/sparc/uspace/lib/libc/generic/time.c
 ,8 → 47,6
 #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/tls.c
 ,7 → 116,7
     tcb_t *tcb;
     size = ALIGN_UP(size, &_tls_alignment);
-    *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);
+    *data = memalign(&_tls_alignment, sizeof(tcb_t) + size);
     tcb = (tcb_t *) (*data + size);
     tcb->self = tcb;

/branches/sparc/uspace/lib/libc/Makefile
71,7 → 71,6
generic/sysinfo.c \
generic/ipc.c \
generic/async.c \
generic/loader.c \
generic/getopt.c \
generic/libadt/list.o \
generic/libadt/hash_table.o \
79,7 → 78,6
generic/err.c \
generic/stdlib.c \
generic/mman.c \
generic/udebug.c \
generic/vfs/vfs.c \
generic/vfs/canonify.c

106,7 → 104,7
find generic/ arch/$(ARCH)/ -name '*.o' -follow -exec rm \{\} \;

depend: kerninc
-makedepend -f - -- $(DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
-makedepend $(DEFS) $(CFLAGS) -f - $(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
 ,14 → 38,6
 #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
 ,8 → 36,6
 #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
 ,14 → 30,12
  * @{
  */
 /** @file
- *  @brief
+ *  @brief Empty.
  */
 #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
 ,8 → 36,6
 #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
 ,8 → 36,6
 #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
 ,8 → 36,6
 #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
 ,8 → 36,6
 #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
 ,25 → 36,8
 #ifndef LIBC_ia32_SYSCALL_H_
 #define LIBC_ia32_SYSCALL_H_
-#include <sys/types.h>
-#include <kernel/syscall/syscall.h>
+#include <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 - INT $0x30 version.
+/** Syscall wrapper.
  *
  * 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_int
-__syscall_int:
+.global __syscall
+__syscall:
     pushl %ebx
     pushl %esi
     pushl %edi
 ,38 → 53,3
     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

 /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 -pipe
+CFLAGS = -fno-builtin -Wall -Werror-implicit-function-declaration -Wmissing-prototypes -O3 -nostdlib -nostdinc -I$(LIBC_PREFIX)/include
 LFLAGS = -M -N $(SOFTINT_PREFIX)/libsoftint.a
 AFLAGS =
 #-Werror

 /branches/sparc/uspace/lib/libfs/Makefile
 ,7 → 57,7
     find . -name '*.o' -follow -exec rm \{\} \;
 depend:
-    -makedepend -f - -- $(DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(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 -f - -- $(DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(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 -f - -- $(DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null
+    -makedepend $(DEFS) $(CFLAGS) -f - $(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/srv/vfs/vfs_ops.c
 ,7 → 153,7
         return;
     }
     /* Allocate buffer for the mount point data being received. */
-    char *buf;
+    uint8_t *buf;
     buf = malloc(size + 1);
     if (!buf) {
         ipc_answer_0(callid, ENOMEM);

 /branches/sparc/uspace/srv/vfs/vfs.c
 ,6 → 49,8
 #define NAME "vfs"
+#define dprintf(...)    printf(__VA_ARGS__)
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
     bool keep_on_going = 1;

 /branches/sparc/uspace/srv/loader/main.c
 ,7 → 46,6
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <bool.h>
 #include <fcntl.h>
 #include <sys/types.h>
 #include <ipc/ipc.h>
 ,33 → 77,6
 /** Buffer holding all arguments */
 static char *arg_buf = NULL;
-static elf_info_t prog_info;
-static elf_info_t interp_info;
-static bool is_dyn_linked;
-static void loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
-{
-    ipc_callid_t callid;
-    task_id_t task_id;
-    size_t len;
-    task_id = task_get_id();
-    if (!ipc_data_read_receive(&callid, &len)) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    if (len > sizeof(task_id)) len = sizeof(task_id);
-    ipc_data_read_finalize(callid, &task_id, len);
-    ipc_answer_0(rid, EOK);
-}
 /** Receive a call setting pathname of the program to execute.
  *
  * @param rid
 ,16 → 191,20
     argv[n] = NULL;
 }
-/** Load the previously selected program.
+/** Load and run the previously selected program.
  *
  * @param rid
  * @param request
  * @return 0 on success, !0 on error.
  */
-static int loader_load(ipc_callid_t rid, ipc_call_t *request)
+static int loader_run(ipc_callid_t rid, ipc_call_t *request)
 {
     int rc;
+    elf_info_t prog_info;
+    elf_info_t interp_info;
 //  printf("Load program '%s'\n", pathname);
     rc = elf_load_file(pathname, 0, &prog_info);
 ,8 → 224,9
         /* Statically linked program */
 //      printf("Run statically linked program\n");
 //      printf("entry point: 0x%llx\n", prog_info.entry);
-        is_dyn_linked = false;
         ipc_answer_0(rid, EOK);
+        close_console();
+        elf_run(&prog_info, &pcb);
         return 0;
     }
 ,40 → 244,17
     pcb.rtld_dynamic = interp_info.dynamic;
     pcb.rtld_bias = RTLD_BIAS;
-    is_dyn_linked = true;
+    printf("run dynamic linker\n");
+    printf("entry point: 0x%llx\n", interp_info.entry);
+    close_console();
     ipc_answer_0(rid, EOK);
+    elf_run(&interp_info, &pcb);
+    /* Not reached */
     return 0;
 }
-/** Run the previously loaded program.
- *
- * @param rid
- * @param request
- * @return 0 on success, !0 on error.
- */
-static void loader_run(ipc_callid_t rid, ipc_call_t *request)
-{
-    if (is_dyn_linked == true) {
-        /* Dynamically linked program */
-        printf("run dynamic linker\n");
-        printf("entry point: 0x%llx\n", interp_info.entry);
-        close_console();
-        ipc_answer_0(rid, EOK);
-        elf_run(&interp_info, &pcb);
-    } else {
-        /* Statically linked program */
-        close_console();
-        ipc_answer_0(rid, EOK);
-        elf_run(&prog_info, &pcb);
-    }
-    /* Not reached */
-}
 /** Handle loader connection.
  *
  * Receive and carry out commands (of which the last one should be
 ,23 → 271,18
     while (1) {
         callid = async_get_call(&call);
+//      printf("received call from phone %d, method=%d\n",
+//          call.in_phone_hash, IPC_GET_METHOD(call));
         switch (IPC_GET_METHOD(call)) {
-        case LOADER_GET_TASKID:
-            loader_get_taskid(callid, &call);
-            continue;
         case LOADER_SET_PATHNAME:
             loader_set_pathname(callid, &call);
             continue;
         case LOADER_SET_ARGS:
             loader_set_args(callid, &call);
-            continue;
-        case LOADER_LOAD:
-            loader_load(callid, &call);
-            continue;
         case LOADER_RUN:
             loader_run(callid, &call);
-            /* Not reached */
+            exit(0);
+            continue;
         default:
             retval = ENOENT;
             break;

/branches/sparc/uspace/Makefile
48,7 → 48,6
srv/devmap \
app/tetris \
app/tester \
app/trace \
app/klog \
app/init \
app/bdsh

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3492 → Rev 3491