Changes in / [95c9158:81f70b4] in mainline

Files:

• boot/Makefile.build (modified) (1 diff)
• boot/arch/ia64/src/main.c (modified) (1 diff)
• boot/generic/include/memstr.h (modified) (1 diff)
• boot/generic/src/memstr.c (modified) (1 diff)
• boot/generic/src/version.c (modified) (1 diff)
• contrib/conf/mips32-gx.sh (modified) (1 diff)
• kernel/Makefile (modified) (1 diff)
• kernel/arch/ppc32/src/ppc32.c (modified) (1 diff)
• kernel/generic/include/str.h (modified) (1 diff)
• kernel/generic/src/console/cmd.c (modified) (1 diff)
• kernel/generic/src/console/kconsole.c (modified) (1 diff)
• kernel/generic/src/lib/str.c (modified) (1 diff)
• kernel/generic/src/main/version.c (modified) (1 diff)
• kernel/generic/src/sysinfo/stats.c (modified) (3 diffs)
• uspace/app/bdsh/cmds/modules/ls/ls.c (modified) (15 diffs)
• uspace/app/bdsh/cmds/modules/ls/ls.h (added)
• uspace/app/bdsh/cmds/modules/touch/entry.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/touch/touch.c (modified) (5 diffs)
• uspace/app/bdsh/cmds/modules/touch/touch.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/touch/touch_def.h (modified) (1 diff)
• uspace/app/getterm/Makefile (modified) (1 diff)
• uspace/app/getterm/version.c (modified) (2 diffs)
• uspace/lib/c/generic/str.c (modified) (1 diff)
• uspace/lib/c/include/str.h (modified) (1 diff)
• uspace/lib/usb/src/dev.c (modified) (1 diff)
• version (modified) (1 diff)

boot/Makefile.build

@@ -34 +34 @@
 OPTIMIZATION = 3
 
-DEFS = -DRELEASE=$(RELEASE) "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
+DEFS = -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
 
 GCC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \

boot/arch/ia64/src/main.c

@@ -189 +189 @@
         printf("\nInflating components ... ");
         
