From 020cc2248e07c97903db27a55122b578b528cb15 Mon Sep 17 00:00:00 2001 From: patacongo Date: Wed, 20 Mar 2013 18:22:21 +0000 Subject: [PATCH] Change prototypes of up_create_stack and up_release_stack to include a task type parameter git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5765 42af7a65-404d-4744-a932-0658087f49c3 --- arch/arm/src/common/up_createstack.c | 40 ++++++++++++++------ arch/arm/src/common/up_releasestack.c | 28 ++++++++++++-- arch/arm/src/common/up_usestack.c | 23 ++++++++---- arch/arm/src/common/up_vfork.c | 3 +- arch/avr/src/avr/up_createstack.c | 38 +++++++++++++------ arch/avr/src/avr/up_usestack.c | 24 ++++++++---- arch/avr/src/avr32/up_createstack.c | 38 +++++++++++++------ arch/avr/src/avr32/up_usestack.c | 21 +++++++---- arch/avr/src/common/up_releasestack.c | 28 ++++++++++++-- arch/hc/src/common/up_createstack.c | 38 +++++++++++++------ arch/hc/src/common/up_releasestack.c | 24 +++++++++++- arch/hc/src/common/up_usestack.c | 26 ++++++++----- arch/mips/src/common/up_createstack.c | 38 +++++++++++++------ arch/mips/src/common/up_releasestack.c | 28 ++++++++++++-- arch/mips/src/common/up_usestack.c | 21 +++++++---- arch/mips/src/mips32/up_vfork.c | 3 +- arch/rgmp/src/nuttx.c | 4 +- arch/sh/src/common/up_createstack.c | 38 +++++++++++++------ arch/sh/src/common/up_releasestack.c | 28 ++++++++++++-- arch/sh/src/common/up_usestack.c | 21 +++++++---- arch/sim/src/up_createstack.c | 39 +++++++++++++------ arch/sim/src/up_releasestack.c | 28 ++++++++++++-- arch/sim/src/up_usestack.c | 21 +++++++---- arch/x86/src/i486/up_createstack.c | 38 +++++++++++++------ arch/x86/src/i486/up_releasestack.c | 24 +++++++++++- arch/x86/src/i486/up_usestack.c | 24 ++++++++---- arch/z16/src/common/up_createstack.c | 38 +++++++++++++------ arch/z16/src/common/up_releasestack.c | 52 ++++++++++++++++++-------- arch/z16/src/common/up_usestack.c | 45 ++++++++++++---------- arch/z80/src/common/up_createstack.c | 38 +++++++++++++------ arch/z80/src/common/up_releasestack.c | 52 ++++++++++++++++++-------- arch/z80/src/common/up_usestack.c | 45 ++++++++++++---------- 32 files changed, 694 insertions(+), 262 deletions(-) diff --git a/arch/arm/src/common/up_createstack.c b/arch/arm/src/common/up_createstack.c index efa0e0a157..65eb91159b 100644 --- a/arch/arm/src/common/up_createstack.c +++ b/arch/arm/src/common/up_createstack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/arm/src/common/up_createstack.c * - * Copyright (C) 2007-2012 Gregory Nutt. All rights reserved. + * Copyright (C) 2007-2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -111,24 +111,40 @@ static void *memset32(void *s, uint32_t c, size_t n) * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/arm/src/common/up_releasestack.c b/arch/arm/src/common/up_releasestack.c index 94311b20c3..711022f93e 100644 --- a/arch/arm/src/common/up_releasestack.c +++ b/arch/arm/src/common/up_releasestack.c @@ -62,12 +62,34 @@ * Name: up_release_stack * * Description: - * A task has been stopped. Free all stack - * related resources retained int the defunct TCB. + * A task has been stopped. Free all stack related resources retained in + * the defunct TCB. + * + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None * ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/arm/src/common/up_usestack.c b/arch/arm/src/common/up_usestack.c index 57eb1d36ea..a141006bbd 100644 --- a/arch/arm/src/common/up_usestack.c +++ b/arch/arm/src/common/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/arm/src/common/up_usestack.c * - * Copyright (C) 2007-2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2007-2009, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -92,20 +92,27 @@ * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB - * using pre-allocated stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, + * + * - adj_stack_size: Stack size after adjustment for hardware, * processor, etc. This value is retained only for debug * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/arm/src/common/up_vfork.c b/arch/arm/src/common/up_vfork.c index 6340cb3b8a..03fb09b2f1 100644 --- a/arch/arm/src/common/up_vfork.c +++ b/arch/arm/src/common/up_vfork.c @@ -162,7 +162,8 @@ pid_t up_vfork(const struct vfork_s *context) /* Allocate the stack for the TCB */ - ret = up_create_stack((FAR struct tcb_s *)child, stacksize); + ret = up_create_stack((FAR struct tcb_s *)child, stacksize, + parent->flags & TCB_FLAG_TTYPE_MASK); if (ret != OK) { sdbg("up_create_stack failed: %d\n", ret); diff --git a/arch/avr/src/avr/up_createstack.c b/arch/avr/src/avr/up_createstack.c index 1eb56f918e..60f6dceec9 100644 --- a/arch/avr/src/avr/up_createstack.c +++ b/arch/avr/src/avr/up_createstack.c @@ -70,24 +70,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/avr/src/avr/up_usestack.c b/arch/avr/src/avr/up_usestack.c index 22bdcf84e1..ebd911fb25 100644 --- a/arch/avr/src/avr/up_usestack.c +++ b/arch/avr/src/avr/up_usestack.c @@ -67,18 +67,26 @@ * * Description: * Setup up stack-related information in the TCB using pre-allocated stack - * memory + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, - * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of - * the stack pointer. + * + * - adj_stack_size: Stack size after adjustment for hardware, + * processor, etc. This value is retained only for debug + * purposes. + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/avr/src/avr32/up_createstack.c b/arch/avr/src/avr32/up_createstack.c index 5d49f49778..da7e8788c5 100644 --- a/arch/avr/src/avr32/up_createstack.c +++ b/arch/avr/src/avr32/up_createstack.c @@ -69,24 +69,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/avr/src/avr32/up_usestack.c b/arch/avr/src/avr32/up_usestack.c index 43dc6bfe9c..86cdc2de40 100644 --- a/arch/avr/src/avr32/up_usestack.c +++ b/arch/avr/src/avr32/up_usestack.c @@ -65,20 +65,27 @@ * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB - * using pre-allocated stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, + * + * - adj_stack_size: Stack size after adjustment for hardware, * processor, etc. This value is retained only for debug * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/avr/src/common/up_releasestack.c b/arch/avr/src/common/up_releasestack.c index afce3261db..7d3e6f28c2 100644 --- a/arch/avr/src/common/up_releasestack.c +++ b/arch/avr/src/common/up_releasestack.c @@ -62,12 +62,34 @@ * Name: up_release_stack * * Description: - * A task has been stopped. Free all stack - * related resources retained int the defunct TCB. + * A task has been stopped. Free all stack related resources retained in + * the defunct TCB. + * + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None * ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/hc/src/common/up_createstack.c b/arch/hc/src/common/up_createstack.c index d5d5a853a6..a8b192c4bc 100644 --- a/arch/hc/src/common/up_createstack.c +++ b/arch/hc/src/common/up_createstack.c @@ -66,24 +66,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/hc/src/common/up_releasestack.c b/arch/hc/src/common/up_releasestack.c index f6eaec982f..f8c2fa142d 100644 --- a/arch/hc/src/common/up_releasestack.c +++ b/arch/hc/src/common/up_releasestack.c @@ -66,9 +66,31 @@ * A task has been stopped. Free all stack related resources retained in * the defunct TCB. * + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None + * ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/hc/src/common/up_usestack.c b/arch/hc/src/common/up_usestack.c index f23677be52..7f3c8fc669 100644 --- a/arch/hc/src/common/up_usestack.c +++ b/arch/hc/src/common/up_usestack.c @@ -64,19 +64,27 @@ * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB using pre-allocated - * stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, etc. - * This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of the - * stack pointer. + * + * - adj_stack_size: Stack size after adjustment for hardware, + * processor, etc. This value is retained only for debug + * purposes. + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/mips/src/common/up_createstack.c b/arch/mips/src/common/up_createstack.c index e4689fc7c9..b228e80619 100644 --- a/arch/mips/src/common/up_createstack.c +++ b/arch/mips/src/common/up_createstack.c @@ -87,24 +87,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/mips/src/common/up_releasestack.c b/arch/mips/src/common/up_releasestack.c index d507c3b7b4..3ce46bebdc 100644 --- a/arch/mips/src/common/up_releasestack.c +++ b/arch/mips/src/common/up_releasestack.c @@ -62,12 +62,34 @@ * Name: up_release_stack * * Description: - * A task has been stopped. Free all stack - * related resources retained int the defunct TCB. + * A task has been stopped. Free all stack related resources retained in + * the defunct TCB. + * + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None * ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/mips/src/common/up_usestack.c b/arch/mips/src/common/up_usestack.c index 208c15bc04..fe1d27818d 100644 --- a/arch/mips/src/common/up_usestack.c +++ b/arch/mips/src/common/up_usestack.c @@ -65,20 +65,27 @@ * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB - * using pre-allocated stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, + * + * - adj_stack_size: Stack size after adjustment for hardware, * processor, etc. This value is retained only for debug * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/mips/src/mips32/up_vfork.c b/arch/mips/src/mips32/up_vfork.c index 3714cfac76..15fd328129 100644 --- a/arch/mips/src/mips32/up_vfork.c +++ b/arch/mips/src/mips32/up_vfork.c @@ -167,7 +167,8 @@ pid_t up_vfork(const struct vfork_s *context) /* Allocate the stack for the TCB */ - ret = up_create_stack((FAR struct tcb_s *)child, stacksize); + ret = up_create_stack((FAR struct tcb_s *)child, stacksize, + parent->flags & TCB_FLAG_TTYPE_MASK); if (ret != OK) { sdbg("up_create_stack failed: %d\n", ret); diff --git a/arch/rgmp/src/nuttx.c b/arch/rgmp/src/nuttx.c index 0a13401c20..3dc5310062 100644 --- a/arch/rgmp/src/nuttx.c +++ b/arch/rgmp/src/nuttx.c @@ -111,7 +111,7 @@ void up_allocate_heap(void **heap_start, size_t *heap_size) *heap_size = KERNBASE + kmem_size - (uint32_t)boot_freemem; } -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { int ret = ERROR; size_t *adj_stack_ptr; @@ -158,7 +158,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) return OK; } -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { kufree(dtcb->stack_alloc_ptr); diff --git a/arch/sh/src/common/up_createstack.c b/arch/sh/src/common/up_createstack.c index 9abc05f76d..3ffdc30509 100644 --- a/arch/sh/src/common/up_createstack.c +++ b/arch/sh/src/common/up_createstack.c @@ -66,24 +66,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/sh/src/common/up_releasestack.c b/arch/sh/src/common/up_releasestack.c index a8b9d7769d..8325781187 100644 --- a/arch/sh/src/common/up_releasestack.c +++ b/arch/sh/src/common/up_releasestack.c @@ -62,12 +62,34 @@ * Name: up_release_stack * * Description: - * A task has been stopped. Free all stack - * related resources retained int the defunct TCB. + * A task has been stopped. Free all stack related resources retained in + * the defunct TCB. + * + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None * ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/sh/src/common/up_usestack.c b/arch/sh/src/common/up_usestack.c index 1cc383a91d..7c2b9586ea 100644 --- a/arch/sh/src/common/up_usestack.c +++ b/arch/sh/src/common/up_usestack.c @@ -65,20 +65,27 @@ * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB - * using pre-allocated stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, + * + * - adj_stack_size: Stack size after adjustment for hardware, * processor, etc. This value is retained only for debug * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/sim/src/up_createstack.c b/arch/sim/src/up_createstack.c index a6ebcc5fa0..fe9986e65f 100644 --- a/arch/sim/src/up_createstack.c +++ b/arch/sim/src/up_createstack.c @@ -67,25 +67,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup - * up stack-related information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, - * processor, etc. This value is retained only for debug - * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The - * initial value of the stack pointer. + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, + * etc. This value is retained only for debug purposes. + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this much + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { int ret = ERROR; diff --git a/arch/sim/src/up_releasestack.c b/arch/sim/src/up_releasestack.c index c1e12ca00e..56413f3418 100644 --- a/arch/sim/src/up_releasestack.c +++ b/arch/sim/src/up_releasestack.c @@ -64,12 +64,34 @@ * Name: up_release_stack * * Description: - * A task has been stopped. Free all stack - * related resources retained int the defunct TCB. + * A task has been stopped. Free all stack related resources retained in + * the defunct TCB. + * + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None * ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/sim/src/up_usestack.c b/arch/sim/src/up_usestack.c index afa4193641..af2d8121da 100644 --- a/arch/sim/src/up_usestack.c +++ b/arch/sim/src/up_usestack.c @@ -64,20 +64,27 @@ * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB - * using pre-allocated stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, + * + * - adj_stack_size: Stack size after adjustment for hardware, * processor, etc. This value is retained only for debug * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/x86/src/i486/up_createstack.c b/arch/x86/src/i486/up_createstack.c index 927abcf2e2..bcce5fdcc4 100644 --- a/arch/x86/src/i486/up_createstack.c +++ b/arch/x86/src/i486/up_createstack.c @@ -68,24 +68,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/x86/src/i486/up_releasestack.c b/arch/x86/src/i486/up_releasestack.c index 38a2dbfe81..0aa43ce58c 100644 --- a/arch/x86/src/i486/up_releasestack.c +++ b/arch/x86/src/i486/up_releasestack.c @@ -65,9 +65,31 @@ * A task has been stopped. Free all stack related resources retained in * the defunct TCB. * + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None + * ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/x86/src/i486/up_usestack.c b/arch/x86/src/i486/up_usestack.c index 8865a9e3fc..f972d89506 100644 --- a/arch/x86/src/i486/up_usestack.c +++ b/arch/x86/src/i486/up_usestack.c @@ -66,18 +66,26 @@ * * Description: * Setup up stack-related information in the TCB using pre-allocated stack - * memory + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, - * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of - * the stack pointer. + * + * - adj_stack_size: Stack size after adjustment for hardware, + * processor, etc. This value is retained only for debug + * purposes. + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. + * + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. * ****************************************************************************/ diff --git a/arch/z16/src/common/up_createstack.c b/arch/z16/src/common/up_createstack.c index fcbf90bfec..d523181692 100644 --- a/arch/z16/src/common/up_createstack.c +++ b/arch/z16/src/common/up_createstack.c @@ -67,24 +67,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/z16/src/common/up_releasestack.c b/arch/z16/src/common/up_releasestack.c index f661869258..84cc4be7d3 100644 --- a/arch/z16/src/common/up_releasestack.c +++ b/arch/z16/src/common/up_releasestack.c @@ -1,4 +1,4 @@ -/************************************************************ +/**************************************************************************** * common/up_releasestack.c * * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved. @@ -31,11 +31,11 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Included Files - ************************************************************/ + ****************************************************************************/ #include @@ -46,28 +46,50 @@ #include "os_internal.h" #include "up_internal.h" -/************************************************************ +/**************************************************************************** * Private Types - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Private Function Prototypes - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Global Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Name: up_release_stack * * Description: - * A task has been stopped. Free all stack - * related resources retained int the defunct TCB. + * A task has been stopped. Free all stack related resources retained in + * the defunct TCB. * - ************************************************************/ + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None + * + ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/z16/src/common/up_usestack.c b/arch/z16/src/common/up_usestack.c index 671930bbeb..6396ce9c27 100644 --- a/arch/z16/src/common/up_usestack.c +++ b/arch/z16/src/common/up_usestack.c @@ -1,4 +1,4 @@ -/************************************************************ +/**************************************************************************** * arch/z16/common/up_usestack.c * * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved. @@ -31,11 +31,11 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Included Files - ************************************************************/ + ****************************************************************************/ #include @@ -49,38 +49,45 @@ #include "up_internal.h" -/************************************************************ +/**************************************************************************** * Private Types - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Private Function Prototypes - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Global Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB - * using pre-allocated stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, + * + * - adj_stack_size: Stack size after adjustment for hardware, * processor, etc. This value is retained only for debug * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. * - ************************************************************/ + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. + * + ****************************************************************************/ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) { diff --git a/arch/z80/src/common/up_createstack.c b/arch/z80/src/common/up_createstack.c index c086839bf2..1e47b09bdf 100644 --- a/arch/z80/src/common/up_createstack.c +++ b/arch/z80/src/common/up_createstack.c @@ -66,24 +66,40 @@ * Name: up_create_stack * * Description: - * Allocate a stack for a new thread and setup up stack-related - * information in the TCB. + * Allocate a stack for a new thread and setup up stack-related information + * in the TCB. * - * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, processor, + * The following TCB fields must be initialized by this function: + * + * - adj_stack_size: Stack size after adjustment for hardware, processor, * etc. This value is retained only for debug purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The initial value of * the stack pointer. * - * Input Parameters: - * tcb: The TCB of new task - * stack_size: The requested stack size. At least this how much must be - * allocated. + * Inputs: + * - tcb: The TCB of new task + * - stack_size: The requested stack size. At least this much + * must be allocated. + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain contexts where the TCB may not be fully + * initialized when up_create_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is allocated. For example, kernel thread stacks should + * be allocated from protected kernel memory. Stacks for user tasks and + * threads must come from memory that is accessible to user code. * ****************************************************************************/ -int up_create_stack(struct tcb_s *tcb, size_t stack_size) +int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { /* Is there already a stack allocated of a different size? */ diff --git a/arch/z80/src/common/up_releasestack.c b/arch/z80/src/common/up_releasestack.c index 346971610a..beefc47445 100644 --- a/arch/z80/src/common/up_releasestack.c +++ b/arch/z80/src/common/up_releasestack.c @@ -1,4 +1,4 @@ -/************************************************************ +/**************************************************************************** * common/up_releasestack.c * * Copyright (C) 2007-2009 Gregory Nutt. All rights reserved. @@ -31,11 +31,11 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Included Files - ************************************************************/ + ****************************************************************************/ #include @@ -46,28 +46,50 @@ #include "os_internal.h" #include "up_internal.h" -/************************************************************ +/**************************************************************************** * Private Types - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Private Function Prototypes - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Global Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Name: up_release_stack * * Description: - * A task has been stopped. Free all stack - * related resources retained int the defunct TCB. + * A task has been stopped. Free all stack related resources retained in + * the defunct TCB. * - ************************************************************/ + * Input Parmeters + * - dtcb: The TCB containing information about the stack to be released + * - ttype: The thread type. This may be one of following (defined in + * include/nuttx/sched.h): + * + * TCB_FLAG_TTYPE_TASK Normal user task + * TCB_FLAG_TTYPE_PTHREAD User pthread + * TCB_FLAG_TTYPE_KERNEL Kernel thread + * + * This thread type is normally available in the flags field of the TCB, + * however, there are certain error recovery contexts where the TCB may + * not be fully initialized when up_release_stack is called. + * + * If CONFIG_NUTTX_KERNEL is defined, then this thread type may affect + * how the stack is freed. For example, kernel thread stacks may have + * been allocated from protected kernel memory. Stacks for user tasks + * and threads must have come from memory that is accessible to user + * code. + * + * Returned Value: + * None + * + ****************************************************************************/ -void up_release_stack(struct tcb_s *dtcb) +void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { if (dtcb->stack_alloc_ptr) { diff --git a/arch/z80/src/common/up_usestack.c b/arch/z80/src/common/up_usestack.c index f6fdb5fd46..8d322e7056 100644 --- a/arch/z80/src/common/up_usestack.c +++ b/arch/z80/src/common/up_usestack.c @@ -1,4 +1,4 @@ -/************************************************************ +/**************************************************************************** * arch/z80/src/common/up_usestack.c * * Copyright (C) 2007-2009 Gregory Nutt. All rights reserved. @@ -31,11 +31,11 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Included Files - ************************************************************/ + ****************************************************************************/ #include @@ -48,38 +48,45 @@ #include "up_internal.h" -/************************************************************ +/**************************************************************************** * Private Types - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Private Function Prototypes - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Global Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Name: up_use_stack * * Description: - * Setup up stack-related information in the TCB - * using pre-allocated stack memory + * Setup up stack-related information in the TCB using pre-allocated stack + * memory. This function is called only from task_init() when a task or + * kernel thread is started (never for pthreads). * * The following TCB fields must be initialized: - * adj_stack_size: Stack size after adjustment for hardware, + * + * - adj_stack_size: Stack size after adjustment for hardware, * processor, etc. This value is retained only for debug * purposes. - * stack_alloc_ptr: Pointer to allocated stack - * adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The + * - stack_alloc_ptr: Pointer to allocated stack + * - adj_stack_ptr: Adjusted stack_alloc_ptr for HW. The * initial value of the stack pointer. * * Inputs: - * tcb: The TCB of new task - * stack_size: The allocated stack size. + * - tcb: The TCB of new task + * - stack_size: The allocated stack size. * - ************************************************************/ + * NOTE: Unlike up_stack_create() and up_stack_release, this function + * does not require the task type (ttype) parameter. The TCB flags will + * always be set to provide the task type to up_use_stack() if it needs + * that information. + * + ****************************************************************************/ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) {