2008-06-13 Joel Sherrill <joel.sherrill@oarcorp.com>

	* posix/include/rtems/posix/pthread.h, posix/src/pthread.c,
	posix/src/pthreadcreate.c, rtems/include/rtems.h, rtems/src/attr.c,
	sapi/include/confdefs.h, sapi/include/rtems/config.h,
	score/inline/rtems/score/stack.inl, score/src/isr.c,
	score/src/mpci.c, score/src/threadcreateidle.c,
	score/src/threadinitialize.c, score/src/threadstackallocate.c: Add
	ability for application to configure minimum stack size. Add
	RTEMS_CONFIGURED_MINIMUM_STACK_SIZE constant so user can clearly
	indicate they want the configured as opposed to the recommended
	minimum stack size.

14 files changed, 133 insertions, 37 deletions

diff --git a/cpukit/ChangeLog b/cpukit/ChangeLog
index 27be15eb9a..e7b48c37a8 100644
--- a/cpukit/ChangeLog
+++ b/cpukit/ChangeLog
@@ -1,3 +1,16 @@
+2008-06-13	Joel Sherrill <joel.sherrill@oarcorp.com>
+
+	* posix/include/rtems/posix/pthread.h, posix/src/pthread.c,
+	posix/src/pthreadcreate.c, rtems/include/rtems.h, rtems/src/attr.c,
+	sapi/include/confdefs.h, sapi/include/rtems/config.h,
+	score/inline/rtems/score/stack.inl, score/src/isr.c,
+	score/src/mpci.c, score/src/threadcreateidle.c,
+	score/src/threadinitialize.c, score/src/threadstackallocate.c: Add
+	ability for application to configure minimum stack size. Add
+	RTEMS_CONFIGURED_MINIMUM_STACK_SIZE constant so user can clearly
+	indicate they want the configured as opposed to the recommended
+	minimum stack size.
+
 2008-06-10	Chris Johns <chrisj@rtems.org>
 
 	* score/include/rtems/score/priority.h: Let the CPU define the
