Changeset 80cd7cd in mainline for kernel/generic

Timestamp:

2011-01-13T20:58:24Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

87e373b

Parents:

eaef141 (diff), a613fea1 (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

Files:

• include/ddi/ddi.h (modified) (1 diff)
• include/ddi/irq.h (modified) (3 diffs)
• include/interrupt.h (modified) (1 diff)
• include/proc/task.h (modified) (1 diff)
• include/syscall/syscall.h (modified) (2 diffs)
• src/ddi/ddi.c (modified) (1 diff)
• src/interrupt/interrupt.c (modified) (1 diff)
• src/ipc/ipc.c (modified) (1 diff)
• src/ipc/irq.c (modified) (1 diff)
• src/main/main.c (modified) (2 diffs)
• src/mm/slab.c (modified) (2 diffs)
• src/proc/task.c (modified) (1 diff)
• src/syscall/syscall.c (modified) (5 diffs)

kernel/generic/include/ddi/ddi.h

@@ -54 +54 @@
 extern sysarg_t sys_physmem_map(sysarg_t, sysarg_t, sysarg_t, sysarg_t);
 extern sysarg_t sys_iospace_enable(ddi_ioarg_t *);
-extern sysarg_t sys_interrupt_enable(int irq, int enable);
 
 /*

kernel/generic/include/ddi/irq.h

@@ -54 +54 @@
         /** Read 4 bytes from the I/O space. */
         CMD_PIO_READ_32,
+        
         /** Write 1 byte to the I/O space. */
         CMD_PIO_WRITE_8,
@@ -62 +63 @@
         
         /**
-         * Perform a bit test on the source argument and store the result into
-         * the destination argument.
+         * Write 1 byte from the source argument
+         * to the I/O space.
+         */
+        CMD_PIO_WRITE_A_8,
+        /**
+         * Write 2 bytes from the source argument
+         * to the I/O space.
+         */
+        CMD_PIO_WRITE_A_16,
+        /**
+         * Write 4 bytes from the source argument
+         * to the I/O space.
+         */
+        CMD_PIO_WRITE_A_32,
+        
+        /**
+         * Perform a bit masking on the source argument
+         * and store the result into the destination argument.
          */
         CMD_BTEST,
         
         /**
-         * Predicate the execution of the following N commands by the boolean
-         * value of the source argument.
+         * Predicate the execution of the following
+         * N commands by the boolean value of the source
+         * argument.
          */
         CMD_PREDICATE,
@@ -75 +93 @@
         /** Accept the interrupt. */
         CMD_ACCEPT,
+        
         /** Decline the interrupt. */
         CMD_DECLINE,

kernel/generic/include/interrupt.h

@@ -60 +60 @@
 extern void fault_if_from_uspace(istate_t *, const char *, ...)
     PRINTF_ATTRIBUTE(2, 3);
+extern istate_t *istate_get(thread_t *);
 extern iroutine_t exc_register(unsigned int, const char *, bool, iroutine_t);
 extern void exc_dispatch(unsigned int, istate_t *);

kernel/generic/include/proc/task.h

@@ -154 +154 @@
 
 extern sysarg_t sys_task_set_name(const char *, size_t);
+extern sysarg_t sys_task_kill(task_id_t *);
 
 #endif

kernel/generic/include/syscall/syscall.h

@@ -47 +47 @@
         SYS_TASK_GET_ID,
         SYS_TASK_SET_NAME,
+        SYS_TASK_KILL,
         SYS_PROGRAM_SPAWN_LOADER,
         
@@ -81 +82 @@
         SYS_PHYSMEM_MAP,
         SYS_IOSPACE_ENABLE,
-        SYS_INTERRUPT_ENABLE,
         
         SYS_SYSINFO_GET_TAG,

kernel/generic/src/ddi/ddi.c

@@ -258 +258 @@
 }
 
-/** Disable or enable specified interrupts.
- * 
- * @param irq the interrupt to be enabled/disabled.
- * @param enable if true enable the interrupt, disable otherwise.
- * 
- * @retutn Zero on success, error code otherwise.
- */
-sysarg_t sys_interrupt_enable(int irq, int enable)
-{
-/* FIXME: this needs to be generic code, or better not be in kernel at all. */
-#if 0
-        cap_t task_cap = cap_get(TASK);
-        if (!(task_cap & CAP_IRQ_REG))
-                return EPERM;
-                
-        if (irq < 0 || irq > 16) {
-                return EINVAL;
-        }
-        
-        uint16_t irq_mask = (uint16_t)(1 << irq);
-        if (enable) {
-                trap_virtual_enable_irqs(irq_mask);
-        } else {
-                trap_virtual_disable_irqs(irq_mask);
-        }
-        
-#endif
-        return 0;
-}
-
 /** @}
  */

kernel/generic/src/interrupt/interrupt.c

@@ -209 +209 @@
 }
 