+        /*
+         * We will use the next available address for a copy of each component to
+         * make sure that inflate() works with disjunctive memory regions.
+         */
+        top = ALIGN_UP(top, PAGE_SIZE);
+
         for (i = cnt; i > 0; i--) {
                 printf("%s ", components[i - 1].name);
                 
-                int err = inflate(components[i - 1].start, components[i - 1].size,
+                /*
+                 * Copy the component to a location which is guaranteed not to
+                 * overlap with the destination for inflate().
+                 */
+                memmove((void *) top, components[i - 1].start, components[i - 1].size);
+                
+                int err = inflate((void *) top, components[i - 1].size,
                     dest[i - 1], components[i - 1].inflated);
                 

boot/generic/include/memstr.h

@@ -36 +36 @@
 
 extern void *memcpy(void *, const void *, size_t);
+extern void *memmove(void *, const void *, size_t);
 
 #endif

boot/generic/src/memstr.c

@@ -51 +51 @@
 }
 
+/** Move memory block with possible overlapping.
+ *
+ * Copy cnt bytes from src address to dst address. The source
+ * and destination memory areas may overlap.
+ *
+ * @param dst Destination address to copy to.
+ * @param src Source address to copy from.
+ * @param cnt Number of bytes to copy.
+ *
+ * @return Destination address.
+ *
+ */
+void *memmove(void *dst, const void *src, size_t cnt)
+{
+        /* Nothing to do? */
+        if (src == dst)
+                return dst;
+        
+        /* Non-overlapping? */
+        if ((dst >= src + cnt) || (src >= dst + cnt))
+                return memcpy(dst, src, cnt);
+        
+        uint8_t *dp;
+        const uint8_t *sp;
+        
+        /* Which direction? */
+        if (src > dst) {
+                /* Forwards. */
+                dp = dst;
+                sp = src;
+                
+                while (cnt-- != 0)
+                        *dp++ = *sp++;
+        } else {
+                /* Backwards. */
+                dp = dst + (cnt - 1);
+                sp = src + (cnt - 1);
+                
+                while (cnt-- != 0)
+                        *dp-- = *sp--;
+        }
+        
+        return dst;
+}
+
 /** @}
  */

boot/generic/src/version.c

@@ -32 +32 @@
 
 static const char *project = "HelenOS bootloader";
-static const char *copyright = "Copyright (c) 2001-2011 HelenOS project";
+static const char *copyright = STRING(COPYRIGHT);
 static const char *release = STRING(RELEASE);
 static const char *name = STRING(NAME);

contrib/conf/mips32-gx.sh

@@ -8 +8 @@
 fi
 
-gxemul $@ -E testmips -C R4000 -X image.boot -d d0:"$DISK_IMG"
+gxemul $@ -E oldtestmips -C R4000 -X image.boot -d d0:"$DISK_IMG"

kernel/Makefile

@@ -90 +90 @@
 endif
 
-DEFS = -DKERNEL -DRELEASE=$(RELEASE) "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
+DEFS = -DKERNEL -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
 
 GCC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \

kernel/arch/ppc32/src/ppc32.c

@@ -130 +130 @@
                         visual = VISUAL_INDIRECT_8;
                         break;
+                case 15:
+                        visual = VISUAL_RGB_5_5_5_BE;
+                        break;
                 case 16:
-                        visual = VISUAL_RGB_5_5_5_BE;
+                        visual = VISUAL_RGB_5_6_5_BE;
                         break;
                 case 24:

kernel/generic/include/str.h

@@ -97 +97 @@
 extern bool wstr_remove(wchar_t *str, size_t pos);
 
-extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
+extern int str_uint64_t(const char *, char **, unsigned int, bool, uint64_t *);
 
 extern void order_suffix(const uint64_t, uint64_t *, char *);

kernel/generic/src/console/cmd.c

@@ -906 +906 @@
                    ((char *) argv->buffer)[0] <= '9') {
                 uint64_t value;
-                rc = str_uint64((char *) argv->buffer, NULL, 0, true, &value);
+                rc = str_uint64_t((char *) argv->buffer, NULL, 0, true, &value);
                 if (rc == EOK)
                         addr = (uintptr_t) value;

kernel/generic/src/console/kconsole.c

@@ -472 +472 @@
                 /* It's a number - convert it */
                 uint64_t value;
-                int rc = str_uint64(text, NULL, 0, true, &value);
+                int rc = str_uint64_t(text, NULL, 0, true, &value);
                 switch (rc) {
                 case EINVAL:

kernel/generic/src/lib/str.c

@@ -893 +893 @@
  *
  */
-int str_uint64(const char *nptr, char **endptr, unsigned int base,
+int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
     bool strict, uint64_t *result)
 {

kernel/generic/src/main/version.c

@@ -38 +38 @@
 
 static const char *project = "SPARTAN kernel";
-static const char *copyright = "Copyright (c) 2001-2011 HelenOS project";
+static const char *copyright = STRING(COPYRIGHT);
 static const char *release = STRING(RELEASE);
 static const char *name = STRING(NAME);

kernel/generic/src/sysinfo/stats.c

@@ -474 +474 @@
         /* Parse the task ID */
         task_id_t task_id;
-        if (str_uint64(name, NULL, 0, true, &task_id) != EOK)
+        if (str_uint64_t(name, NULL, 0, true, &task_id) != EOK)
                 return ret;
         
@@ -545 +545 @@
         /* Parse the thread ID */
         thread_id_t thread_id;
-        if (str_uint64(name, NULL, 0, true, &thread_id) != EOK)
+        if (str_uint64_t(name, NULL, 0, true, &thread_id) != EOK)
                 return ret;
         
@@ -662 +662 @@
         /* Parse the exception number */
         uint64_t excn;
-        if (str_uint64(name, NULL, 0, true, &excn) != EOK)
+        if (str_uint64_t(name, NULL, 0, true, &excn) != EOK)
                 return ret;
         

uspace/app/bdsh/cmds/modules/ls/ls.c

@@ -42 +42 @@
 #include <sort.h>
 
+#include "ls.h"
 #include "errors.h"
 #include "config.h"
@@ -48 +49 @@
 #include "cmds.h"
 
-/* Various values that can be returned by ls_scope() */
-#define LS_BOGUS 0
-#define LS_FILE  1
-#define LS_DIR   2
-
-/** Structure to represent a directory entry.
- *
- * Useful to keep together important information
- * for sorting directory entries.
- */
-struct dir_elem_t {
-        char *name;
-        struct stat s;
-};
-
 static const char *cmdname = "ls";
+
+static ls_job_t ls;
 
 static struct option const long_options[] = {
         { "help", no_argument, 0, 'h' },
         { "unsort", no_argument, 0, 'u' },
+        { "recursive", no_argument, 0, 'r' },
         { 0, 0, 0, 0 }
 };
+
+/* Prototypes for the ls command, excluding entry points. */
+static unsigned int ls_start(ls_job_t *);
+static void ls_print(struct dir_elem_t *);
+static int ls_cmp(void *, void *, void *);
+static signed int ls_scan_dir(const char *, DIR *, struct dir_elem_t **);
+static unsigned int ls_recursive(const char *, DIR *);
+static unsigned int ls_scope(const char *, struct dir_elem_t *);
+
+static unsigned int ls_start(ls_job_t *ls)
+{
+        ls->recursive = 0;
+        ls->sort = 1;
+
+        return 1;
+}
 
 /** Print an entry.
@@ -92 +97 @@
 }
 
-
 /** Compare 2 directory elements.
  *
@@ -127 +131 @@
  *                              0 otherwise.
  */
-static void ls_scan_dir(const char *d, DIR *dirp, int sort)
+static signed int ls_scan_dir(const char *d, DIR *dirp, 
+    struct dir_elem_t **dir_list_ptr)
 {
         int alloc_blocks = 20;
@@ -140 +145 @@
         
         if (!dirp)
-                return;
+                return -1;
 
         buff = (char *) malloc(PATH_MAX);
         if (!buff) {
                 cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
-                return;
+                return -1;
         }
         
@@ -152 +157 @@
                 cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
                 free(buff);
-                return;
+                return -1;
         }
         
@@ -187 +192 @@
         }
         
-        if (sort) {
+        if (ls.sort) {
                 if (!qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t),
                     ls_cmp, NULL)) {
@@ -196 +201 @@
         for (i = 0; i < nbdirs; i++)
                 ls_print(&tosort[i]);
+
+        /* Populate the directory list. */
+        if (ls.recursive) {
+                tmp = (struct dir_elem_t *) realloc(*dir_list_ptr, 
+                    nbdirs * sizeof(struct dir_elem_t));
+                if (!tmp) {
+                        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+                        goto out;
+                } 
+                *dir_list_ptr = tmp;
+
+                for (i = 0; i < nbdirs; i++) {
+                        (*dir_list_ptr)[i].name = str_dup(tosort[i].name);
+                        if (!(*dir_list_ptr)[i].name) {
+                                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
+                                goto out;
+                        }
+                }
+        }
         
 out:
@@ -202 +226 @@
         free(tosort);
         free(buff);
+
+        return nbdirs;
+}
+
+/** Visit a directory recursively.
+ *
+ * ls_recursive visits all the subdirectories recursively and
+ * prints the files and directories in them.
+ *
+ * @param path  Path the current directory being visited.
+ * @param dirp  Directory stream.
+ */
+static unsigned int ls_recursive(const char *path, DIR *dirp)
+{
+        int i, nbdirs, ret;
+        unsigned int scope;
+        char *subdir_path;
+        DIR *subdirp;
+        struct dir_elem_t *dir_list;
+        
+        const char * const trailing_slash = "/";
+
+        nbdirs = 0;
+        dir_list = (struct dir_elem_t *) malloc(sizeof(struct dir_elem_t));
+
+        printf("\n%s:\n", path);
+
+        subdir_path = (char *) malloc(PATH_MAX);
+        if (!subdir_path) {
+                ret = CMD_FAILURE;
+                goto out;
+        }
+
+        nbdirs = ls_scan_dir(path, dirp, &dir_list); 
+        if (nbdirs == -1) {
+                ret = CMD_FAILURE;
+                goto out;
+        }
+
+        for (i = 0; i < nbdirs; ++i) {
+                memset(subdir_path, 0, PATH_MAX);
+
+                if (str_size(subdir_path) + str_size(path) + 1 <= PATH_MAX)
+                        str_append(subdir_path, PATH_MAX, path);
+                if (path[str_size(path)-1] != '/' &&
+                    str_size(subdir_path) + str_size(trailing_slash) + 1 <= PATH_MAX)
+                        str_append(subdir_path, PATH_MAX, trailing_slash);
+                if (str_size(subdir_path) +
+                    str_size(dir_list[i].name) + 1 <= PATH_MAX)
+                        str_append(subdir_path, PATH_MAX, dir_list[i].name);
+
+                scope = ls_scope(subdir_path, &dir_list[i]);
+                switch (scope) {
+                case LS_FILE:
+                        break;
+                case LS_DIR:
+                        subdirp = opendir(subdir_path);
+                        if (!subdirp) {
+                                /* May have been deleted between scoping it and opening it */
+                                cli_error(CL_EFAIL, "Could not stat %s", dir_list[i].name);
+                                ret = CMD_FAILURE;
+                                goto out;
+                        }
+
+                        ret = ls_recursive(subdir_path, subdirp);
+                        closedir(subdirp);
+                        if (ret == CMD_FAILURE)
+                                goto out;
+                        break;
+                case LS_BOGUS:
+                        ret = CMD_FAILURE;
+                        goto out;
+                }       
+        }
+   
+        ret = CMD_SUCCESS; 
+
+out:
+        for (i = 0; i < nbdirs; i++)
+                free(dir_list[i].name);
+        free(dir_list);
+        free(subdir_path);
+
+        return ret;
+}
+
+static unsigned int ls_scope(const char *path, struct dir_elem_t *de)
+{
+        if (stat(path, &de->s)) {
+                cli_error(CL_ENOENT, path);
+                return LS_BOGUS;
+        }
+
+        if (de->s.is_file)
+                return LS_FILE;
+        else if (de->s.is_directory)
+                return LS_DIR;
+
+        return LS_BOGUS;
 }
 
@@ -215 +338 @@
                 "Options:\n"
                 "  -h, --help       A short option summary\n"
-                "  -u, --unsort     Do not sort directory entries\n",
+                "  -u, --unsort     Do not sort directory entries\n"
+                "  -r, --recursive  List subdirectories recursively\n",
                 cmdname);
         }
