Changeset dff90fa7 in mainline for kernel/generic

Timestamp:

2013-06-05T19:41:12Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

74dcc07

Parents:

f288d85 (diff), 6db5d4b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

mainline changes

Location:

kernel/generic

Files:

• include/debug.h (modified) (1 diff)
• include/lib/memfnc.h (modified) (1 diff)
• include/mm/tlb.h (modified) (1 diff)
• include/printf/verify.h (modified) (1 diff)
• src/interrupt/interrupt.c (modified) (2 diffs)
• src/main/kinit.c (modified) (1 diff)
• src/main/main.c (modified) (1 diff)
• src/mm/as.c (modified) (7 diffs)
• src/mm/backend_anon.c (modified) (3 diffs)
• src/mm/backend_elf.c (modified) (4 diffs)
• src/mm/backend_phys.c (modified) (3 diffs)
• src/mm/page.c (modified) (3 diffs)
• src/proc/task.c (modified) (1 diff)
• src/sysinfo/sysinfo.c (modified) (1 diff)

kernel/generic/include/debug.h

@@ -77 +77 @@
         } while (0)
 
+/** Static assert macro
+ *
+ */
+#define STATIC_ASSERT(expr) \
+        _Static_assert(expr, "")
+
+#define STATIC_ASSERT_VERBOSE(expr, msg) \
+        _Static_assert(expr, msg)
+
+
 #else /* CONFIG_DEBUG */
 
 #define ASSERT(expr)
 #define ASSERT_VERBOSE(expr, msg)
+#define STATIC_ASSERT(expr)
+#define STATIC_ASSERT_VERBOSE(expr, msg)
 
 #endif /* CONFIG_DEBUG */

kernel/generic/include/lib/memfnc.h

@@ -38 +38 @@
 #include <typedefs.h>
 
-extern void *memset(void *, int, size_t);
-extern void *memcpy(void *, const void *, size_t);
+extern void *memset(void *, int, size_t)
+    __attribute__ ((optimize("-fno-tree-loop-distribute-patterns")));
+extern void *memcpy(void *, const void *, size_t)
+    __attribute__ ((optimize("-fno-tree-loop-distribute-patterns")));
 
 #endif

kernel/generic/include/mm/tlb.h

@@ -73 +73 @@
 extern void tlb_shootdown_ipi_recv(void);
 #else
-#define tlb_shootdown_start(w, x, y, z) (0)
-#define tlb_shootdown_finalize(i)       ((i) = (i));
+#define tlb_shootdown_start(w, x, y, z) interrupts_disable()    
+#define tlb_shootdown_finalize(i)       (interrupts_restore(i));
 #define tlb_shootdown_ipi_recv()
 #endif /* CONFIG_SMP */

kernel/generic/include/printf/verify.h

@@ -38 +38 @@
 #ifndef NVERIFY_PRINTF
 
+#ifdef __clang__
+#define PRINTF_ATTRIBUTE(start, end) \
+        __attribute__((format(__printf__, start, end)))
+#else
 #define PRINTF_ATTRIBUTE(start, end) \
         __attribute__((format(gnu_printf, start, end)))
+#endif
+
 
 #else /* NVERIFY_PRINTF */

kernel/generic/src/interrupt/interrupt.c

@@ -54 +54 @@
 #include <proc/thread.h>
 #include <arch/cycle.h>
+#include <arch/stack.h>
 #include <str.h>
 #include <trace.h>
@@ -222 +223 @@
         /*
          * The istate structure should be right at the bottom of the kernel
-         * stack.
+         * memory stack.
          */
-        return (istate_t *) ((uint8_t *)
-            thread->kstack + STACK_SIZE - sizeof(istate_t));
+        return (istate_t *) &thread->kstack[MEM_STACK_SIZE - sizeof(istate_t)];
 }
 

kernel/generic/src/main/kinit.c

@@ -250 +250 @@
                                     CAP_IO_MANAGER | CAP_IRQ_REG);
                                 
-                                if (!ipc_phone_0)
+                                if (!ipc_phone_0) {
                                         ipc_phone_0 = &programs[i].task->answerbox;
+                                        /*
+                                         * Hold the first task so that the
+                                         * ipc_phone_0 remains a valid pointer
+                                         * even if the first task exits for
+                                         * whatever reason.
+                                         */
+                                        task_hold(programs[i].task);
+                                }
                         }
                         

