WebSVN – HelenOS – Path Comparison – / – /branches/dd/kernel/generic/src/lib Rev 3022 and /branches/dd/kernel/generic/src/lib Rev 4055

Ignore whitespace Rev 3022 → Rev 4055

/branches/dd/kernel/generic/src/lib/objc_ext.c
File deleted

/branches/dd/kernel/generic/src/lib/objc.c
File deleted

 /branches/dd/kernel/generic/src/lib/rd.c
 ,7 → 42,6
 #include <mm/frame.h>
 #include <sysinfo/sysinfo.h>
 #include <ddi/ddi.h>
-#include <print.h>
 #include <align.h>
 static parea_t rd_parea;        /**< Physical memory area for rd. */
 ,14 → 48,14
 /**
  * RAM disk initialization routine. At this point, the RAM disk memory is shared
- * and information about the share is provided as sysinfo values to the userspace
- * tasks.
+ * and information about the share is provided as sysinfo values to the
+ * userspace tasks.
  */
-int init_rd(rd_header * header, size_t size)
+int init_rd(rd_header_t *header, size_t size)
 {
     /* Identify RAM disk */
     if ((header->magic[0] != RD_MAG0) || (header->magic[1] != RD_MAG1) ||
-        (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
+        (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
         return RE_INVALID;
     /* Identify version */
 ,10 → 79,7
     if ((hsize % FRAME_SIZE) || (dsize % FRAME_SIZE))
         return RE_UNSUPPORTED;
-    if (dsize % FRAME_SIZE)
-        return RE_UNSUPPORTED;
     if (hsize > size)
         return RE_INVALID;
 ,17 → 86,16
     if ((uint64_t) hsize + dsize > size)
         dsize = size - hsize;
-    rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize), FRAME_SIZE);
-    rd_parea.vbase = (uintptr_t) ((void *) header + hsize);
+    rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
+        FRAME_SIZE);
     rd_parea.frames = SIZE2FRAMES(dsize);
-    rd_parea.cacheable = true;
     ddi_parea_register(&rd_parea);
     sysinfo_set_item_val("rd", NULL, true);
     sysinfo_set_item_val("rd.header_size", NULL, hsize);
     sysinfo_set_item_val("rd.size", NULL, dsize);
-    sysinfo_set_item_val("rd.address.physical", NULL, (unative_t)
-        KA2PA((void *) header + hsize));
+    sysinfo_set_item_val("rd.address.physical", NULL,
+        (unative_t) KA2PA((void *) header + hsize));
     return RE_OK;
 }

 /branches/dd/kernel/generic/src/lib/elf.c
 ,7 → 57,7
 };
 static int segment_header(elf_segment_header_t *entry, elf_header_t *elf,
-    as_t *as);
+    as_t *as, int flags);
 static int section_header(elf_section_header_t *entry, elf_header_t *elf,
     as_t *as);
 static int load_segment(elf_segment_header_t *entry, elf_header_t *elf,
 ,9 → 67,10
  *
  * @param header Pointer to ELF header in memory
  * @param as Created and properly mapped address space
+ * @param flags A combination of ELD_F_*
  * @return EE_OK on success
  */
-unsigned int elf_load(elf_header_t *header, as_t * as)
+unsigned int elf_load(elf_header_t *header, as_t * as, int flags)
 {
     int i, rc;
 ,7 → 111,7
         seghdr = &((elf_segment_header_t *)(((uint8_t *) header) +
             header->e_phoff))[i];
-        rc = segment_header(seghdr, header, as);
+        rc = segment_header(seghdr, header, as, flags);
         if (rc != EE_OK)
             return rc;
     }
 ,8 → 152,10
  * @return EE_OK on success, error code otherwise.
  */
 static int segment_header(elf_segment_header_t *entry, elf_header_t *elf,
-    as_t *as)
+    as_t *as, int flags)
 {
+    char *interp;
     switch (entry->p_type) {
     case PT_NULL:
     case PT_PHDR:
 ,6 → 165,16
         break;
     case PT_DYNAMIC:
     case PT_INTERP:
+        interp = (char *)elf + entry->p_offset;
+        /* FIXME */
+        /*if (memcmp((uintptr_t)interp, (uintptr_t)ELF_INTERP_ZSTR,
+            ELF_INTERP_ZLEN) != 0) {
+            return EE_UNSUPPORTED;
+        }*/
+        if ((flags & ELD_F_LOADER) == 0) {
+            return EE_LOADER;
+        }
+        break;
     case PT_SHLIB:
     case PT_NOTE:
     case PT_LOPROC:

 /branches/dd/kernel/generic/src/lib/string.c
 ,0 → 1,170
+/*
+ * Copyright (c) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/**
+ * @file
+ * @brief Miscellaneous functions.
+ */
+#include <string.h>
+#include <print.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch.h>
+#include <console/kconsole.h>
+/** Return number of characters in a string.
+ *
+ * @param str NULL terminated string.
+ *
+ * @return Number of characters in str.
+ *
+ */
+size_t strlen(const char *str)
+{
+    int i;
+    for (i = 0; str[i]; i++);
+    return i;
+}
+/** Compare two NULL terminated strings
+ *
+ * Do a char-by-char comparison of two NULL terminated strings.
+ * The strings are considered equal iff they consist of the same
+ * characters on the minimum of their lengths.
+ *
+ * @param src First string to compare.
+ * @param dst Second string to compare.
+ *
+ * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
+ *
+ */
+int strcmp(const char *src, const char *dst)
+{
+    for (; *src && *dst; src++, dst++) {
+        if (*src < *dst)
+            return -1;
+        if (*src > *dst)
+            return 1;
+    }
+    if (*src == *dst)
+        return 0;
+    if (!*src)
+        return -1;
+    return 1;
+}
+/** Compare two NULL terminated strings
+ *
+ * Do a char-by-char comparison of two NULL terminated strings.
+ * The strings are considered equal iff they consist of the same
+ * characters on the minimum of their lengths and specified maximal
+ * length.
+ *
+ * @param src First string to compare.
+ * @param dst Second string to compare.
+ * @param len Maximal length for comparison.
+ *
+ * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
+ *
+ */
+int strncmp(const char *src, const char *dst, size_t len)
+{
+    unsigned int i;
+    for (i = 0; (*src) && (*dst) && (i < len); src++, dst++, i++) {
+        if (*src < *dst)
+            return -1;
+        if (*src > *dst)
+            return 1;
+    }
+    if (i == len || *src == *dst)
+        return 0;
+    if (!*src)
+        return -1;
+    return 1;
+}
+/** Copy NULL terminated string.
+ *
+ * Copy at most 'len' characters from string 'src' to 'dest'.
+ * If 'src' is shorter than 'len', '\0' is inserted behind the
+ * last copied character.
+ *
+ * @param src  Source string.
+ * @param dest Destination buffer.
+ * @param len  Size of destination buffer.
+ *
+ */
+void strncpy(char *dest, const char *src, size_t len)
+{
+    unsigned int i;
+    for (i = 0; i < len; i++) {
+        if (!(dest[i] = src[i]))
+            return;
+    }
+    dest[i - 1] = '\0';
+}
+/** Find first occurence of character in string.
+ *
+ * @param s String to search.
+ * @param i Character to look for.
+ *
+ * @return Pointer to character in @a s or NULL if not found.
+ */
+extern char *strchr(const char *s, int i)
+{
+    while (*s != '\0') {
+        if (*s == i)
+            return (char *) s;
+        ++s;
+    }
+    return NULL;
+}
+/** @}
+ */

 /branches/dd/kernel/generic/src/lib/memstr.c
 ,5 → 1,6
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,12 → 35,10
  * @file
  * @brief   Memory string operations.
  *
- * This file provides architecture independent functions
- * to manipulate blocks of memory. These functions
- * are optimized as much as generic functions of
- * this type can be. However, architectures are
- * free to provide even more optimized versions of these
- * functions.
+ * This file provides architecture independent functions to manipulate blocks of
+ * memory. These functions are optimized as much as generic functions of this
+ * type can be. However, architectures are free to provide even more optimized
+ * versions of these functions.
  */
 #include <memstr.h>
 ,93 → 45,119
 #include <arch/types.h>
 #include <align.h>
-/** Copy block of memory
+/** Copy block of memory.
  *
- * Copy cnt bytes from src address to dst address.
- * The copying is done word-by-word and then byte-by-byte.
- * The source and destination memory areas cannot overlap.
+ * Copy cnt bytes from src address to dst address.  The copying is done
+ * word-by-word and then byte-by-byte.  The source and destination memory areas
+ * cannot overlap.
  *
- * @param src Origin address to copy from.
- * @param dst Origin address to copy to.
- * @param cnt Number of bytes to copy.
+ * @param src       Source address to copy from.
+ * @param dst       Destination address to copy to.
+ * @param cnt       Number of bytes to copy.
  *
+ * @return      Destination address.
  */
-void *_memcpy(void * dst, const void *src, size_t cnt)
+void *_memcpy(void *dst, const void *src, size_t cnt)
 {
     unsigned int i, j;
     if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
-        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
+        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
         for (i = 0; i < cnt; i++)
             ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
     } else {
-        for (i = 0; i < cnt/sizeof(unative_t); i++)
+        for (i = 0; i < cnt / sizeof(unative_t); i++)
             ((unative_t *) dst)[i] = ((unative_t *) src)[i];
-        for (j = 0; j < cnt%sizeof(unative_t); j++)
-            ((uint8_t *)(((unative_t *) dst) + i))[j] = ((uint8_t *)(((unative_t *) src) + i))[j];
+        for (j = 0; j < cnt % sizeof(unative_t); j++)
+            ((uint8_t *)(((unative_t *) dst) + i))[j] =
+                ((uint8_t *)(((unative_t *) src) + i))[j];
     }
-    return (char *) src;
+    return (char *) dst;
 }
-/** Fill block of memory
+/** Move memory block with possible overlapping.
  *
- * Fill cnt bytes at dst address with the value x.
- * The filling is done byte-by-byte.
+ * Copy cnt bytes from src address to dst address. The source and destination
+ * memory areas may overlap.
  *
- * @param dst Origin address to fill.
- * @param cnt Number of bytes to fill.
- * @param x   Value to fill.
+ * @param src       Source address to copy from.
+ * @param dst       Destination address to copy to.
+ * @param cnt       Number of bytes to copy.
  *
+ * @return      Destination address.
  */
-void _memsetb(uintptr_t dst, size_t cnt, uint8_t x)
+void *memmove(void *dst, const void *src, size_t n)
 {
-    unsigned int i;
-    uint8_t *p = (uint8_t *) dst;
-    for (i = 0; i < cnt; i++)
-        p[i] = x;
+    const uint8_t *sp;
+    uint8_t *dp;
+    /* Nothing to do? */
+    if (src == dst)
+        return dst;
+    /* Non-overlapping? */
+    if (dst >= src + n || src >= dst + n) {
+        return memcpy(dst, src, n);
+    }
+    /* Which direction? */
+    if (src > dst) {
+        /* Forwards. */
+        sp = src;
+        dp = dst;
+        while (n-- != 0)
+            *dp++ = *sp++;
+    } else {
+        /* Backwards. */
+        sp = src + (n - 1);
+        dp = dst + (n - 1);
+        while (n-- != 0)
+            *dp-- = *sp--;
+    }
+    return dst;
 }
 /** Fill block of memory
  *
- * Fill cnt words at dst address with the value x.
- * The filling is done word-by-word.
+ * Fill cnt bytes at dst address with the value x.  The filling is done
+ * byte-by-byte.
  *
- * @param dst Origin address to fill.
- * @param cnt Number of words to fill.
- * @param x   Value to fill.
+ * @param dst       Destination address to fill.
+ * @param cnt       Number of bytes to fill.
+ * @param x     Value to fill.
  *
  */
-void _memsetw(uintptr_t dst, size_t cnt, uint16_t x)
+void _memsetb(void *dst, size_t cnt, uint8_t x)
 {
     unsigned int i;
-    uint16_t *p = (uint16_t *) dst;
+    uint8_t *p = (uint8_t *) dst;
     for (i = 0; i < cnt; i++)
-        p[i] = x;
+        p[i] = x;
 }
-/** Copy string
+/** Fill block of memory.
  *
- * Copy string from src address to dst address.
- * The copying is done char-by-char until the null
- * character. The source and destination memory areas
- * cannot overlap.
+ * Fill cnt words at dst address with the value x.  The filling is done
+ * word-by-word.
  *
- * @param src Origin string to copy from.
- * @param dst Origin string to copy to.
+ * @param dst       Destination address to fill.
+ * @param cnt       Number of words to fill.
+ * @param x     Value to fill.
  *
  */
-char *strcpy(char *dest, const char *src)
+void _memsetw(void *dst, size_t cnt, uint16_t x)
 {
-    char *orig = dest;
+    unsigned int i;
+    uint16_t *p = (uint16_t *) dst;
-    while ((*(dest++) = *(src++)))
-        ;
-    return orig;
+    for (i = 0; i < cnt; i++)
+        p[i] = x;
 }
 /** @}

 /branches/dd/kernel/generic/src/lib/func.c
 ,8 → 55,6
 #ifdef CONFIG_DEBUG
     bool rundebugger = false;
-//      TODO test_and_set not defined on all arches
-//  if (!test_and_set(&haltstate))
     if (!atomic_get(&haltstate)) {
         atomic_set(&haltstate, 1);
         rundebugger = true;
 ,116 → 64,19
 #endif
     interrupts_disable();
-#ifdef CONFIG_DEBUG
-    if (rundebugger) {
-        printf("\n");
-        kconsole("panic"); /* Run kconsole as a last resort to user */
-    }
-#endif
+#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
+    if (rundebugger)
+        kconsole("panic", "\nLast resort kernel console ready\n", false);
+#endif
     if (CPU)