@@ -228 +352 @@
         DIR *dirp;
         int c, opt_ind;
-        int sort = 1;
+        int ret = 0;
+        unsigned int scope;
+
+        if (!ls_start(&ls)) {
+                cli_error(CL_EFAIL, "%s: Could not initialize", cmdname);
+                return CMD_FAILURE;
+        }
 
         argc = cli_count_args(argv);
         
         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "hu", long_options, &opt_ind);
+                c = getopt_long(argc, argv, "hur", long_options, &opt_ind);
                 switch (c) {
                 case 'h':
@@ -239 +369 @@
                         return CMD_SUCCESS;
                 case 'u':
-                        sort = 0;
+                        ls.sort = 0;
+                        break;
+                case 'r':
+                        ls.recursive = 1;
                         break;
                 }
@@ -251 +384 @@
                 return CMD_FAILURE;
         }
-        memset(de.name, 0, sizeof(PATH_MAX));
+        memset(de.name, 0, PATH_MAX);
         
         if (argc == 0)
@@ -257 +390 @@
         else
                 str_cpy(de.name, PATH_MAX, argv[optind]);
-        
-        if (stat(de.name, &de.s)) {
-                cli_error(CL_ENOENT, de.name);
-                free(de.name);
-                return CMD_FAILURE;
-        }
-
-        if (de.s.is_file) {
+
+        scope = ls_scope(de.name, &de);
+        switch (scope) {
+        case LS_FILE:
                 ls_print(&de);
-        } else {
+                break;
+        case LS_DIR:
                 dirp = opendir(de.name);
                 if (!dirp) {
@@ -274 +404 @@
                         return CMD_FAILURE;
                 }
-                ls_scan_dir(de.name, dirp, sort);
+                if (ls.recursive)
+                        ret = ls_recursive(de.name, dirp);
+                else  
+                        ret = ls_scan_dir(de.name, dirp, NULL);
+
                 closedir(dirp);
+                break;
+        case LS_BOGUS:
+                return CMD_FAILURE;
         }
 
         free(de.name);
 
-        return CMD_SUCCESS;
-}
-
+        if (ret == -1 || ret == CMD_FAILURE)
+                return CMD_FAILURE;
+        else
+                return CMD_SUCCESS;
+}
+

