Improve internal priority setting logi

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1587 42af7a65-404d-4744-a932-0658087f49c3

5 files changed, 302 insertions, 142 deletions

diff --git a/nuttx/sched/Makefile b/nuttx/sched/Makefile
index 090473bba..89da69f14 100644
--- a/nuttx/sched/Makefile
+++ b/nuttx/sched/Makefile
@@ -48,7 +48,7 @@ TSK_SRCS	= task_create.c task_init.c task_setup.c task_activate.c \
 		  sched_addreadytorun.c sched_removereadytorun.c sched_addprioritized.c \
 		  sched_mergepending.c sched_addblocked.c sched_removeblocked.c \
 		  sched_free.c sched_gettcb.c sched_releasetcb.c
-SCHED_SRCS	= sched_setparam.c sched_getparam.c \
+SCHED_SRCS	= sched_setparam.c sched_settcbprio.c sched_getparam.c \
 		  sched_setscheduler.c sched_getscheduler.c \
 		  sched_yield.c sched_rrgetinterval.c sched_foreach.c \
 		  sched_getprioritymax.c sched_getprioritymin.c \
diff --git a/nuttx/sched/os_internal.h b/nuttx/sched/os_internal.h
index a9b1bfc85..e6e1849f4 100644
--- a/nuttx/sched/os_internal.h
+++ b/nuttx/sched/os_internal.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * sched/os_internal.h
  *
- *   Copyright (C) 2007-2009Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -252,6 +252,7 @@ extern boolean sched_addprioritized(FAR _TCB *newTcb,
 extern boolean sched_mergepending(void);
 extern void    sched_addblocked(FAR _TCB *btcb, tstate_t task_state);
 extern void    sched_removeblocked(FAR _TCB *btcb);
+extern int sched_settcbprio(FAR _TCB *tcb, int sched_priority);
 extern FAR _TCB *sched_gettcb(pid_t pid);
 
 #if CONFIG_NFILE_DESCRIPTORS > 0 || CONFIG_NSOCKET_DESCRIPTORS > 0
diff --git a/nuttx/sched/sched_setparam.c b/nuttx/sched/sched_setparam.c
index 20b0d6831..4bd676087 100644
--- a/nuttx/sched/sched_setparam.c
+++ b/nuttx/sched/sched_setparam.c
@@ -78,9 +78,9 @@
  * Description:
  *   This function sets the priority of a specified task.
  *
- *   NOTE: Setting a task's priority to the same value has the
- *   similar effect to sched_yield() -- The task will be moved to
- *   after all other tasks with the same priority.
+ *   NOTE: Setting a task's priority to the same value has a similar
+ *   effect to sched_yield() -- The task will be moved to  after all other
+ *   tasks with the same priority.
  *
  * Inputs:
  *   pid - the task ID of the task to reprioritize.  If pid is
@@ -106,9 +106,7 @@ int sched_setparam(pid_t pid, const struct sched_param *param)
 {
   FAR _TCB  *rtcb;
   FAR _TCB  *tcb;
-  tstate_t   task_state;
-  irqstate_t saved_state;
-  int        sched_priority = param->sched_priority;
+  int        ret;
 
   /* Verify that the requested priority is in the valid range */
 
@@ -116,7 +114,7 @@ int sched_setparam(pid_t pid, const struct sched_param *param)
       param->sched_priority < SCHED_PRIORITY_MIN || 
       param->sched_priority > SCHED_PRIORITY_MAX)
     {
-      *get_errno_ptr() = EINVAL;
+      errno = EINVAL;
       return ERROR;
     }
 
@@ -143,136 +141,15 @@ int sched_setparam(pid_t pid, const struct sched_param *param)
         {
           /* No task with this pid was found */
 
-          *get_errno_ptr() = ESRCH;
+          errno = ESRCH;
           sched_unlock();
           return ERROR;
         }
     }
 