-        printf("cpu%d: halted\n", CPU->id);
+        printf("cpu%u: halted\n", CPU->id);
     else
         printf("cpu: halted\n");
     cpu_halt();
 }
-/** Return number of characters in a string.
- *
- * @param str NULL terminated string.
- *
- * @return Number of characters in str.
- */
-size_t strlen(const char *str)
-{
-    int i;
-    for (i = 0; str[i]; i++)
-        ;
-    return i;
-}
-/** Compare two NULL terminated strings
- *
- * Do a char-by-char comparison of two NULL terminated strings.
- * The strings are considered equal iff they consist of the same
- * characters on the minimum of their lengths.
- *
- * @param src First string to compare.
- * @param dst Second string to compare.
- *
- * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
- *
- */
-int strcmp(const char *src, const char *dst)
-{
-    for (; *src && *dst; src++, dst++) {
-        if (*src < *dst)
-            return -1;
-        if (*src > *dst)
-            return 1;
-    }
-    if (*src == *dst)
-        return 0;
-    if (!*src)
-        return -1;
-    return 1;
-}
-/** Compare two NULL terminated strings
- *
- * Do a char-by-char comparison of two NULL terminated strings.
- * The strings are considered equal iff they consist of the same
- * characters on the minimum of their lengths and specified maximal
- * length.
- *
- * @param src First string to compare.
- * @param dst Second string to compare.
- * @param len Maximal length for comparison.
- *
- * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
- *
- */
-int strncmp(const char *src, const char *dst, size_t len)
-{
-    unsigned int i;
-    for (i = 0; (*src) && (*dst) && (i < len); src++, dst++, i++) {
-        if (*src < *dst)
-            return -1;
-        if (*src > *dst)
-            return 1;
-    }
-    if (i == len || *src == *dst)
-        return 0;
-    if (!*src)
-        return -1;
-    return 1;
-}
-/** Copy NULL terminated string.
- *
- * Copy at most 'len' characters from string 'src' to 'dest'.
- * If 'src' is shorter than 'len', '\0' is inserted behind the
- * last copied character.
- *
- * @param src Source string.
- * @param dest Destination buffer.
- * @param len Size of destination buffer.
- */
-void strncpy(char *dest, const char *src, size_t len)
-{
-    unsigned int i;
-    for (i = 0; i < len; i++) {
-        if (!(dest[i] = src[i]))
-            return;
-    }
-    dest[i-1] = '\0';
-}
 /** Convert ascii representation to unative_t
  *
  * Supports 0x for hexa & 0 for octal notation.

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3022 → Rev 4055