uspace/app/bdsh/cmds/modules/touch/entry.h

@@ -7 +7 @@
 
 #endif /* TOUCH_ENTRY_H */
-

uspace/app/bdsh/cmds/modules/touch/touch.c

@@ -27 +27 @@
  */
 
-/* TODO: Options that people would expect, such as not creating the file if
- * it doesn't exist, specifying the access time, etc */
+/*
+ * TODO: Options that people would expect, such as specifying the access time,
+ * etc.
+ */
 
 #include <stdio.h>
@@ -37 +39 @@
 #include <sys/types.h>
 #include <str.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <errno.h>
 
 #include "config.h"
@@ -47 +52 @@
 static const char *cmdname = "touch";
 
+static struct option const long_options[] = {
+        { "no-create", no_argument, 0, 'c' },
+        { 0, 0, 0, 0 }
+};
+
 /* Dispays help for touch in various levels */
 void help_cmd_touch(unsigned int level)
 {
         if (level == HELP_SHORT) {
-                printf("`%s' updates access times for files\n", cmdname);
+                printf("`%s' updates access times of files\n", cmdname);
         } else {
                 help_cmd_touch(HELP_SHORT);
-                printf("  `%s' <file>, if the file does not exist it will be "
-                                "created\n", cmdname);
+                printf("Usage: `%s' [-c|--no-create] <file>...\n\n"
+                    "If the file does not exist it will be created empty,\n"
+                    "unless -c (--no-create) is supplied.\n\n"
+                    "Options:\n"
+                    "   -c, --no-create  Do not create new files\n",
+                    cmdname);
         }
-
+        
         return;
 }
