Changeset 7aaed09 in mainline for kernel/generic/src

Timestamp:

2011-12-18T14:02:30Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

c868e2d

Parents:

3b71e84d (diff), 1761268 (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:

Merge mainline changes.

Location:

kernel/generic/src

Files:

• ddi/ddi.c (modified) (10 diffs)
• ipc/irq.c (modified) (3 diffs)
• ipc/sysipc.c (modified) (1 diff)
• lib/rd.c (modified) (2 diffs)
• main/kinit.c (modified) (2 diffs)
• main/main.c (modified) (1 diff)
• mm/page.c (modified) (2 diffs)
• syscall/syscall.c (modified) (1 diff)

kernel/generic/src/ddi/ddi.c

@@ -45 +45 @@
 #include <mm/frame.h>
 #include <mm/as.h>
+#include <mm/page.h>
 #include <synch/mutex.h>
 #include <syscall/copy.h>
@@ -52 +53 @@
 #include <errno.h>
 #include <trace.h>
+#include <bitops.h>
 
 /** This lock protects the parea_btree. */
@@ -87 +89 @@
 /** Map piece of physical memory into virtual address space of current task.
  *
- * @param pf    Physical address of the starting frame.
- * @param vp    Virtual address of the starting page.
+ * @param phys  Physical address of the starting frame.
+ * @param virt  Virtual address of the starting page.
  * @param pages Number of pages to map.
  * @param flags Address space area flags for the mapping.
  *
- * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *         syscall, EBADMEM if pf or vf is not page aligned, ENOENT if there
- *         is no task matching the specified ID or the physical address space
- *         is not enabled for mapping and ENOMEM if there was a problem in
- *         creating address space area.
- *
- */
-NO_TRACE static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages,
+ * @return EOK on success.
+ * @return EPERM if the caller lacks capabilities to use this syscall.
+ * @return EBADMEM if phys or virt is not page aligned.
+ * @return ENOENT if there is no task matching the specified ID or
+ *         the physical address space is not enabled for mapping.
+ * @return ENOMEM if there was a problem in creating address space area.
+ *
+ */
+NO_TRACE static int ddi_physmem_map(uintptr_t phys, uintptr_t virt, size_t pages,
     unsigned int flags)
 {
         ASSERT(TASK);
         
-        if ((pf % FRAME_SIZE) != 0)
+        if ((phys % FRAME_SIZE) != 0)
                 return EBADMEM;
         
-        if ((vp % PAGE_SIZE) != 0)
+        if ((virt % PAGE_SIZE) != 0)
                 return EBADMEM;
         
@@ -118 +121 @@
         
         mem_backend_data_t backend_data;
-        backend_data.base = pf;
+        backend_data.base = phys;
         backend_data.frames = pages;
         
@@ -129 +132 @@
         btree_node_t *nodep;
         parea_t *parea = (parea_t *) btree_search(&parea_btree,
-            (btree_key_t) pf, &nodep);
+            (btree_key_t) phys, &nodep);
         
         if ((parea != NULL) && (parea->frames >= pages)) {
@@ -149 +152 @@
         
         irq_spinlock_lock(&zones.lock, true);
-        size_t znum = find_zone(ADDR2PFN(pf), pages, 0);
+        size_t znum = find_zone(ADDR2PFN(phys), pages, 0);
         
         if (znum == (size_t) -1) {
@@ -182 +185 @@
         
 map:
-        if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp,
+        if (!as_area_create(TASK->as, flags, FRAMES2SIZE(pages), virt,
             AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
                 /*
@@ -253 +256 @@
 /** Wrapper for SYS_PHYSMEM_MAP syscall.
  *
- * @param phys_base Physical base address to map
- * @param virt_base Destination virtual address
+ * @param phys  Physical base address to map
+ * @param virt  Destination virtual address
  * @param pages Number of pages
  * @param flags Flags of newly mapped pages
@@ -261 +264 @@
  *
  */
-sysarg_t sys_physmem_map(sysarg_t phys_base, sysarg_t virt_base,
-    sysarg_t pages, sysarg_t flags)
-{
-        return (sysarg_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
-            FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
-            (size_t) pages, (int) flags);
+sysarg_t sys_physmem_map(uintptr_t phys, uintptr_t virt,
+    size_t pages, unsigned int flags)
+{
+        return (sysarg_t)
+            ddi_physmem_map(ALIGN_DOWN(phys, FRAME_SIZE),
+            ALIGN_DOWN(virt, PAGE_SIZE), pages, flags);
 }
 
@@ -287 +290 @@
 }
 
+NO_TRACE static int dmamem_map(uintptr_t virt, size_t size,
+    unsigned int map_flags, unsigned int flags, void **phys)
+{
+        ASSERT(TASK);
+        
+        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0) {
+                // TODO: implement locking of non-anonymous mapping
+                return page_find_mapping(virt, phys);
+        } else {
+                // TODO: implement locking
+                
+                if ((virt % PAGE_SIZE) != 0)
+                        return EBADMEM;
+                
+                size_t pages = SIZE2FRAMES(size);
+                uint8_t order;
+                
+                /* We need the 2^order >= pages */
+                if (pages == 1)
+                        order = 0;
+                else
+                        order = fnzb(pages - 1) + 1;
+                
+                *phys = frame_alloc_noreserve(order, 0);
+                if (*phys == NULL)
+                        return ENOMEM;
+                
+                mem_backend_data_t backend_data;
+                backend_data.base = (uintptr_t) *phys;
+                backend_data.frames = pages;
+                
+                if (!as_area_create(TASK->as, map_flags, size, virt,
+                    AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
+                        frame_free_noreserve((uintptr_t) *phys);
+                        return ENOMEM;
+                }
+                
+                return EOK;
+        }
+}
+
+NO_TRACE static int dmamem_unmap(uintptr_t virt, size_t size,
+    unsigned int flags)
+{
+        // TODO: implement unlocking & unmap
+        return EOK;
+}
+
+sysarg_t sys_dmamem_map(uintptr_t virt, size_t size, unsigned int map_flags,
+    unsigned int flags, void *phys_ptr)
+{
+        void *phys;
+        int rc = dmamem_map(virt, size, map_flags, flags, &phys);
+        if (rc != EOK)
+                return rc;
+        
+        rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+        if (rc != EOK) {
+                dmamem_unmap(virt, size, flags);
+                return rc;
+        }
+        
+        return EOK;
+}
+
+sysarg_t sys_dmamem_unmap(uintptr_t virt, size_t size, unsigned int flags)
+{
+        return dmamem_unmap(virt, size, flags);
+}
+
 /** @}
  */

kernel/generic/src/ipc/irq.c

@@ -365 +365 @@
                 return IRQ_DECLINE;
         
-#define CMD_MEM_READ(target) \
-do { \
-        void *va = code->cmds[i].addr; \
-        if (AS != irq->driver_as) \
-                as_switch(AS, irq->driver_as); \
-        memcpy_from_uspace(&target, va, (sizeof(target))); \
-        if (dstarg) \
-                scratch[dstarg] = target; \
-} while(0)
-
-#define CMD_MEM_WRITE(val) \
-do { \
-        void *va = code->cmds[i].addr; \
-        if (AS != irq->driver_as) \
-                as_switch(AS, irq->driver_as); \
-        memcpy_to_uspace(va, &val, sizeof(val)); \
-} while (0)
-
         as_t *current_as = AS;
-        size_t i;
-        for (i = 0; i < code->cmdcount; i++) {
+        if (current_as != irq->driver_as)
+                as_switch(AS, irq->driver_as);
+        
+        for (size_t i = 0; i < code->cmdcount; i++) {
                 uint32_t dstval;
+                void *va;
+                uint8_t val8;
+                uint16_t val16;
+                uint32_t val32;
+                
                 uintptr_t srcarg = code->cmds[i].srcarg;
                 uintptr_t dstarg = code->cmds[i].dstarg;
@@ -442 +431 @@
                         }
                         break;
-                case CMD_MEM_READ_8: {
-                        uint8_t val;
-                        CMD_MEM_READ(val);
-                        break;
-                        }
-                case CMD_MEM_READ_16: {
-                        uint16_t val;
-                        CMD_MEM_READ(val);
-                        break;
-                        }
-                case CMD_MEM_READ_32: {
-                        uint32_t val;
-                        CMD_MEM_READ(val);
-                        break;
-                        }
-                case CMD_MEM_WRITE_8: {
-                        uint8_t val = code->cmds[i].value;
-                        CMD_MEM_WRITE(val);
-                        break;
-                        }
-                case CMD_MEM_WRITE_16: {
-                        uint16_t val = code->cmds[i].value;
-                        CMD_MEM_WRITE(val);
-                        break;
-                        }
-                case CMD_MEM_WRITE_32: {
-                        uint32_t val = code->cmds[i].value;
-                        CMD_MEM_WRITE(val);
-                        break;
-                        }
+                case CMD_MEM_READ_8:
+                        va = code->cmds[i].addr;
+                        memcpy_from_uspace(&val8, va, sizeof(val8));
+                        if (dstarg)
+                                scratch[dstarg] = val8;
+                        break;
+                case CMD_MEM_READ_16:
+                        va = code->cmds[i].addr;
+                        memcpy_from_uspace(&val16, va, sizeof(val16));
+                        if (dstarg)
+                                scratch[dstarg] = val16;
+                        break;
+                case CMD_MEM_READ_32:
+                        va = code->cmds[i].addr;
+                        memcpy_from_uspace(&val32, va, sizeof(val32));
+                        if (dstarg)
+                                scratch[dstarg] = val32;
+                        break;
+                case CMD_MEM_WRITE_8:
+                        val8 = code->cmds[i].value;
+                        va = code->cmds[i].addr;
+                        memcpy_to_uspace(va, &val8, sizeof(val8));
+                        break;
+                case CMD_MEM_WRITE_16:
+                        val16 = code->cmds[i].value;
+                        va = code->cmds[i].addr;
+                        memcpy_to_uspace(va, &val16, sizeof(val16));
+                        break;
+                case CMD_MEM_WRITE_32:
+                        val32 = code->cmds[i].value;
+                        va = code->cmds[i].addr;
+                        memcpy_to_uspace(va, &val32, sizeof(val32));
+                        break;
                 case CMD_MEM_WRITE_A_8:
                         if (srcarg) {
-                                uint8_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
+                                val8 = scratch[srcarg];
+                                va = code->cmds[i].addr;
+                                memcpy_to_uspace(va, &val8, sizeof(val8));
                         }
                         break;
                 case CMD_MEM_WRITE_A_16:
                         if (srcarg) {
-                                uint16_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
+                                val16 = scratch[srcarg];
+                                va = code->cmds[i].addr;
+                                memcpy_to_uspace(va, &val16, sizeof(val16));
                         }
                         break;
                 case CMD_MEM_WRITE_A_32:
                         if (srcarg) {
-                                uint32_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
+                                val32 = scratch[srcarg];
+                                va = code->cmds[i].addr;
+                                memcpy_to_uspace(va, &val32, sizeof(val32));
                         }
                         break;
@@ -513 +508 @@
                 }
         }
+        
         if (AS != current_as)
                 as_switch(AS, current_as);

kernel/generic/src/ipc/sysipc.c

@@ -278 +278 @@
                 }
         } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) {
-                if (!IPC_GET_RETVAL(answer->data)) { 
+                if (!IPC_GET_RETVAL(answer->data)) {
                         irq_spinlock_lock(&answer->sender->lock, true);
                         as_t *as = answer->sender->as;

kernel/generic/src/lib/rd.c

@@ -33 +33 @@
 /**
  * @file
- * @brief       RAM disk support.
+ * @brief RAM disk support.
  *
  * Support for RAM disk images.
@@ -39 +39 @@
 
 #include <lib/rd.h>
-#include <byteorder.h>
 #include <mm/frame.h>
 #include <sysinfo/sysinfo.h>
 #include <ddi/ddi.h>
-#include <align.h>
 
-static parea_t rd_parea;                /**< Physical memory area for rd. */
+/** Physical memory area for RAM disk. */
+static parea_t rd_parea;
 
-/**
- * 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.
- */  
-int init_rd(rd_header_t *header, size_t size)
+/** RAM disk initialization routine
+ *
+ * The information about the RAM disk is provided as sysinfo
+ * values to the uspace tasks.
+ *
+ */
+void init_rd(void *data, 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))
-                return RE_INVALID;
+        uintptr_t base = KA2PA((uintptr_t) data);
+        ASSERT((base % FRAME_SIZE) == 0);
         
-        /* Identify version */  
-        if (header->version != RD_VERSION)
-                return RE_UNSUPPORTED;
-        
-        uint32_t hsize;
-        uint64_t dsize;
-        switch (header->data_type) {
-        case RD_DATA_LSB:
-                hsize = uint32_t_le2host(header->header_size);
-                dsize = uint64_t_le2host(header->data_size);
-                break;
-        case RD_DATA_MSB:
-                hsize = uint32_t_be2host(header->header_size);
-                dsize = uint64_t_be2host(header->data_size);
-                break;
-        default:
-                return RE_UNSUPPORTED;
-        }
-        
-        if ((hsize % FRAME_SIZE) || (dsize % FRAME_SIZE))
-                return RE_UNSUPPORTED;
-                
-        if (hsize > size)
-                return RE_INVALID;
-        
-        if ((uint64_t) hsize + dsize > size)
-                dsize = size - hsize;
-        
-        rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
-            FRAME_SIZE);
-        rd_parea.frames = SIZE2FRAMES(dsize);
+        rd_parea.pbase = base;
+        rd_parea.frames = SIZE2FRAMES(size);
         rd_parea.unpriv = false;
         rd_parea.mapped = false;
         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,
-            (sysarg_t) KA2PA((void *) header + hsize));
-
-        return RE_OK;
+        sysinfo_set_item_val("rd.size", NULL, size);
+        sysinfo_set_item_val("rd.address.physical", NULL, (sysarg_t) base);
 }
 