+/** Get istate structure of a thread.
+ *
+ * Get pointer to the istate structure at the bottom of the kernel stack.
+ *
+ * This function can be called in interrupt or user context. In interrupt
+ * context the istate structure is created by the low-level exception
+ * handler. In user context the istate structure is created by the
+ * low-level syscall handler.
+ */
+istate_t *istate_get(thread_t *thread)
+{
+        /*
+         * The istate structure should be right at the bottom of the kernel
+         * stack.
+         */
+        return (istate_t *) ((uint8_t *) thread->kstack + THREAD_STACK_SIZE -
+            sizeof(istate_t));
+}
+
 #ifdef CONFIG_KCONSOLE
 

kernel/generic/src/ipc/ipc.c

@@ -706 +706 @@
                                 break;
                         case IPC_PHONE_CONNECTED:
-                                printf("connected to: %p ",
-                                    task->phones[i].callee);
+                                printf("connected to: %p (%" PRIu64 ") ",
+                                    task->phones[i].callee,
+                                    task->phones[i].callee->task->taskid);
                                 break;
                         case IPC_PHONE_SLAMMED:

kernel/generic/src/ipc/irq.c

@@ -404 +404 @@
                             (uint32_t) code->cmds[i].value);
                         break;
+                case CMD_PIO_WRITE_A_8:
+                        if (srcarg) {
+                                pio_write_8((ioport8_t *) code->cmds[i].addr,
+                                    (uint8_t) scratch[srcarg]);
+                        }
+                        break;
+                case CMD_PIO_WRITE_A_16:
+                        if (srcarg) {
+                                pio_write_16((ioport16_t *) code->cmds[i].addr,
+                                    (uint16_t) scratch[srcarg]);
+                        }
+                        break;
+                case CMD_PIO_WRITE_A_32:
+                        if (srcarg) {
+                                pio_write_32((ioport32_t *) code->cmds[i].addr,
+                                    (uint32_t) scratch[srcarg]);
+                        }
+                        break;
                 case CMD_BTEST:
                         if ((srcarg) && (dstarg)) {

kernel/generic/src/main/main.c

@@ -185 +185 @@
         LOG("\nconfig.base=%p config.kernel_size=%zu"
             "\nconfig.stack_base=%p config.stack_size=%zu",
-            config.base, config.kernel_size, config.stack_base,
-            config.stack_size);
+            (void *) config.base, config.kernel_size,
+            (void *) config.stack_base, config.stack_size);
         
 #ifdef CONFIG_KCONSOLE
@@ -242 +242 @@
                 for (i = 0; i < init.cnt; i++)
                         LOG("init[%zu].addr=%p, init[%zu].size=%zu",
-                            i, init.tasks[i].addr, i, init.tasks[i].size);
+                            i, (void *) init.tasks[i].addr, i, init.tasks[i].size);
         } else
                 printf("No init binaries found.\n");

kernel/generic/src/mm/slab.c

@@ -806 +806 @@
 }
 
-/** Go through all caches and reclaim what is possible
- *
- * Interrupts must be disabled before calling this function,
- * otherwise  memory allocation from interrupts can deadlock.
- *
- */
+/** Go through all caches and reclaim what is possible */
 size_t slab_reclaim(unsigned int flags)
 {
-        irq_spinlock_lock(&slab_cache_lock, false);
+        irq_spinlock_lock(&slab_cache_lock, true);
         
         size_t frames = 0;
@@ -824 +819 @@
         }
         
-        irq_spinlock_unlock(&slab_cache_lock, false);
+        irq_spinlock_unlock(&slab_cache_lock, true);
         
         return frames;

kernel/generic/src/proc/task.c

@@ -360 +360 @@
 }
 
+/** Syscall to forcefully terminate a task
+ *
+ * @param uspace_taskid Pointer to task ID in user space.
+ *
+ * @return 0 on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_task_kill(task_id_t *uspace_taskid)
+{
+        task_id_t taskid;
+        int rc;
+
+        rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
+        if (rc != 0)
+                return (sysarg_t) rc;
+
+        return (sysarg_t) task_kill(taskid);
+}
+
 /** Find task structure corresponding to task ID.
  *

kernel/generic/src/syscall/syscall.c

@@ -45 +45 @@
 #include <debug.h>
 #include <ddi/device.h>
+#include <interrupt.h>
 #include <ipc/sysipc.h>
 #include <synch/futex.h>
@@ -66 +67 @@
 #ifdef CONFIG_UDEBUG
         /*
+         * An istate_t-compatible record was created on the stack by the
+         * low-level syscall handler. This is the userspace space state
+         * structure.
+         */
+        THREAD->udebug.uspace_state = istate_get(THREAD);
+
+        /*
          * Early check for undebugged tasks. We do not lock anything as this
          * test need not be precise in either direction.
-         *
          */
         if (THREAD->udebug.active)
@@ -98 +105 @@
                 udebug_stoppable_end();
         }
+
+        /* Clear userspace state pointer */
+        THREAD->udebug.uspace_state = NULL;
 #endif
         
@@ -120 +130 @@
         (syshandler_t) sys_task_get_id,
         (syshandler_t) sys_task_set_name,
+        (syshandler_t) sys_task_kill,
         (syshandler_t) sys_program_spawn_loader,
         
@@ -160 +171 @@
         (syshandler_t) sys_physmem_map,
         (syshandler_t) sys_iospace_enable,
-        (syshandler_t) sys_interrupt_enable,
         
         /* Sysinfo syscalls */