@@ -64 +78 @@
 int cmd_touch(char **argv)
 {
-        unsigned int argc, i = 0, ret = 0;
-        int fd;
+        unsigned int argc = cli_count_args(argv);
+        unsigned int i = 0;
+        unsigned int ret = 0;
+        int c;
+        int longind;
+        bool no_create = false;
+        struct stat file_stat;
+        int fd = -1;
         char *buff = NULL;
-
+        
         DIR *dirp;
-
-        argc = cli_count_args(argv);
-
-        if (argc == 1) {
-                printf("%s - incorrect number of arguments. Try `help %s extended'\n",
-                        cmdname, cmdname);
+        
+        for (c = 0, optind = 0, longind = 0; c != -1; ) {
+                c = getopt_long(argc, argv, "c", long_options, &longind);
+                switch (c) {
+                case 'c':
+                        no_create = true;
+                        break;
+                }
+        }
+        
+        if (argc - optind < 1) {
+                printf("%s: Incorrect number of arguments. Try `help %s extended'\n",
+                    cmdname, cmdname);
                 return CMD_FAILURE;
         }
-
-        for (i = 1; i < argc; i ++) {
+        
+        for (i = optind; argv[i] != NULL; i++) {
                 buff = str_dup(argv[i]);
+                if (buff == NULL) {
+                        cli_error(CL_ENOMEM, "Out of memory");
+                        ret++;
+                        continue;
+                }
+                
                 dirp = opendir(buff);
                 if (dirp) {
-                        cli_error(CL_ENOTSUP, "%s is a directory", buff);
+                        cli_error(CL_ENOTSUP, "`%s' is a directory", buff);
                         closedir(dirp);
-                        ret ++;
+                        free(buff);
+                        ret++;
                         continue;
                 }
-
-                fd = open(buff, O_RDWR | O_CREAT);
+                
+                /* Check whether file exists if -c (--no-create) option is given */
+                if ((!no_create) || ((no_create) && (stat(buff, &file_stat) == EOK)))
+                        fd = open(buff, O_RDWR | O_CREAT);
+                
                 if (fd < 0) {
-                        cli_error(CL_EFAIL, "Could not update / create %s ", buff);
-                        ret ++;
+                        cli_error(CL_EFAIL, "Could not update or create `%s'", buff);
+                        free(buff);
+                        ret++;
                         continue;
-                } else
+                } else {
                         close(fd);
-
+                        fd = -1;
+                }
+                
                 free(buff);
         }
-
+        
         if (ret)
                 return CMD_FAILURE;
@@ -104 +144 @@
                 return CMD_SUCCESS;
 }
-

uspace/app/bdsh/cmds/modules/touch/touch.h

@@ -4 +4 @@
 /* Prototypes for the touch command, excluding entry points */
 
-
 #endif /* TOUCH_H */
-

uspace/app/bdsh/cmds/modules/touch/touch_def.h

@@ -5 +5 @@
         &help_cmd_touch,
 },