kernel/generic/src/main/kinit.c

@@ -179 +179 @@
         for (i = 0; i < init.cnt; i++) {
                 if (init.tasks[i].addr % FRAME_SIZE) {
-                        printf("init[%zu].addr is not frame aligned\n", i);
+                        printf("init[%zu]: Address is not frame aligned\n", i);
                         programs[i].task = NULL;
                         continue;
@@ -203 +203 @@
                     namebuf, &programs[i]);
                 
-                if ((rc == 0) && (programs[i].task != NULL)) {
+                if (rc == 0) {
+                        if (programs[i].task != NULL) {
+                                /*
+                                 * Set capabilities to init userspace tasks.
+                                 */
+                                cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
+                                    CAP_IO_MANAGER | CAP_IRQ_REG);
+                                
+                                if (!ipc_phone_0)
+                                        ipc_phone_0 = &programs[i].task->answerbox;
+                        }
+                        
                         /*
-                         * Set capabilities to init userspace tasks.
+                         * If programs[i].task == NULL then it is
+                         * the program loader and it was registered
+                         * successfully.
                          */
-                        cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
-                            CAP_IO_MANAGER | CAP_IRQ_REG);
-                        
-                        if (!ipc_phone_0)
-                                ipc_phone_0 = &programs[i].task->answerbox;
-                } else if (rc == 0) {
-                        /* It was the program loader and was registered */
-                } else {
-                        /* RAM disk image */
-                        int rd = init_rd((rd_header_t *) init.tasks[i].addr, init.tasks[i].size);
-                        
-                        if (rd != RE_OK)
-                                printf("Init binary %zu not used (error %d)\n", i, rd);
-                }
+                } else if (i == init.cnt - 1) {
+                        /*
+                         * Assume the last task is the RAM disk.
+                         */
+                        init_rd((void *) init.tasks[i].addr, init.tasks[i].size);
+                } else
+                        printf("init[%zu]: Init binary load failed (error %d)\n", i, rc);
         }
         

