Remove non-preemptive section hack.

5 files changed, 16 insertions, 202 deletions

diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
index 65496c26da..27868b3742 100644
--- a/arch/x86/kernel/syscall_table_32.S
+++ b/arch/x86/kernel/syscall_table_32.S
@@ -328,16 +328,14 @@ ENTRY(sys_call_table)
         .long sys_set_rt_task_param     /* 325 */
         .long sys_get_rt_task_param
         .long sys_complete_job
-        .long sys_register_np_flag
-        .long sys_exit_np
-        .long sys_od_open               /* 330 */
+        .long sys_od_open
         .long sys_od_close
         .long sys_fmlp_down
         .long sys_fmlp_up
         .long sys_srp_down
-        .long sys_srp_up                /* 335 */
+        .long sys_srp_up
         .long sys_query_job_no
         .long sys_wait_for_job_release
         .long sys_wait_for_ts_release
         .long sys_release_ts
-        .long sys_null_call             /* 340 */
+        .long sys_null_call
diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index 6c7a4c5234..c56e004b9a 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -146,18 +146,6 @@ void srp_ceiling_block(void);
 
 #define heap2task(hn) ((struct task_struct*) hn->value)
 
-
-#ifdef CONFIG_NP_SECTION
-/* returns 1 if task t has registered np flag and set it to RT_NON_PREEMPTIVE
- */
-int is_np(struct task_struct *t);
-
-/* request that the task should call sys_exit_np()
- */
-void request_exit_np(struct task_struct *t);
-
-#else
-
 static inline int is_np(struct task_struct *t)
 {
         return tsk_rt(t)->kernel_np;
@@ -165,8 +153,6 @@ static inline int is_np(struct task_struct *t)
 
 #define  request_exit_np(t)
 
-#endif
-
 static inline int is_present(struct task_struct* t)
 {
         return t && tsk_rt(t)->present;
diff --git a/include/litmus/unistd.h b/include/litmus/unistd.h
index 5ef367f491..d83842d3e5 100644
--- a/include/litmus/unistd.h
+++ b/include/litmus/unistd.h
@@ -4,18 +4,16 @@
 #define __NR_set_rt_task_param  __LSC(0)
 #define __NR_get_rt_task_param  __LSC(1)
 #define __NR_sleep_next_period  __LSC(2)
-#define __NR_register_np_flag   __LSC(3)
-#define __NR_exit_np            __LSC(4)
-#define __NR_od_open            __LSC(5)
-#define __NR_od_close           __LSC(6)
-#define __NR_fmlp_down          __LSC(7)
-#define __NR_fmlp_up            __LSC(8)
-#define __NR_srp_down           __LSC(9)
-#define __NR_srp_up             __LSC(10)
-#define __NR_query_job_no       __LSC(11)
-#define __NR_wait_for_job_release __LSC(12)
-#define __NR_wait_for_ts_release __LSC(13)
-#define __NR_release_ts         __LSC(14)
-#define __NR_null_call          __LSC(15)
+#define __NR_od_open            __LSC(3)
+#define __NR_od_close           __LSC(4)
+#define __NR_fmlp_down          __LSC(5)
+#define __NR_fmlp_up            __LSC(6)
+#define __NR_srp_down           __LSC(7)
+#define __NR_srp_up             __LSC(8)
+#define __NR_query_job_no       __LSC(9)
+#define __NR_wait_for_job_release __LSC(10)
+#define __NR_wait_for_ts_release __LSC(11)
+#define __NR_release_ts         __LSC(12)
+#define __NR_null_call          __LSC(13)
 
-#define NR_litmus_syscalls 16
+#define NR_litmus_syscalls 14
diff --git a/litmus/Kconfig b/litmus/Kconfig
index f73a454c4f..90c9717cc5 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -2,19 +2,6 @@ menu "LITMUS^RT"
 
 menu "Real-Time Synchronization"
 
-config NP_SECTION
-        bool "Non-preemptive section support"
-        depends on !SPARC64
-        default n
-        help
-          Include support for flag-based non-preemptive section signaling
-          from userspace.
-
-          (currently broken on SPARC64)
-
-          Say Yes if you want FMLP short critical section  synchronization support.
-
-
 config SRP
         bool "Stack Resource Policy (SRP)"
         default n
@@ -25,7 +12,7 @@ config SRP
 
 config FMLP
         bool "FMLP support"
-        depends on NP_SECTION
+#       depends on NP_SECTION
         default n
         help
           Include support for deterministic multiprocessor real-time
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 3562322827..1afd41e394 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -332,161 +332,6 @@ void send_scheduler_signals(void)
 
 }
 
-#ifdef CONFIG_NP_SECTION
-
-static inline void np_mem_error(struct task_struct* t, const char* reason)
-{
-        if (t->state != TASK_DEAD && !(t->flags & PF_EXITING)) {
-                TRACE("np section: %s => %s/%d killed\n",
-                      reason, t->comm, t->pid);
-                force_scheduler_signal(t, SIGKILL);
-        }
-}
-
-/*      sys_register_np_flag() allows real-time tasks to register an
- *      np section indicator.
- *      returns 0      if the flag was successfully registered
- *      returns EINVAL if current task is not a real-time task
- *      returns EFAULT if *flag couldn't be written
- */
-asmlinkage long sys_register_np_flag(short __user *flag)
-{
-        int retval = -EINVAL;
-        short test_val = RT_PREEMPTIVE;
-
-        /* avoid races with the scheduler */
-        preempt_disable();
-        TRACE("reg_np_flag(%p) for %s/%d\n", flag,
-              current->comm, current->pid);
-
-        /* Let's first try to write to the address.
-         * That way it is initialized and any bugs
-         * involving dangling pointers will caught
-         * early.
-         * NULL indicates disabling np section support
-         * and should not be tested.
-         */
-        if (flag)
-          retval = poke_kernel_address(test_val, flag);
-        else
-          retval = 0;
-        TRACE("reg_np_flag: retval=%d\n", retval);
-        if (unlikely(0 != retval))
-                np_mem_error(current, "np flag: not writable");
-        else
-          /* the pointer is ok */
-          current->rt_param.np_flag = flag;
-
-        preempt_enable();
-        return retval;
-}
-
-
-void request_exit_np(struct task_struct *t)
-{
-        int ret;
-        short flag;
-
-        /* We can only do this if t is actually currently scheduled on this CPU
-         * because otherwise we are in the wrong address space. Thus make sure
-         * to check.
-         */
-        BUG_ON(t != current);
-
-        if (unlikely(!is_realtime(t) || !t->rt_param.np_flag)) {
-                TRACE_TASK(t, "request_exit_np(): BAD TASK!\n");
-                return;
-        }
-
-        flag = RT_EXIT_NP_REQUESTED;
-        ret  = poke_kernel_address(flag, t->rt_param.np_flag + 1);
-        TRACE("request_exit_np(%s/%d)\n", t->comm, t->pid);
-        if (unlikely(0 != ret))
-                np_mem_error(current, "request_exit_np(): flag not writable");
-
-}
-
-
-int is_np(struct task_struct* t)
-{
-        int ret;
-        unsigned short flag = 0x5858; /* = XX, looks nicer in debug*/
-
-        BUG_ON(t != current);
-
-        if (unlikely(t->rt_param.kernel_np))
-                return 1;
-        else if (unlikely(t->rt_param.np_flag == NULL) ||
-                 t->flags & PF_EXITING ||
-                 t->state == TASK_DEAD)
-                return 0;
-        else {
-                /* This is the tricky part. The process has registered a
-                 * non-preemptive section marker. We now need to check whether
-                 * it is set to to NON_PREEMPTIVE. Along the way we could
-                 * discover that the pointer points to an unmapped region (=>
-                 * kill the task) or that the location contains some garbage
-                 * value (=> also kill the task). Killing the task in any case
-                 * forces userspace to play nicely. Any bugs will be discovered
-                 * immediately.
-                 */
-                ret = probe_kernel_address(t->rt_param.np_flag, flag);
-                if (0 == ret && (flag == RT_NON_PREEMPTIVE ||
-                                 flag == RT_PREEMPTIVE))
-                return flag != RT_PREEMPTIVE;
-                else {
-                        /* either we could not read from the address or
-                         * it contained garbage => kill the process
-                         * FIXME: Should we cause a SEGFAULT instead?
-                         */
-                        TRACE("is_np: ret=%d flag=%c%c (%x)\n", ret,
-                              flag & 0xff, (flag >> 8) & 0xff, flag);
-                        np_mem_error(t, "is_np() could not read");
-                        return 0;
-                }
-        }
-}
-
-/*
- *      sys_exit_np() allows real-time tasks to signal that it left a
- *      non-preemptable section. It will be called after the kernel requested a
- *      callback in the preemption indicator flag.
- *      returns 0      if the signal was valid and processed.
- *      returns EINVAL if current task is not a real-time task
- */
-asmlinkage long sys_exit_np(void)
-{
-        int retval = -EINVAL;
-
-        TS_EXIT_NP_START;
-
-        if (!is_realtime(current))
-                goto out;
-
-        TRACE("sys_exit_np(%s/%d)\n", current->comm, current->pid);
-        /* force rescheduling so that we can be preempted */
-        set_tsk_need_resched(current);
-        retval = 0;
-      out:
-
-        TS_EXIT_NP_END;
-        return retval;
-}
-
-#else /* !CONFIG_NP_SECTION */
-
-asmlinkage long sys_register_np_flag(short __user *flag)
-{
-        return -ENOSYS;
-}
-
-asmlinkage long sys_exit_np(void)
-{
-        return -ENOSYS;
-}
-
-#endif /* CONFIG_NP_SECTION */
-
 
 /* sys_null_call() is only used for determining raw system call
  * overheads (kernel entry, kernel exit). It has no useful side effects.