-

uspace/app/getterm/Makefile

@@ -29 +29 @@
 
 USPACE_PREFIX = ../..
-DEFS = -DRELEASE=$(RELEASE) "-DNAME=$(NAME)"
+DEFS = -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)"
 BINARY = getterm
 

uspace/app/getterm/version.c

@@ -40 +40 @@
 #include "version.h"
 
+static const char *copyright = STRING(COPYRIGHT);
 static const char *release = STRING(RELEASE);
 static const char *name = STRING(NAME);
@@ -61 +62 @@
         printf("HelenOS release %s (%s)%s%s\n", release, name, revision, timestamp);
         printf("Running on %s (%s)\n", arch, term);
-        printf("Copyright (c) 2001-2011 HelenOS project\n\n");
+        printf("%s\n\n", copyright);
 }
 

uspace/lib/c/generic/str.c

@@ -1535 +1535 @@
  *
  */
-int str_uint64(const char *nptr, char **endptr, unsigned int base,
+int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
     bool strict, uint64_t *result)
 {

uspace/lib/c/include/str.h

@@ -106 +106 @@
 extern int str_uint16_t(const char *, char **, unsigned int, bool, uint16_t *);
 extern int str_uint32_t(const char *, char **, unsigned int, bool, uint32_t *);
-extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
+extern int str_uint64_t(const char *, char **, unsigned int, bool, uint64_t *);
 extern int str_size_t(const char *, char **, unsigned int, bool, size_t *);
 

uspace/lib/usb/src/dev.c

@@ -122 +122 @@
         char *ptr;
 
-        rc = str_uint64(path, &ptr, 10, false, &sid);
+        rc = str_uint64_t(path, &ptr, 10, false, &sid);
         if (rc != EOK) {
                 return false;

version

@@ -46 +46 @@
 
 NAME = Sashimi
+COPYRIGHT = Copyright (c) 2001-2012 HelenOS project