diff --git a/cpukit/posix/include/rtems/posix/pthread.h b/cpukit/posix/include/rtems/posix/pthread.h
index 6d0c739f0c..14eaf36c4c 100644
--- a/cpukit/posix/include/rtems/posix/pthread.h
+++ b/cpukit/posix/include/rtems/posix/pthread.h
@@ -27,9 +27,12 @@ extern "C" {
 #include <rtems/posix/config.h>
 #include <rtems/posix/threadsup.h>
 
-#define PTHREAD_MINIMUM_STACK_SIZE (STACK_MINIMUM_SIZE * 2)
+/**
+ *  The following sets the minimum stack size for POSIX threads.
+ */
+#define PTHREAD_MINIMUM_STACK_SIZE (_Stack_Minimum() * 2)
 
-/*
+/**
  *  The following defines the information control block used to manage
  *  this class of objects.
  */
diff --git a/cpukit/posix/src/pthread.c b/cpukit/posix/src/pthread.c
index 53126e2428..a19e2c069c 100644
--- a/cpukit/posix/src/pthread.c
+++ b/cpukit/posix/src/pthread.c
@@ -44,7 +44,7 @@
 const pthread_attr_t _POSIX_Threads_Default_attributes = {
   TRUE,                       /* is_initialized */
   NULL,                       /* stackaddr */
-  PTHREAD_MINIMUM_STACK_SIZE, /* stacksize */
+  0,                          /* stacksize -- will be adjusted to minimum */
   PTHREAD_SCOPE_PROCESS,      /* contentionscope */
   PTHREAD_INHERIT_SCHED,      /* inheritsched */
   SCHED_FIFO,                 /* schedpolicy */
diff --git a/cpukit/posix/src/pthreadcreate.c b/cpukit/posix/src/pthreadcreate.c
index 6eeda2da14..c579fb3e14 100644
--- a/cpukit/posix/src/pthreadcreate.c
+++ b/cpukit/posix/src/pthreadcreate.c
@@ -26,6 +26,16 @@
 #include <rtems/posix/time.h>
 #include <rtems/score/apimutex.h>
 
+static inline size_t _POSIX_Threads_Ensure_minimum_stack (
+  size_t size
+)
+{
+  if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
+    return size;
+  return PTHREAD_MINIMUM_STACK_SIZE;
+}
+
+
 int pthread_create(
   pthread_t              *thread,
   const pthread_attr_t   *attr,
@@ -54,11 +64,13 @@ int pthread_create(
     return EINVAL;
 
   /*
-   *  Core Thread Initialize insures we get the minimum amount of
+   *  Core Thread Initialize ensures we get the minimum amount of
    *  stack space if it is allowed to allocate it itself.
+   *
+   *  NOTE: If the user provides the stack we will let it drop below
+   *        twice the minimum.
    */
-
-  if ( the_attr->stackaddr && !_Stack_Is_enough( the_attr->stacksize ) )
+  if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
     return EINVAL;
 
 #if 0
@@ -184,7 +196,7 @@ int pthread_create(
     &_POSIX_Threads_Information,
     the_thread,
     the_attr->stackaddr,
-    the_attr->stacksize,
+    _POSIX_Threads_Ensure_minimum_stack(the_attr->stacksize),
     is_fp,
     core_priority,
     TRUE,                 /* preemptible */
diff --git a/cpukit/rtems/include/rtems.h b/cpukit/rtems/include/rtems.h
index 8eb91f12fa..537a6c8171 100644
--- a/cpukit/rtems/include/rtems.h
+++ b/cpukit/rtems/include/rtems.h
@@ -152,6 +152,12 @@ extern "C" {
 #define RTEMS_MINIMUM_STACK_SIZE  STACK_MINIMUM_SIZE
 
 /**
+ *  The following constant is used to specify that the task should
+ *  be created with the configured minimum stack size.
+ */
+#define RTEMS_CONFIGURED_MINIMUM_STACK_SIZE  0
+
+/**
  *  Constant for indefinite wait.  (actually an illegal interval)
  */
 #define RTEMS_NO_TIMEOUT  WATCHDOG_NO_TIMEOUT
diff --git a/cpukit/rtems/src/attr.c b/cpukit/rtems/src/attr.c
index 8b0b542441..2312d36bb5 100644
--- a/cpukit/rtems/src/attr.c
+++ b/cpukit/rtems/src/attr.c
@@ -21,7 +21,6 @@
 #include <rtems/score/stack.h>
 #include <rtems/rtems/modes.h>
 
-uint32_t   rtems_minimum_stack_size = STACK_MINIMUM_SIZE;
 uint32_t   rtems_interrupt_mask = RTEMS_INTERRUPT_MASK;
 
 rtems_attribute rtems_interrupt_level_attribute(
diff --git a/cpukit/sapi/include/confdefs.h b/cpukit/sapi/include/confdefs.h
index b60c03cc56..ac51b7726f 100644
--- a/cpukit/sapi/include/confdefs.h
+++ b/cpukit/sapi/include/confdefs.h
@@ -202,6 +202,13 @@ extern rtems_configuration_table        Configuration;
 #endif
 
 /**
+ *  By default, use the minimum stack size requested by this port.
+ */
+#ifndef CONFIGURE_MINIMUM_TASK_STACK_SIZE
+  #define CONFIGURE_MINIMUM_TASK_STACK_SIZE CPU_STACK_MINIMUM_SIZE
+#endif
+
+/**
  *  @brief Idle task stack size configuration
  *
  *  By default, the IDLE task will have a stack of minimum size.
@@ -211,7 +218,7 @@ extern rtems_configuration_table        Configuration;
   #ifdef BSP_IDLE_TASK_STACK_SIZE
     #define CONFIGURE_IDLE_TASK_STACK_SIZE BSP_IDLE_TASK_STACK_SIZE
   #else
-    #define CONFIGURE_IDLE_TASK_STACK_SIZE RTEMS_MINIMUM_STACK_SIZE
+    #define CONFIGURE_IDLE_TASK_STACK_SIZE CONFIGURE_MINIMUM_TASK_STACK_SIZE
   #endif
 #endif
 
@@ -225,7 +232,7 @@ extern rtems_configuration_table        Configuration;
   #ifdef BSP_INTERRUPT_STACK_SIZE
     #define CONFIGURE_INTERRUPT_STACK_SIZE BSP_INTERRUPT_STACK_SIZE
   #else
-    #define CONFIGURE_INTERRUPT_STACK_SIZE RTEMS_MINIMUM_STACK_SIZE
+    #define CONFIGURE_INTERRUPT_STACK_SIZE CONFIGURE_MINIMUM_TASK_STACK_SIZE
   #endif
 #endif
 
@@ -362,7 +369,7 @@ extern rtems_configuration_table        Configuration;
 #endif
 
 #ifndef CONFIGURE_INIT_TASK_STACK_SIZE
-  #define CONFIGURE_INIT_TASK_STACK_SIZE    RTEMS_MINIMUM_STACK_SIZE
+  #define CONFIGURE_INIT_TASK_STACK_SIZE    CONFIGURE_MINIMUM_TASK_STACK_SIZE
 #endif
 
 #ifndef CONFIGURE_INIT_TASK_PRIORITY
@@ -814,7 +821,7 @@ extern rtems_configuration_table        Configuration;
 
       #ifndef CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE
 	#define CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE \
-                (RTEMS_MINIMUM_STACK_SIZE * 2)
+                (CONFIGURE_MINIMUM_TASK_STACK_SIZE * 2)
       #endif
 
       #ifdef CONFIGURE_INIT
@@ -952,7 +959,8 @@ extern rtems_configuration_table        Configuration;
    * Ada tasks are allocated twice the minimum stack space.
    */
   #define CONFIGURE_ADA_TASKS_STACK \
-    (CONFIGURE_MAXIMUM_ADA_TASKS * (RTEMS_MINIMUM_STACK_SIZE + (6 * 1024)))
+    (CONFIGURE_MAXIMUM_ADA_TASKS * \
+      (CONFIGURE_MINIMUM_TASK_STACK_SIZE + (6 * 1024)))
 
 #else
   #define CONFIGURE_GNAT_MUTEXES           0
@@ -1034,7 +1042,8 @@ extern rtems_configuration_table        Configuration;
       #endif
 
       #ifndef CONFIGURE_ITRON_INIT_TASK_STACK_SIZE
-	#define CONFIGURE_ITRON_INIT_TASK_STACK_SIZE    RTEMS_MINIMUM_STACK_SIZE
+	#define CONFIGURE_ITRON_INIT_TASK_STACK_SIZE \
+                CONFIGURE_MINIMUM_TASK_STACK_SIZE
       #endif
 
       #ifdef CONFIGURE_INIT
@@ -1151,7 +1160,7 @@ extern rtems_configuration_table        Configuration;
  ( \
   _Configure_Object_RAM(_tasks, sizeof(Thread_Control)) + \
   ((_tasks) * \
-   (_Configure_From_workspace(STACK_MINIMUM_SIZE) + \
+   (_Configure_From_workspace(CONFIGURE_MINIMUM_TASK_STACK_SIZE) + \
     _Configure_From_workspace(sizeof(RTEMS_API_Control)) + \
     _Configure_From_workspace(CONFIGURE_MEMORY_PER_TASK_FOR_LIBC_REENTRANCY) + \
     _Configure_From_workspace(CONFIGURE_MEMORY_PER_TASK_FOR_POSIX_API) + \
@@ -1298,7 +1307,7 @@ extern rtems_configuration_table        Configuration;
 #define CONFIGURE_MEMORY_FOR_SYSTEM_OVERHEAD \
   ( \
     CONFIGURE_MEMORY_FOR_TASKS(1, 0) +              /* IDLE and stack */ \
-    (CONFIGURE_IDLE_TASK_STACK_SIZE - RTEMS_MINIMUM_STACK_SIZE) + \
+    (CONFIGURE_IDLE_TASK_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE) + \
     _Configure_From_workspace(                        /* Ready chains */ \
         ((PRIORITY_MAXIMUM+1) * sizeof(Chain_Control)) ) + \
     CONFIGURE_INTERRUPT_VECTOR_TABLE +           /* interrupt vectors */ \
@@ -1315,9 +1324,9 @@ extern rtems_configuration_table        Configuration;
  *  This accounts for any extra memory required by the Classic API
  *  Initialization Task.
  */
-#if (CONFIGURE_INIT_TASK_STACK_SIZE > RTEMS_MINIMUM_STACK_SIZE)
+#if (CONFIGURE_INIT_TASK_STACK_SIZE > CONFIGURE_MINIMUM_TASK_STACK_SIZE)
   #define CONFIGURE_INITIALIZATION_THREADS_STACKS_CLASSIC_PART \
-      (CONFIGURE_INIT_TASK_STACK_SIZE - RTEMS_MINIMUM_STACK_SIZE)
+      (CONFIGURE_INIT_TASK_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE)
 #else
   #define CONFIGURE_INITIALIZATION_THREADS_STACKS_CLASSIC_PART 0
 #endif
@@ -1327,9 +1336,9 @@ extern rtems_configuration_table        Configuration;
  *  Initialization Thread.
  */
 #if defined(RTEMS_POSIX_API) && \
-    (CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE > RTEMS_MINIMUM_STACK_SIZE)
+    (CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE > CONFIGURE_MINIMUM_TASK_STACK_SIZE)
   #define CONFIGURE_INITIALIZATION_THREADS_STACKS_POSIX_PART \
-      (CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE - RTEMS_MINIMUM_STACK_SIZE)
+    (CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE)
 #else
   #define CONFIGURE_INITIALIZATION_THREADS_STACKS_POSIX_PART 0
 #endif
@@ -1339,9 +1348,9 @@ extern rtems_configuration_table        Configuration;
  *  Initialization Task.
  */
 #if defined(RTEMS_ITRON_API) && \
-    (CONFIGURE_ITRON_INIT_TASK_STACK_SIZE > RTEMS_MINIMUM_STACK_SIZE)
+    (CONFIGURE_ITRON_INIT_TASK_STACK_SIZE > CONFIGURE_MINIMUM_TASK_STACK_SIZE)
   #define CONFIGURE_INITIALIZATION_THREADS_STACKS_ITRON_PART \
-      (CONFIGURE_ITRON_INIT_TASK_STACK_SIZE - RTEMS_MINIMUM_STACK_SIZE)
+      (CONFIGURE_ITRON_INIT_TASK_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE)
 #else
   #define CONFIGURE_INITIALIZATION_THREADS_STACKS_ITRON_PART 0
 #endif
@@ -1429,7 +1438,7 @@ extern rtems_configuration_table        Configuration;
      CONFIGURE_TOTAL_TASKS_AND_THREADS, CONFIGURE_TOTAL_TASKS_AND_THREADS) + \
    CONFIGURE_MEMORY_FOR_CLASSIC + \
    CONFIGURE_MEMORY_FOR_POSIX + \
-   (CONFIGURE_MAXIMUM_POSIX_THREADS * RTEMS_MINIMUM_STACK_SIZE ) + \
+   (CONFIGURE_MAXIMUM_POSIX_THREADS * CONFIGURE_MINIMUM_TASK_STACK_SIZE ) + \
    CONFIGURE_MEMORY_FOR_ITRON + \
    CONFIGURE_INITIALIZATION_THREADS_STACKS + \
    CONFIGURE_MEMORY_FOR_STATIC_EXTENSIONS + \
@@ -1500,6 +1509,16 @@ extern rtems_configuration_table        Configuration;
     };
   #endif
 
+  /** This variable specifies the minimum stack size for tasks in an RTEMS
+   *  application.
+   *
+   *  @note This is left as a simple uint32_t so it can be externed as
+   *        needed without requring being high enough logical to
+   *        include the full configuration table.
+   */
+  uint32_t rtems_minimum_stack_size = 
+    CONFIGURE_MINIMUM_TASK_STACK_SIZE;
+
   /**
    *  This is the primary Configuration Table for this application.
    */
diff --git a/cpukit/sapi/include/rtems/config.h b/cpukit/sapi/include/rtems/config.h
index 57b6720945..777a9c3402 100644
--- a/cpukit/sapi/include/rtems/config.h
+++ b/cpukit/sapi/include/rtems/config.h
@@ -109,10 +109,26 @@ typedef struct {
  *     + required number of each object type for each API configured
  */
 typedef struct {
+  /** This field specifies the base address of the RTEMS Workspace.
+   */
   void                          *work_space_start;
+
+  /** This field specifies the size in bytes of the RTEMS Workspace.
+   */
   uint32_t                       work_space_size;
+
+  /** This field specifies the maximum number of dynamically installed
+   *  used extensions.
+   */
   uint32_t                       maximum_extensions;
+
+  /** This field specifies the number of microseconds which elapse
+   *  between clock ticks.  This is the basis for RTEMS timing.
+   */
   uint32_t                       microseconds_per_tick;
+
+  /** This field specifies the number of ticks in each task's timeslice.
+   */
   uint32_t                       ticks_per_timeslice;
 
   /** This element points to the BSP's optional idle task which may override
diff --git a/cpukit/score/inline/rtems/score/stack.inl b/cpukit/score/inline/rtems/score/stack.inl
index cfa634df95..7726cf1a05 100644
--- a/cpukit/score/inline/rtems/score/stack.inl
+++ b/cpukit/score/inline/rtems/score/stack.inl
@@ -29,7 +29,6 @@
  *  size bytes of memory starting at starting_address have been
  *  reserved for a stack.
  */
-
 RTEMS_INLINE_ROUTINE void _Stack_Initialize (
   Stack_Control *the_stack,
   void          *starting_address,
@@ -41,15 +40,48 @@ RTEMS_INLINE_ROUTINE void _Stack_Initialize (
 }
 
 /**
+ *  This function returns the minimum stack size configured
+ *  for this application.
+ *
+ *  @return This method returns the minimum stack size;
+ */
+RTEMS_INLINE_ROUTINE uint32_t _Stack_Minimum (void)
+{
+  extern uint32_t rtems_minimum_stack_size;
+  return rtems_minimum_stack_size;
+}
+
+/**
  *  This function returns TRUE if size bytes is enough memory for
  *  a valid stack area on this processor, and FALSE otherwise.
+ *
+ *  @param[in] size is the stack size to check
+ *
+ *  @return This method returns TRUE if the stack is large enough.
  */
-
 RTEMS_INLINE_ROUTINE boolean _Stack_Is_enough (
   size_t size
 )
 {
-  return ( size >= STACK_MINIMUM_SIZE );
+  return ( size >= _Stack_Minimum() );
+}
+
+/**
+ *  This function returns the appropriate stack size given the requested
+ *  size.  If the requested size is below the minimum, then the minimum
+ *  configured stack size is returned.
+ *
+ *  @param[in] size is the stack size to check
+ *
+ *  @return This method returns the appropriate stack size.
+ */
+RTEMS_INLINE_ROUTINE size_t _Stack_Ensure_minimum (
+  size_t size
+)
+{
+  if ( size >= _Stack_Minimum() )
+    return size;
+  return _Stack_Minimum();
 }
 
 /**
diff --git a/cpukit/score/src/isr.c b/cpukit/score/src/isr.c
index d282ebecd6..e6d62a9366 100644
--- a/cpukit/score/src/isr.c
+++ b/cpukit/score/src/isr.c
@@ -48,7 +48,7 @@ void _ISR_Handler_initialization( void )
 
 #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )
 
-  if ( _Configuration_Table->interrupt_stack_size < STACK_MINIMUM_SIZE )
+  if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) )
     _Internal_error_Occurred(
       INTERNAL_ERROR_CORE,
       TRUE,
diff --git a/cpukit/score/src/mpci.c b/cpukit/score/src/mpci.c
index 058191530d..828ad766e5 100644
--- a/cpukit/score/src/mpci.c
+++ b/cpukit/score/src/mpci.c
@@ -114,7 +114,7 @@ void _MPCI_Create_server( void )
     &_Thread_Internal_information,
     _MPCI_Receive_server_tcb,
     NULL,        /* allocate the stack */
-    STACK_MINIMUM_SIZE +
+    _Stack_Minimum() + 
       CPU_MPCI_RECEIVE_SERVER_EXTRA_STACK +
       _Configuration_MP_table->extra_mpci_receive_server_stack,
     CPU_ALL_TASKS_ARE_FP,
diff --git a/cpukit/score/src/threadcreateidle.c b/cpukit/score/src/threadcreateidle.c
index 3eaff869cf..bcbfcf3039 100644
--- a/cpukit/score/src/threadcreateidle.c
+++ b/cpukit/score/src/threadcreateidle.c
@@ -64,9 +64,8 @@ void _Thread_Create_idle( void )
   if ( _Configuration_Table->idle_task )
     idle = _Configuration_Table->idle_task;
 
-  idle_task_stack_size =  _Configuration_Table->idle_task_stack_size;
-  if ( idle_task_stack_size < STACK_MINIMUM_SIZE )
-    idle_task_stack_size = STACK_MINIMUM_SIZE;
+  idle_task_stack_size = 
+    _Stack_Ensure_minimum( _Configuration_Table->idle_task_stack_size );
 
   /*
    *  This is only called during initialization and we better be sure
diff --git a/cpukit/score/src/threadinitialize.c b/cpukit/score/src/threadinitialize.c
index 2956cf42ed..eb4df83e50 100644
--- a/cpukit/score/src/threadinitialize.c
+++ b/cpukit/score/src/threadinitialize.c
@@ -75,10 +75,8 @@ boolean _Thread_Initialize(
 
 
   if ( !stack_area ) {
-    if ( !_Stack_Is_enough( stack_size ) )
-      actual_stack_size = STACK_MINIMUM_SIZE;
-    else
-      actual_stack_size = stack_size;
+
+    actual_stack_size = _Stack_Ensure_minimum( stack_size );
 
     actual_stack_size = _Thread_Stack_Allocate( the_thread, actual_stack_size );
 
diff --git a/cpukit/score/src/threadstackallocate.c b/cpukit/score/src/threadstackallocate.c
index b0b131bfc8..86ae78c4cc 100644
--- a/cpukit/score/src/threadstackallocate.c
+++ b/cpukit/score/src/threadstackallocate.c
@@ -49,8 +49,7 @@ size_t _Thread_Stack_Allocate(
   void *stack_addr = 0;
   size_t the_stack_size = stack_size;
 
-  if ( !_Stack_Is_enough( the_stack_size ) )
-    the_stack_size = STACK_MINIMUM_SIZE;
+  the_stack_size = _Stack_Ensure_minimum( stack_size );
 
   /*
    * Call ONLY the CPU table stack allocate hook, _or_ the