From c86f502f2e311735fee306ee3dcb5435a1ced4e0 Mon Sep 17 00:00:00 2001 From: patacongo Date: Wed, 20 Mar 2013 20:27:08 +0000 Subject: [PATCH] In the kernel build, allocate the stacks for kernel threads from the kernel heap so that they are protected from medddling by the applications git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5766 42af7a65-404d-4744-a932-0658087f49c3 --- arch/arm/src/common/up_createstack.c | 38 ++- arch/arm/src/common/up_releasestack.c | 24 +- arch/arm/src/common/up_usestack.c | 8 +- arch/avr/src/avr/up_createstack.c | 38 ++- arch/avr/src/avr/up_usestack.c | 8 +- arch/avr/src/avr32/up_createstack.c | 38 ++- arch/avr/src/avr32/up_usestack.c | 10 +- arch/avr/src/common/up_releasestack.c | 24 +- arch/hc/src/common/up_createstack.c | 38 ++- arch/hc/src/common/up_releasestack.c | 24 +- arch/hc/src/common/up_usestack.c | 11 +- arch/mips/src/common/up_createstack.c | 38 ++- arch/mips/src/common/up_releasestack.c | 24 +- arch/mips/src/common/up_usestack.c | 10 +- arch/rgmp/src/nuttx.c | 315 +++++++++++++------------ arch/sh/src/common/up_createstack.c | 38 ++- arch/sh/src/common/up_releasestack.c | 24 +- arch/sh/src/common/up_usestack.c | 12 +- arch/sim/src/up_createstack.c | 17 +- arch/sim/src/up_releasestack.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 | 10 +- arch/z16/src/common/up_createstack.c | 38 ++- arch/z16/src/common/up_releasestack.c | 24 +- arch/z16/src/common/up_usestack.c | 10 +- arch/z80/src/common/up_createstack.c | 38 ++- arch/z80/src/common/up_releasestack.c | 24 +- arch/z80/src/common/up_usestack.c | 10 +- 29 files changed, 711 insertions(+), 265 deletions(-) diff --git a/arch/arm/src/common/up_createstack.c b/arch/arm/src/common/up_createstack.c index 65eb91159b..634fb9d61f 100644 --- a/arch/arm/src/common/up_createstack.c +++ b/arch/arm/src/common/up_createstack.c @@ -146,17 +146,19 @@ static void *memset32(void *s, uint32_t c, size_t n) 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ + /* Do we need to allocate a new stack? */ if (!tcb->stack_alloc_ptr) { @@ -164,12 +166,32 @@ int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); @@ -218,7 +240,7 @@ int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) */ #if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_STACK) - memset32(tcb->stack_alloc_ptr, 0xDEADBEEF, tcb->adj_stack_size/4); + memset32(tcb->stack_alloc_ptr, 0xdeadbeef, tcb->adj_stack_size/4); #endif up_ledon(LED_STACKCREATED); diff --git a/arch/arm/src/common/up_releasestack.c b/arch/arm/src/common/up_releasestack.c index 711022f93e..9ab872d332 100644 --- a/arch/arm/src/common/up_releasestack.c +++ b/arch/arm/src/common/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/arm/src/common/up_releasestack.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 @@ -91,11 +91,31 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/arm/src/common/up_usestack.c b/arch/arm/src/common/up_usestack.c index a141006bbd..a45ec99b57 100644 --- a/arch/arm/src/common/up_usestack.c +++ b/arch/arm/src/common/up_usestack.c @@ -121,12 +121,16 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr) { - sched_ufree(tcb->stack_alloc_ptr); + /* Yes... Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack; diff --git a/arch/avr/src/avr/up_createstack.c b/arch/avr/src/avr/up_createstack.c index 60f6dceec9..98423be1f0 100644 --- a/arch/avr/src/avr/up_createstack.c +++ b/arch/avr/src/avr/up_createstack.c @@ -105,30 +105,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (FAR void *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (FAR void *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/avr/src/avr/up_usestack.c b/arch/avr/src/avr/up_usestack.c index ebd911fb25..629ad6cf02 100644 --- a/arch/avr/src/avr/up_usestack.c +++ b/arch/avr/src/avr/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/avr/src/avr/up_usestack.c * - * Copyright (C) 2011 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -98,12 +98,12 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) if (tcb->stack_alloc_ptr) { - /* Yes.. free it */ + /* Yes.. Release the old stack allocation */ - sched_ufree(tcb->stack_alloc_ptr); + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack; diff --git a/arch/avr/src/avr32/up_createstack.c b/arch/avr/src/avr32/up_createstack.c index da7e8788c5..76ed2c0f5e 100644 --- a/arch/avr/src/avr32/up_createstack.c +++ b/arch/avr/src/avr32/up_createstack.c @@ -104,30 +104,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (FAR void *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (FAR void *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/avr/src/avr32/up_usestack.c b/arch/avr/src/avr32/up_usestack.c index 86cdc2de40..e71be16e7e 100644 --- a/arch/avr/src/avr32/up_usestack.c +++ b/arch/avr/src/avr32/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/avr/src/avr32/up_usestack.c * - * Copyright (C) 2010 Gregory Nutt. All rights reserved. + * Copyright (C) 2010, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -94,12 +94,16 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr) { - sched_ufree(tcb->stack_alloc_ptr); + /* Yes.. Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack; diff --git a/arch/avr/src/common/up_releasestack.c b/arch/avr/src/common/up_releasestack.c index 7d3e6f28c2..ec172bd5e4 100644 --- a/arch/avr/src/common/up_releasestack.c +++ b/arch/avr/src/common/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/avr/src/common/up_releasestack.c * - * Copyright (C) 2010 Gregory Nutt. All rights reserved. + * Copyright (C) 2010, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -91,12 +91,32 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/hc/src/common/up_createstack.c b/arch/hc/src/common/up_createstack.c index a8b192c4bc..d7050f5122 100644 --- a/arch/hc/src/common/up_createstack.c +++ b/arch/hc/src/common/up_createstack.c @@ -101,30 +101,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/hc/src/common/up_releasestack.c b/arch/hc/src/common/up_releasestack.c index f8c2fa142d..800e0ccb5a 100644 --- a/arch/hc/src/common/up_releasestack.c +++ b/arch/hc/src/common/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/hc/src/common/up_releasestack.c * - * Copyright (C) 2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2009, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -92,11 +92,31 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/hc/src/common/up_usestack.c b/arch/hc/src/common/up_usestack.c index 7f3c8fc669..047ba2e9a5 100644 --- a/arch/hc/src/common/up_usestack.c +++ b/arch/hc/src/common/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/hc/src/common/up_usestack.c * - * Copyright (C) 2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2009, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -93,13 +93,16 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + /* Yes.. Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack; diff --git a/arch/mips/src/common/up_createstack.c b/arch/mips/src/common/up_createstack.c index b228e80619..6109797a34 100644 --- a/arch/mips/src/common/up_createstack.c +++ b/arch/mips/src/common/up_createstack.c @@ -122,30 +122,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/mips/src/common/up_releasestack.c b/arch/mips/src/common/up_releasestack.c index 3ce46bebdc..f1cb44c230 100644 --- a/arch/mips/src/common/up_releasestack.c +++ b/arch/mips/src/common/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/mips/src/common/up_releasestack.c * - * Copyright (C) 2011 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -91,11 +91,31 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/mips/src/common/up_usestack.c b/arch/mips/src/common/up_usestack.c index fe1d27818d..b636a51d78 100644 --- a/arch/mips/src/common/up_usestack.c +++ b/arch/mips/src/common/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/mips/src/common/up_usestack.c * - * Copyright (C) 2011 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -94,12 +94,16 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr) { - sched_ufree(tcb->stack_alloc_ptr); + /* Yes.. Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack; diff --git a/arch/rgmp/src/nuttx.c b/arch/rgmp/src/nuttx.c index 3dc5310062..79f97fcfca 100644 --- a/arch/rgmp/src/nuttx.c +++ b/arch/rgmp/src/nuttx.c @@ -66,11 +66,11 @@ static inline void up_switchcontext(struct tcb_s *ctcb, struct tcb_s *ntcb) { // do nothing if two tasks are the same if (ctcb == ntcb) - return; + return; // this function can not be called in interrupt if (up_interrupt_context()) { - panic("%s: try to switch context in interrupt\n", __func__); + panic("%s: try to switch context in interrupt\n", __func__); } // start switch @@ -81,19 +81,19 @@ static inline void up_switchcontext(struct tcb_s *ctcb, struct tcb_s *ntcb) void up_initialize(void) { extern pidhash_t g_pidhash[]; - extern void vdev_init(void); + extern void vdev_init(void); extern void nuttx_arch_init(void); // intialize the current_task to g_idletcb current_task = g_pidhash[PIDHASH(0)].tcb; - // OS memory alloc system is ready - use_os_kmalloc = 1; + // OS memory alloc system is ready + use_os_kmalloc = 1; // rgmp vdev init - vdev_init(); + vdev_init(); - nuttx_arch_init(); + nuttx_arch_init(); // enable interrupt local_irq_enable(); @@ -106,13 +106,14 @@ void up_idle(void) void up_allocate_heap(void **heap_start, size_t *heap_size) { - void *boot_freemem = boot_alloc(0, sizeof(int)); + void *boot_freemem = boot_alloc(0, sizeof(int)); *heap_start = boot_freemem; *heap_size = KERNBASE + kmem_size - (uint32_t)boot_freemem; } int up_create_stack(struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { + uint32_t *stack_alloc_ptr; int ret = ERROR; size_t *adj_stack_ptr; @@ -123,18 +124,27 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size, uint8_t ttype) /* Allocate the memory for the stack */ - uint32_t *stack_alloc_ptr = (uint32_t*)kumalloc(adj_stack_size); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) { + stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); + } else +#endif + { + stack_alloc_ptr = (uint32_t*)kumalloc(adj_stack_size); + } if (stack_alloc_ptr) { - /* This is the address of the last word in the allocation */ + /* This is the address of the last word in the allocation */ - adj_stack_ptr = &stack_alloc_ptr[adj_stack_words - 1]; + adj_stack_ptr = &stack_alloc_ptr[adj_stack_words - 1]; - /* Save the values in the TCB */ + /* Save the values in the TCB */ - tcb->adj_stack_size = adj_stack_size; - tcb->stack_alloc_ptr = stack_alloc_ptr; - tcb->adj_stack_ptr = (void *)((unsigned int)adj_stack_ptr & ~7); - ret = OK; + tcb->adj_stack_size = adj_stack_size; + tcb->stack_alloc_ptr = stack_alloc_ptr; + tcb->adj_stack_ptr = (void *)((unsigned int)adj_stack_ptr & ~7); + ret = OK; } return ret; } @@ -160,13 +170,28 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) void up_release_stack(struct tcb_s *dtcb, uint8_t ttype) { - if (dtcb->stack_alloc_ptr) { - kufree(dtcb->stack_alloc_ptr); - } + /* Is there a stack allocated? */ - dtcb->stack_alloc_ptr = NULL; - dtcb->adj_stack_size = 0; - dtcb->adj_stack_ptr = NULL; + if (dtcb->stack_alloc_ptr) { +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) { + kfree(dtcb->stack_alloc_ptr); + } else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + kufree(dtcb->stack_alloc_ptr); + } + } + + /* Mark the stack freed */ + + dtcb->stack_alloc_ptr = NULL; + dtcb->adj_stack_size = 0; + dtcb->adj_stack_ptr = NULL; } /**************************************************************************** @@ -196,43 +221,43 @@ void up_block_task(struct tcb_s *tcb, tstate_t task_state) { /* Verify that the context switch can be performed */ if ((tcb->task_state < FIRST_READY_TO_RUN_STATE) || - (tcb->task_state > LAST_READY_TO_RUN_STATE)) { - warn("%s: task sched error\n", __func__); - return; + (tcb->task_state > LAST_READY_TO_RUN_STATE)) { + warn("%s: task sched error\n", __func__); + return; } else { - struct tcb_s *rtcb = current_task; - bool switch_needed; + struct tcb_s *rtcb = current_task; + bool switch_needed; - /* Remove the tcb task from the ready-to-run list. If we - * are blocking the task at the head of the task list (the - * most likely case), then a context switch to the next - * ready-to-run task is needed. In this case, it should - * also be true that rtcb == tcb. - */ - switch_needed = sched_removereadytorun(tcb); + /* Remove the tcb task from the ready-to-run list. If we + * are blocking the task at the head of the task list (the + * most likely case), then a context switch to the next + * ready-to-run task is needed. In this case, it should + * also be true that rtcb == tcb. + */ + switch_needed = sched_removereadytorun(tcb); - /* Add the task to the specified blocked task list */ - sched_addblocked(tcb, (tstate_t)task_state); + /* Add the task to the specified blocked task list */ + sched_addblocked(tcb, (tstate_t)task_state); - /* Now, perform the context switch if one is needed */ - if (switch_needed) { - struct tcb_s *nexttcb; - // this part should not be executed in interrupt context - if (up_interrupt_context()) { - panic("%s: %d\n", __func__, __LINE__); - } - // If there are any pending tasks, then add them to the g_readytorun - // task list now. It should be the up_realease_pending() called from - // sched_unlock() to do this for disable preemption. But it block - // itself, so it's OK. - if (g_pendingtasks.head) { - warn("Disable preemption failed for task block itself\n"); - sched_mergepending(); - } - nexttcb = (struct tcb_s*)g_readytorun.head; - // context switch - up_switchcontext(rtcb, nexttcb); + /* Now, perform the context switch if one is needed */ + if (switch_needed) { + struct tcb_s *nexttcb; + // this part should not be executed in interrupt context + if (up_interrupt_context()) { + panic("%s: %d\n", __func__, __LINE__); + } + // If there are any pending tasks, then add them to the g_readytorun + // task list now. It should be the up_realease_pending() called from + // sched_unlock() to do this for disable preemption. But it block + // itself, so it's OK. + if (g_pendingtasks.head) { + warn("Disable preemption failed for task block itself\n"); + sched_mergepending(); + } + nexttcb = (struct tcb_s*)g_readytorun.head; + // context switch + up_switchcontext(rtcb, nexttcb); } } } @@ -256,31 +281,31 @@ void up_unblock_task(struct tcb_s *tcb) { /* Verify that the context switch can be performed */ if ((tcb->task_state < FIRST_BLOCKED_STATE) || - (tcb->task_state > LAST_BLOCKED_STATE)) { - warn("%s: task sched error\n", __func__); - return; + (tcb->task_state > LAST_BLOCKED_STATE)) { + warn("%s: task sched error\n", __func__); + return; } else { - struct tcb_s *rtcb = current_task; + struct tcb_s *rtcb = current_task; - /* Remove the task from the blocked task list */ - sched_removeblocked(tcb); + /* Remove the task from the blocked task list */ + sched_removeblocked(tcb); - /* Reset its timeslice. This is only meaningful for round - * robin tasks but it doesn't here to do it for everything - */ + /* Reset its timeslice. This is only meaningful for round + * robin tasks but it doesn't here to do it for everything + */ #if CONFIG_RR_INTERVAL > 0 - tcb->timeslice = CONFIG_RR_INTERVAL / MSEC_PER_TICK; + tcb->timeslice = CONFIG_RR_INTERVAL / MSEC_PER_TICK; #endif - - // Add the task in the correct location in the prioritized - // g_readytorun task list. - if (sched_addreadytorun(tcb) && !up_interrupt_context()) { - /* The currently active task has changed! */ - struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; - // context switch - up_switchcontext(rtcb, nexttcb); - } + + // Add the task in the correct location in the prioritized + // g_readytorun task list. + if (sched_addreadytorun(tcb) && !up_interrupt_context()) { + /* The currently active task has changed! */ + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; + // context switch + up_switchcontext(rtcb, nexttcb); + } } } @@ -295,11 +320,11 @@ void up_release_pending(void) /* Merge the g_pendingtasks list into the g_readytorun task list */ if (sched_mergepending()) { - /* The currently active task has changed! */ - struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; + /* The currently active task has changed! */ + struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; - // context switch - up_switchcontext(rtcb, nexttcb); + // context switch + up_switchcontext(rtcb, nexttcb); } } @@ -308,54 +333,54 @@ void up_reprioritize_rtr(struct tcb_s *tcb, uint8_t priority) /* Verify that the caller is sane */ if (tcb->task_state < FIRST_READY_TO_RUN_STATE || - tcb->task_state > LAST_READY_TO_RUN_STATE + tcb->task_state > LAST_READY_TO_RUN_STATE #if SCHED_PRIORITY_MIN > UINT8_MIN - || priority < SCHED_PRIORITY_MIN + || priority < SCHED_PRIORITY_MIN #endif #if SCHED_PRIORITY_MAX < UINT8_MAX - || priority > SCHED_PRIORITY_MAX + || priority > SCHED_PRIORITY_MAX #endif - ) { - warn("%s: task sched error\n", __func__); - return; + ) { + warn("%s: task sched error\n", __func__); + return; } else { - struct tcb_s *rtcb = current_task; - bool switch_needed; + struct tcb_s *rtcb = current_task; + bool switch_needed; - /* Remove the tcb task from the ready-to-run list. - * sched_removereadytorun will return true if we just - * remove the head of the ready to run list. - */ - switch_needed = sched_removereadytorun(tcb); + /* Remove the tcb task from the ready-to-run list. + * sched_removereadytorun will return true if we just + * remove the head of the ready to run list. + */ + switch_needed = sched_removereadytorun(tcb); - /* Setup up the new task priority */ - tcb->sched_priority = (uint8_t)priority; + /* Setup up the new task priority */ + tcb->sched_priority = (uint8_t)priority; - /* Return the task to the specified blocked task list. - * sched_addreadytorun will return true if the task was - * added to the new list. We will need to perform a context - * switch only if the EXCLUSIVE or of the two calls is non-zero - * (i.e., one and only one the calls changes the head of the - * ready-to-run list). - */ - switch_needed ^= sched_addreadytorun(tcb); + /* Return the task to the specified blocked task list. + * sched_addreadytorun will return true if the task was + * added to the new list. We will need to perform a context + * switch only if the EXCLUSIVE or of the two calls is non-zero + * (i.e., one and only one the calls changes the head of the + * ready-to-run list). + */ + switch_needed ^= sched_addreadytorun(tcb); - /* Now, perform the context switch if one is needed */ - if (switch_needed && !up_interrupt_context()) { - struct tcb_s *nexttcb; - // If there are any pending tasks, then add them to the g_readytorun - // task list now. It should be the up_realease_pending() called from - // sched_unlock() to do this for disable preemption. But it block - // itself, so it's OK. - if (g_pendingtasks.head) { - warn("Disable preemption failed for reprioritize task\n"); - sched_mergepending(); + /* Now, perform the context switch if one is needed */ + if (switch_needed && !up_interrupt_context()) { + struct tcb_s *nexttcb; + // If there are any pending tasks, then add them to the g_readytorun + // task list now. It should be the up_realease_pending() called from + // sched_unlock() to do this for disable preemption. But it block + // itself, so it's OK. + if (g_pendingtasks.head) { + warn("Disable preemption failed for reprioritize task\n"); + sched_mergepending(); } - nexttcb = (struct tcb_s*)g_readytorun.head; - // context switch - up_switchcontext(rtcb, nexttcb); + nexttcb = (struct tcb_s*)g_readytorun.head; + // context switch + up_switchcontext(rtcb, nexttcb); } } } @@ -387,26 +412,26 @@ void up_assert(const uint8_t *filename, int line) // which will stop the OS // if in user space just terminate the task if (up_interrupt_context() || current_task->pid == 0) { - panic("%s: %d\n", __func__, __LINE__); + panic("%s: %d\n", __func__, __LINE__); } else { - exit(EXIT_FAILURE); + exit(EXIT_FAILURE); } } void up_assert_code(const uint8_t *filename, int line, int code) { fprintf(stderr, "Assertion failed at file:%s line: %d error code: %d\n", - filename, line, code); + filename, line, code); // in interrupt context or idle task means kernel error // which will stop the OS // if in user space just terminate the task if (up_interrupt_context() || current_task->pid == 0) { - panic("%s: %d\n", __func__, __LINE__); + panic("%s: %d\n", __func__, __LINE__); } else { - exit(EXIT_FAILURE); + exit(EXIT_FAILURE); } } @@ -417,38 +442,38 @@ void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) { /* Refuse to handle nested signal actions */ if (!tcb->xcp.sigdeliver) { - int flags; + int flags; - /* Make sure that interrupts are disabled */ - local_irq_save(flags); + /* Make sure that interrupts are disabled */ + local_irq_save(flags); - // First, handle some special cases when the signal is - // being delivered to the currently executing task. - if (tcb == current_task) { - // CASE 1: We are not in an interrupt handler and - // a task is signalling itself for some reason. - if (!up_interrupt_context()) { - // In this case just deliver the signal now. - sigdeliver(tcb); - } - // CASE 2: We are in an interrupt handler AND the - // interrupted task is the same as the one that - // must receive the signal. - else { - tcb->xcp.sigdeliver = sigdeliver; + // First, handle some special cases when the signal is + // being delivered to the currently executing task. + if (tcb == current_task) { + // CASE 1: We are not in an interrupt handler and + // a task is signalling itself for some reason. + if (!up_interrupt_context()) { + // In this case just deliver the signal now. + sigdeliver(tcb); + } + // CASE 2: We are in an interrupt handler AND the + // interrupted task is the same as the one that + // must receive the signal. + else { + tcb->xcp.sigdeliver = sigdeliver; } } - // Otherwise, we are (1) signaling a task is not running - // from an interrupt handler or (2) we are not in an - // interrupt handler and the running task is signalling - // some non-running task. - else { - tcb->xcp.sigdeliver = sigdeliver; - push_xcptcontext(&tcb->xcp); + // Otherwise, we are (1) signaling a task is not running + // from an interrupt handler or (2) we are not in an + // interrupt handler and the running task is signalling + // some non-running task. + else { + tcb->xcp.sigdeliver = sigdeliver; + push_xcptcontext(&tcb->xcp); } - local_irq_restore(flags); + local_irq_restore(flags); } } @@ -458,7 +483,7 @@ void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver) bool up_interrupt_context(void) { if (nest_irq) - return true; + return true; return false; } @@ -497,7 +522,7 @@ void up_sigdeliver(struct Trapframe *tf) void up_cxxinitialize(void) { - rgmp_cxx_init(); + rgmp_cxx_init(); } #endif diff --git a/arch/sh/src/common/up_createstack.c b/arch/sh/src/common/up_createstack.c index 3ffdc30509..5a22fd3e6e 100644 --- a/arch/sh/src/common/up_createstack.c +++ b/arch/sh/src/common/up_createstack.c @@ -101,30 +101,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/sh/src/common/up_releasestack.c b/arch/sh/src/common/up_releasestack.c index 8325781187..e88e06d523 100644 --- a/arch/sh/src/common/up_releasestack.c +++ b/arch/sh/src/common/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/sh/src/common/up_releasestack.c * - * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2008-2009, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -91,11 +91,31 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/sh/src/common/up_usestack.c b/arch/sh/src/common/up_usestack.c index 7c2b9586ea..bcce3261cd 100644 --- a/arch/sh/src/common/up_usestack.c +++ b/arch/sh/src/common/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/sh/src/common/up_usestack.c * - * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2008-2009, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -94,13 +94,17 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr) { - sched_ufree(tcb->stack_alloc_ptr); + /* Yes.. Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ - + /* Save the new stack allocation */ + tcb->stack_alloc_ptr = stack; /* The Arm7Tdmi uses a push-down stack: the stack grows diff --git a/arch/sim/src/up_createstack.c b/arch/sim/src/up_createstack.c index fe9986e65f..4115dd4ede 100644 --- a/arch/sim/src/up_createstack.c +++ b/arch/sim/src/up_createstack.c @@ -102,6 +102,7 @@ int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) { + uint32_t *stack_alloc_ptr; int ret = ERROR; /* Move up to next even word boundary if necessary */ @@ -111,7 +112,21 @@ int up_create_stack(FAR struct tcb_s *tcb, size_t stack_size, uint8_t ttype) /* Allocate the memory for the stack */ - uint32_t *stack_alloc_ptr = (uint32_t*)kumalloc(adj_stack_size); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); + } + else +#endif + { + stack_alloc_ptr = (uint32_t*)kumalloc(adj_stack_size); + } + + /* Was the allocation successful? */ + if (stack_alloc_ptr) { /* This is the address of the last word in the allocation */ diff --git a/arch/sim/src/up_releasestack.c b/arch/sim/src/up_releasestack.c index 56413f3418..248f6b712c 100644 --- a/arch/sim/src/up_releasestack.c +++ b/arch/sim/src/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * up_releasestack.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 @@ -93,11 +93,28 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - free(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } } + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; dtcb->adj_stack_size = 0; dtcb->adj_stack_ptr = NULL; diff --git a/arch/x86/src/i486/up_createstack.c b/arch/x86/src/i486/up_createstack.c index bcce5fdcc4..ae394dea6f 100644 --- a/arch/x86/src/i486/up_createstack.c +++ b/arch/x86/src/i486/up_createstack.c @@ -103,30 +103,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/x86/src/i486/up_releasestack.c b/arch/x86/src/i486/up_releasestack.c index 0aa43ce58c..8d264641f8 100644 --- a/arch/x86/src/i486/up_releasestack.c +++ b/arch/x86/src/i486/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/x86/src/common/up_releasestack.c * - * Copyright (C) 2011 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -91,11 +91,31 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/x86/src/i486/up_usestack.c b/arch/x86/src/i486/up_usestack.c index f972d89506..b391599315 100644 --- a/arch/x86/src/i486/up_usestack.c +++ b/arch/x86/src/i486/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/x86/src/common/up_usestack.c * - * Copyright (C) 2011 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -94,12 +94,16 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr) { - sched_ufree(tcb->stack_alloc_ptr); + /* Yes.. Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack; diff --git a/arch/z16/src/common/up_createstack.c b/arch/z16/src/common/up_createstack.c index d523181692..2bd3a89514 100644 --- a/arch/z16/src/common/up_createstack.c +++ b/arch/z16/src/common/up_createstack.c @@ -102,30 +102,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/z16/src/common/up_releasestack.c b/arch/z16/src/common/up_releasestack.c index 84cc4be7d3..3d0842a5bd 100644 --- a/arch/z16/src/common/up_releasestack.c +++ b/arch/z16/src/common/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * common/up_releasestack.c * - * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2008-2009, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -91,11 +91,31 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/z16/src/common/up_usestack.c b/arch/z16/src/common/up_usestack.c index 6396ce9c27..7b5effc45f 100644 --- a/arch/z16/src/common/up_usestack.c +++ b/arch/z16/src/common/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/z16/common/up_usestack.c * - * Copyright (C) 2008-2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2008-2009, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -94,12 +94,16 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr) { - sched_ufree(tcb->stack_alloc_ptr); + /* Yes.. Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack; diff --git a/arch/z80/src/common/up_createstack.c b/arch/z80/src/common/up_createstack.c index 1e47b09bdf..a36a8aa7bf 100644 --- a/arch/z80/src/common/up_createstack.c +++ b/arch/z80/src/common/up_createstack.c @@ -101,30 +101,52 @@ 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? */ + /* Is there already a stack allocated of a different size? Because of + * alignment issues, stack_size might erroneously appear to be of a + * different size. Fortunately, this is not a critical operation. + */ if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size) { - /* Yes.. free it */ + /* Yes.. Release the old stack */ - sched_ufree(tcb->stack_alloc_ptr); - tcb->stack_alloc_ptr = NULL; + up_release_stack(tcb, ttype); } - /* Do we need to allocate a stack? */ - + /* Do we need to allocate a new stack? */ + if (!tcb->stack_alloc_ptr) { /* Allocate the stack. If DEBUG is enabled (but not stack debug), * then create a zeroed stack to make stack dumps easier to trace. */ +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) - tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size); #else - tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); + tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size); #endif + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + +#if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK) + tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size); +#else + tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size); +#endif + } + #ifdef CONFIG_DEBUG + /* Was the allocation successful? */ + if (!tcb->stack_alloc_ptr) { sdbg("ERROR: Failed to allocate stack, size %d\n", stack_size); diff --git a/arch/z80/src/common/up_releasestack.c b/arch/z80/src/common/up_releasestack.c index beefc47445..92c7bbd0a6 100644 --- a/arch/z80/src/common/up_releasestack.c +++ b/arch/z80/src/common/up_releasestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * common/up_releasestack.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 @@ -91,11 +91,31 @@ void up_release_stack(FAR struct tcb_s *dtcb, uint8_t ttype) { + /* Is there a stack allocated? */ + if (dtcb->stack_alloc_ptr) { - sched_ufree(dtcb->stack_alloc_ptr); +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Use the kernel allocator if this is a kernel thread */ + + if (ttype == TCB_FLAG_TTYPE_KERNEL) + { + sched_kfree(dtcb->stack_alloc_ptr); + } + else +#endif + { + /* Use the user-space allocator if this is a task or pthread */ + + sched_ufree(dtcb->stack_alloc_ptr); + } + + /* Mark the stack freed */ + dtcb->stack_alloc_ptr = NULL; } + /* The size of the allocated stack is now zero */ + dtcb->adj_stack_size = 0; } diff --git a/arch/z80/src/common/up_usestack.c b/arch/z80/src/common/up_usestack.c index 8d322e7056..095b4f5d53 100644 --- a/arch/z80/src/common/up_usestack.c +++ b/arch/z80/src/common/up_usestack.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/z80/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 @@ -93,12 +93,16 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size) size_t top_of_stack; size_t size_of_stack; + /* Is there already a stack allocated? */ + if (tcb->stack_alloc_ptr) { - sched_ufree(tcb->stack_alloc_ptr); + /* Yes.. Release the old stack allocation */ + + up_release_stack(tcb, tcb->flags & TCB_FLAG_TTYPE_MASK); } - /* Save the stack allocation */ + /* Save the new stack allocation */ tcb->stack_alloc_ptr = stack;