-  /* We need to assure that there there is no interrupt activity while
-   * performing the following.
-   */
-
-  saved_state = irqsave();
-
-  /* There are four cases that must be considered: */
-
-  task_state = tcb->task_state;
-  switch (task_state)
-    {
-       /* CASE 1. The task is running or ready-to-run and a context switch
-        * may be caused by the re-prioritization 
-        */
-
-       case TSTATE_TASK_RUNNING:
-
-         /* A context switch will occur if the new priority of the running
-          * task becomes less than OR EQUAL TO the next highest priority
-          * ready to run task.
-          */
-
-         if (sched_priority <= tcb->flink->sched_priority)
-           {
-             /* A context switch will occur. */
-
-             up_reprioritize_rtr(tcb, (ubyte)sched_priority);
-           }
-
-         /* Otherwise, we can just change priority since it has no effect */
-
-         else
-           {
-             /* Change the task priority */
-
-             tcb->sched_priority = (ubyte)sched_priority;
-#ifdef CONFIG_PRIORITY_INHERITANCE
-             tcb->base_priority  = (ubyte)sched_priority;
-#endif
-           }
-         break;
-
-       /* CASE 2. The task is running or ready-to-run and a context switch
-        * may be caused by the re-prioritization
-        */
-
-       case TSTATE_TASK_READYTORUN:
-
-         /* A context switch will occur if the new priority of the ready-to
-          * run task is (strictly) greater than the current running task 
-          */
-
-         if (sched_priority > rtcb->sched_priority)
-           {
-             /* A context switch will occur. */
-
-             up_reprioritize_rtr(tcb, (ubyte)sched_priority);
-           }
-
-         /* Otherwise, we can just change priority and re-schedule (since it
-          * have no other effect).
-          */
-
-         else
-           {
-             /* Remove the TCB from the ready-to-run task list */
-
-             ASSERT(!sched_removereadytorun(tcb));
-
-             /* Change the task priority */
-
-             tcb->sched_priority = (ubyte)sched_priority;
-#ifdef CONFIG_PRIORITY_INHERITANCE
-             tcb->base_priority  = (ubyte)sched_priority;
-#endif
-
-             /* Put it back into the ready-to-run task list */
-
-             ASSERT(!sched_addreadytorun(tcb));
-           }
-         break;
-
-       /* CASE 3. The task is not in the ready to run list.  Changing its
-        * Priority cannot effect the currently executing task.
-        */
-
-     default:
-        /* CASE 3a. The task resides in a prioritized list. */
-
-        if (g_tasklisttable[task_state].prioritized)
-          {
-            /* Remove the TCB from the prioritized task list */
-
-            dq_rem((FAR dq_entry_t*)tcb, (FAR dq_queue_t*)g_tasklisttable[task_state].list);
-
-            /* Change the task priority */
-
-            tcb->sched_priority = (ubyte)sched_priority;
-#ifdef CONFIG_PRIORITY_INHERITANCE
-            tcb->base_priority  = (ubyte)sched_priority;
-#endif
-
-            /* Put it back into the prioritized list at the correct
-             * position
-             */
-
-            sched_addprioritized(tcb, (FAR dq_queue_t*)g_tasklisttable[task_state].list);
-          }
-
-        /* CASE 3b. The task resides in a non-prioritized list. */
-
-        else
-          {
-            /* Just change the task's priority */
-
-            tcb->sched_priority = (ubyte)sched_priority;
-#ifdef CONFIG_PRIORITY_INHERITANCE
-            tcb->base_priority  = (ubyte)sched_priority;
-#endif
-          }
-        break;
-    }
+ /* Then perform the reprioritization */
 
-  irqrestore(saved_state);
-  sched_unlock();
-  return OK;
+ ret = sched_settcbprio(tcb, param->sched_priority);
+ sched_unlock();
+ return ret;
 }