kernel/generic/src/main/main.c

@@ -89 +89 @@
 #include <lib/ra.h>
 
+/* Ensure [u]int*_t types are of correct size.
+ *
+ * Probably, this is not the best place for such tests
+ * but this file is compiled on all architectures.
+ */
+#define CHECK_INT_TYPE_(signness, size) \
+        STATIC_ASSERT_VERBOSE(sizeof(signness##size##_t) * 8 == size, \
+            #signness #size "_t does not have " #size " bits");
+
+#define CHECK_INT_TYPE(size) \
+        CHECK_INT_TYPE_(int, size); \
+        CHECK_INT_TYPE_(uint, size)
+
+CHECK_INT_TYPE(8);
+CHECK_INT_TYPE(16);
+CHECK_INT_TYPE(32);
+CHECK_INT_TYPE(64);
+
 /** Global configuration structure. */
 config_t config = {

kernel/generic/src/mm/as.c

@@ -544 +544 @@
     mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound)
 {
-        if ((*base != (uintptr_t) -1) && ((*base % PAGE_SIZE) != 0))
+        if ((*base != (uintptr_t) -1) && !IS_ALIGNED(*base, PAGE_SIZE))
                 return NULL;
         
@@ -688 +688 @@
 int as_area_resize(as_t *as, uintptr_t address, size_t size, unsigned int flags)
 {
+        if (!IS_ALIGNED(address, PAGE_SIZE))
+                return EINVAL;
+
         mutex_lock(&as->lock);
         
@@ -1350 +1353 @@
  * Interrupts are assumed disabled.
  *
- * @param page   Faulting page.
- * @param access Access mode that caused the page fault (i.e.
- *               read/write/exec).
- * @param istate Pointer to the interrupted state.
+ * @param address Faulting address.
+ * @param access  Access mode that caused the page fault (i.e.
+ *                read/write/exec).
+ * @param istate  Pointer to the interrupted state.
  *
  * @return AS_PF_FAULT on page fault.
@@ -1361 +1364 @@
  *
  */
-int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
-{
+int as_page_fault(uintptr_t address, pf_access_t access, istate_t *istate)
+{
+        uintptr_t page = ALIGN_DOWN(address, PAGE_SIZE);
         int rc = AS_PF_FAULT;
 
@@ -1452 +1456 @@
                 task_kill_self(true);
         } else {
-                fault_if_from_uspace(istate, "Page fault: %p.", (void *) page);
-                panic_memtrap(istate, access, page, NULL);
+                fault_if_from_uspace(istate, "Page fault: %p.", (void *) address);
+                panic_memtrap(istate, access, address, NULL);
         }
         
@@ -1679 +1683 @@
 {
         ASSERT(mutex_locked(&area->lock));
-        ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
+        ASSERT(IS_ALIGNED(page, PAGE_SIZE));
         ASSERT(count);
         
@@ -1963 +1967 @@
 {
         ASSERT(mutex_locked(&area->lock));
-        ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
+        ASSERT(IS_ALIGNED(page, PAGE_SIZE));
         ASSERT(count);
         

kernel/generic/src/mm/backend_anon.c

@@ -173 +173 @@
  *
  * @param area Pointer to the address space area.
- * @param addr Faulting virtual address.
+ * @param upage Faulting virtual page.
  * @param access Access mode that caused the fault (i.e. read/write/exec).
  *
@@ -179 +179 @@
  *     serviced).
  */
-int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
-{
-        uintptr_t upage = ALIGN_DOWN(addr, PAGE_SIZE);
+int anon_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
+{
         uintptr_t kpage;
         uintptr_t frame;
@@ -187 +186 @@
         ASSERT(page_table_locked(AS));
         ASSERT(mutex_locked(&area->lock));
+        ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
 
         if (!as_area_check_access(area, access))

kernel/generic/src/mm/backend_elf.c

@@ -235 +235 @@
  *
  * @param area          Pointer to the address space area.
- * @param addr          Faulting virtual address.
+ * @param upage         Faulting virtual page.
  * @param access        Access mode that caused the fault (i.e.
  *                      read/write/exec).
@@ -242 +242 @@
  *                      on success (i.e. serviced).
  */
-int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
+int elf_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
 {
         elf_header_t *elf = area->backend_data.elf;
@@ -250 +250 @@
         uintptr_t frame;
         uintptr_t kpage;
-        uintptr_t upage;
         uintptr_t start_anon;
         size_t i;
@@ -257 +256 @@
         ASSERT(page_table_locked(AS));
         ASSERT(mutex_locked(&area->lock));
+        ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
 
         if (!as_area_check_access(area, access))
                 return AS_PF_FAULT;
         
-        if (addr < ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE))
+        if (upage < ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE))
                 return AS_PF_FAULT;
         
-        if (addr >= entry->p_vaddr + entry->p_memsz)
+        if (upage >= entry->p_vaddr + entry->p_memsz)
                 return AS_PF_FAULT;
         
-        i = (addr - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
+        i = (upage - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
         base = (uintptr_t)
             (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
-
-        /* Virtual address of faulting page */
-        upage = ALIGN_DOWN(addr, PAGE_SIZE);
 
         /* Virtual address of the end of initialized part of segment */

kernel/generic/src/mm/backend_phys.c

@@ -111 +111 @@
  *
  * @param area Pointer to the address space area.
- * @param addr Faulting virtual address.
+ * @param upage Faulting virtual page.
  * @param access Access mode that caused the fault (i.e. read/write/exec).
  *
@@ -117 +117 @@
  * serviced).
  */
-int phys_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
+int phys_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
 {
         uintptr_t base = area->backend_data.base;
@@ -123 +123 @@
         ASSERT(page_table_locked(AS));
         ASSERT(mutex_locked(&area->lock));
+        ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
 
         if (!as_area_check_access(area, access))
                 return AS_PF_FAULT;
 
-        ASSERT(addr - area->base < area->backend_data.frames * FRAME_SIZE);
-        page_mapping_insert(AS, addr, base + (addr - area->base),
+        ASSERT(upage - area->base < area->backend_data.frames * FRAME_SIZE);
+        page_mapping_insert(AS, upage, base + (upage - area->base),
             as_area_get_flags(area));
         
-        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
+        if (!used_space_insert(area, upage, 1))
                 panic("Cannot insert used space.");
 

kernel/generic/src/mm/page.c

@@ -104 +104 @@
         ASSERT(page_mapping_operations->mapping_insert);
 
-        page_mapping_operations->mapping_insert(as, page, frame, flags);
+        page_mapping_operations->mapping_insert(as, ALIGN_DOWN(page, PAGE_SIZE),
+            ALIGN_DOWN(frame, FRAME_SIZE), flags);
         
         /* Repel prefetched accesses to the old mapping. */
@@ -127 +128 @@
         ASSERT(page_mapping_operations->mapping_remove);
         
-        page_mapping_operations->mapping_remove(as, page);
+        page_mapping_operations->mapping_remove(as,
+            ALIGN_DOWN(page, PAGE_SIZE));
         
         /* Repel prefetched accesses to the old mapping. */
@@ -150 +152 @@
         ASSERT(page_mapping_operations->mapping_find);
         
-        return page_mapping_operations->mapping_find(as, page, nolock);
+        return page_mapping_operations->mapping_find(as,
+            ALIGN_DOWN(page, PAGE_SIZE), nolock);
 }
 

kernel/generic/src/proc/task.c

@@ -125 +125 @@
 {
         size_t tasks_left;
+
+        if (ipc_phone_0) {
+                task_t *task_0 = ipc_phone_0->task;
+                ipc_phone_0 = NULL;
+                /*
+                 * The first task is held by kinit(), we need to release it or
+                 * it will never finish cleanup.
+                 */
+                task_release(task_0);
+        }
         
         /* Repeat until there are any tasks except TASK */

kernel/generic/src/sysinfo/sysinfo.c

@@ -753 +753 @@
         sysinfo_return_t ret;
         ret.tag = SYSINFO_VAL_UNDEFINED;
+        ret.data.data = NULL;
+        ret.data.size = 0;
         
         if (size > SYSINFO_MAX_PATH)