kernel/generic/src/main/main.c

@@ -268 +268 @@
          * Create the first thread.
          */
-        thread_t *kinit_thread
-                = thread_create(kinit, NULL, kernel, 0, "kinit", true);
+        thread_t *kinit_thread =
+            thread_create(kinit, NULL, kernel, 0, "kinit", true);
         if (!kinit_thread)
                 panic("Cannot create kinit thread.");

kernel/generic/src/mm/page.c

@@ -53 +53 @@
  * We assume that the other processors are either not using the mapping yet
  * (i.e. during the bootstrap) or are executing the TLB shootdown code.  While
- * we don't care much about the former case, the processors in the latter case 
+ * we don't care much about the former case, the processors in the latter case
  * will do an implicit serialization by virtue of running the TLB shootdown
  * interrupt handler.
@@ -198 +198 @@
 }
 
+int page_find_mapping(uintptr_t virt, void **phys)
+{
+        mutex_lock(&AS->lock);
+        
+        pte_t *pte = page_mapping_find(AS, virt, false);
+        if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
+                mutex_unlock(&AS->lock);
+                return ENOENT;
+        }
+        
+        *phys = (void *) PTE_GET_FRAME(pte) +
+            (virt - ALIGN_DOWN(virt, PAGE_SIZE));
+        
+        mutex_unlock(&AS->lock);
+        
+        return EOK;
+}
 
 /** Syscall wrapper for getting mapping of a virtual page.
- * 
- * @retval EOK Everything went find, @p uspace_frame and @p uspace_node
- *             contains correct values.
- * @retval ENOENT Virtual address has no mapping.
- */
-sysarg_t sys_page_find_mapping(uintptr_t virt_address,
-    uintptr_t *uspace_frame)
-{
-        mutex_lock(&AS->lock);
-        
-        pte_t *pte = page_mapping_find(AS, virt_address, false);
-        if (!PTE_VALID(pte) || !PTE_PRESENT(pte)) {
-                mutex_unlock(&AS->lock);
-                
-                return (sysarg_t) ENOENT;
-        }
-        
-        uintptr_t phys_address = PTE_GET_FRAME(pte);
-        
-        mutex_unlock(&AS->lock);
-        
-        int rc = copy_to_uspace(uspace_frame,
-            &phys_address, sizeof(phys_address));
-        if (rc != EOK) {
-                return (sysarg_t) rc;
-        }
-        
-        return EOK;
+ *
+ * @return EOK on success.
+ * @return ENOENT if no virtual address mapping found.
+ *
+ */
+sysarg_t sys_page_find_mapping(uintptr_t virt, void *phys_ptr)
+{
+        void *phys;
+        int rc = page_find_mapping(virt, &phys);
+        if (rc != EOK)
+                return rc;
+        
+        rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+        return (sysarg_t) rc;
 }
 

kernel/generic/src/syscall/syscall.c

@@ -176 +176 @@
         (syshandler_t) sys_device_assign_devno,
         (syshandler_t) sys_physmem_map,
+        (syshandler_t) sys_dmamem_map,
+        (syshandler_t) sys_dmamem_unmap,
         (syshandler_t) sys_iospace_enable,
         (syshandler_t) sys_register_irq,