diff --git a/nuttx/sched/sched_settcbprio.c b/nuttx/sched/sched_settcbprio.c
new file mode 100644
index 000000000..28810ce5d
--- /dev/null
+++ b/nuttx/sched/sched_settcbprio.c
@@ -0,0 +1,285 @@
+/****************************************************************************
+ * sched/sched_settcbprio.c
+ *
+ *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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
+ * COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <sys/types.h>
+#include <sched.h>
+#include <errno.h>
+#include <nuttx/arch.h>
+#include "os_internal.h"
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Type Declarations
+ ****************************************************************************/
+
+/****************************************************************************
+ * Global Variables
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Variables
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name:  sched_settcbprio
+ *
+ * Description:
+ *   This function sets the priority of a specified task.
+ *
+ *   NOTE: Setting a task's priority to the same value has a similar
+ *   effect to sched_yield() -- The task will be moved to  after all other
+ *   tasks with the same priority.
+ *
+ * Inputs:
+ *   tcb - the TCB of task to reprioritize.
+ *   sched_priority - The new task priority
+ *
+ * Return Value:
+ *   On success, sched_setparam() returns 0 (OK). On error, -1
+ *  (ERROR) is returned, and errno is set appropriately.
+ *
+ *  EINVAL The parameter 'param' is invalid or does not make
+ *         sense for the current scheduling policy.
+ *  EPERM  The calling task does not have appropriate privileges.
+ *  ESRCH  The task whose ID is pid could not be found.
+ *
+ * Assumptions:
+ *
+ ****************************************************************************/
+
+int sched_settcbprio(FAR _TCB *tcb, int sched_priority)
+{
+  FAR _TCB  *rtcb = (FAR _TCB*)g_readytorun.head;
+  tstate_t   task_state;
+  irqstate_t saved_state;
+
+  /* We need to assure that there there is no interrupt activity while
+   * performing the following.
+   */
+
+  saved_state = irqsave();
+
+  /* There are four cases that must be considered: */
+
+  task_state = tcb->task_state;
+  switch (task_state)
+    {
+       /* CASE 1. The task is running or ready-to-run and a context switch
+        * may be caused by the re-prioritization 
+        */
+
+       case TSTATE_TASK_RUNNING:
+
+         /* A context switch will occur if the new priority of the running
+          * task becomes less than OR EQUAL TO the next highest priority
+          * ready to run task.
+          */
+
+         if (sched_priority <= tcb->flink->sched_priority)
+           {
+             /* A context switch will occur. */
+
+             up_reprioritize_rtr(tcb, (ubyte)sched_priority);
+           }
+
+         /* Otherwise, we can just change priority since it has no effect */
+
+         else
+           {
+             /* Change the task priority */
+
+             tcb->sched_priority = (ubyte)sched_priority;
+#ifdef CONFIG_PRIORITY_INHERITANCE
+             tcb->base_priority  = (ubyte)sched_priority;
+#endif
+           }
+         break;
+
+       /* CASE 2. The task is running or ready-to-run and a context switch
+        * may be caused by the re-prioritization
+        */
+
+       case TSTATE_TASK_READYTORUN:
+
+         /* A context switch will occur if the new priority of the ready-to
+          * run task is (strictly) greater than the current running task 
+          */
+
+         if (sched_priority > rtcb->sched_priority)
+           {
+             /* A context switch will occur. */
+
+             up_reprioritize_rtr(tcb, (ubyte)sched_priority);
+           }
+
+         /* Otherwise, we can just change priority and re-schedule (since it
+          * have no other effect).
+          */
+
+         else
+           {
+             /* Remove the TCB from the ready-to-run task list */
+
+             ASSERT(!sched_removereadytorun(tcb));
+
+             /* Change the task priority */
+
+             tcb->sched_priority = (ubyte)sched_priority;
+#ifdef CONFIG_PRIORITY_INHERITANCE
+             tcb->base_priority  = (ubyte)sched_priority;
+#endif
+
+             /* Put it back into the ready-to-run task list */
+
+             ASSERT(!sched_addreadytorun(tcb));
+           }
+         break;
+
+       /* CASE 3. The task is not in the ready to run list.  Changing its
+        * Priority cannot effect the currently executing task.
+        */
+
+     default:
+        /* CASE 3a. The task resides in a prioritized list. */
+
+        if (g_tasklisttable[task_state].prioritized)
+          {
+            /* Remove the TCB from the prioritized task list */
+
+            dq_rem((FAR dq_entry_t*)tcb, (FAR dq_queue_t*)g_tasklisttable[task_state].list);
+
+            /* Change the task priority */
+
+            tcb->sched_priority = (ubyte)sched_priority;
+#ifdef CONFIG_PRIORITY_INHERITANCE
+            tcb->base_priority  = (ubyte)sched_priority;
+#endif
+
+            /* Put it back into the prioritized list at the correct
+             * position
+             */
+
+            sched_addprioritized(tcb, (FAR dq_queue_t*)g_tasklisttable[task_state].list);
+          }
+
+        /* CASE 3b. The task resides in a non-prioritized list. */
+
+        else
+          {
+            /* Just change the task's priority */
+
+            tcb->sched_priority = (ubyte)sched_priority;
+#ifdef CONFIG_PRIORITY_INHERITANCE
+            tcb->base_priority  = (ubyte)sched_priority;
+#endif
+          }
+        break;
+    }
+
+  irqrestore(saved_state);
+  return OK;
+}
+
+int sched_setparam(pid_t pid, const struct sched_param *param)
+{
+  FAR _TCB  *rtcb;
+  FAR _TCB  *tcb;
+  int        ret;
+
+  /* Verify that the requested priority is in the valid range */
+
+  if (!param ||
+      param->sched_priority < SCHED_PRIORITY_MIN || 
+      param->sched_priority > SCHED_PRIORITY_MAX)
+    {
+      errno = EINVAL;
+      return ERROR;
+    }
+
+  /* Prohibit modifications to the head of the ready-to-run task
+   * list while adjusting the priority
+   */
+
+  sched_lock();
+
+  /* Check if the task to reprioritize is the calling task */
+
+  rtcb = (FAR _TCB*)g_readytorun.head;
+  if (pid == 0 || pid == rtcb->pid)
+    {
+      tcb = rtcb;
+    }
+
+  /* The pid is not the calling task, we will have to search for it */
+
+  else
+    {
+      tcb = sched_gettcb(pid);
+      if (!tcb)
+        {
+          /* No task with this pid was found */
+
+          errno = ESRCH;
+          sched_unlock();
+          return ERROR;
+        }
+    }
+
+ /* Then perform the reprioritization */
+
+ ret = sched_settcbprio(tcb, param->sched_priority);
+ sched_unlock();
+ return ret;
+}
diff --git a/nuttx/sched/sem_wait.c b/nuttx/sched/sem_wait.c
index 0f8fd2716..62c549cee 100644
--- a/nuttx/sched/sem_wait.c
+++ b/nuttx/sched/sem_wait.c
@@ -110,7 +110,7 @@ int sem_wait(FAR sem_t *sem)
 
   /* Assume any errors reported are due to invalid arguments. */
 
-  *get_errno_ptr() = EINVAL;
+  errno = EINVAL;
 
   if (sem)
     {
@@ -180,17 +180,14 @@ int sem_wait(FAR sem_t *sem)
                * sched_setparam() should set both.
                */
 
-              struct sched_param sparam;
               int base_priority = htcb->base_priority;
-
-              sparam.sched_priority = rtcb->sched_priority;
-              (void)sched_setparam(htcb->pid, &sparam);
+              (void)sched_settcbprio(htcb, rtcb->sched_priority);
               htcb->base_priority = base_priority;
             }
 #endif
           /* Add the TCB to the prioritized semaphore wait queue */
 
-          *get_errno_ptr() = 0;
+          errno = 0;
           up_block_task(rtcb, TSTATE_WAIT_SEM);
 
 #ifdef CONFIG_PRIORITY_INHERITANCE
@@ -202,7 +199,7 @@ int sem_wait(FAR sem_t *sem)
            * be examining the errno value.
            */
 
-          if (*get_errno_ptr() != EINTR)
+          if (errno != EINTR)
             {
               /* We hold the semaphore */