From 4d24c4890165070570fe9c3ffd630b02eff52c88 Mon Sep 17 00:00:00 2001 From: Gregory Nutt Date: Wed, 27 Aug 2014 16:15:46 -0600 Subject: [PATCH] Add ADDRENV support to ALL implementations of up_unblock_task() --- arch/arm/src/arm/up_unblocktask.c | 24 +++++++++++++++++-- arch/arm/src/armv7-a/arm_unblocktask.c | 24 +++++++++++++++++-- arch/avr/src/avr32/up_unblocktask.c | 32 ++++++++++++++++++++++---- arch/hc/src/common/up_unblocktask.c | 24 +++++++++++++++++-- arch/mips/src/mips32/up_unblocktask.c | 32 ++++++++++++++++++++++---- arch/rgmp/src/nuttx.c | 12 ++++++++++ arch/sh/src/common/up_unblocktask.c | 24 +++++++++++++++++-- arch/x86/src/common/up_unblocktask.c | 24 +++++++++++++++++-- arch/z80/src/common/up_unblocktask.c | 26 +++++++++++++++++---- 9 files changed, 200 insertions(+), 22 deletions(-) diff --git a/arch/arm/src/arm/up_unblocktask.c b/arch/arm/src/arm/up_unblocktask.c index eae0733daf..22b2c2d6d8 100644 --- a/arch/arm/src/arm/up_unblocktask.c +++ b/arch/arm/src/arm/up_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/arm/src/arm/up_unblocktask.c * - * Copyright (C) 2007-2009, 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2007-2009, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -44,6 +44,7 @@ #include #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -75,7 +76,7 @@ * tcb: Refers to the tcb to be unblocked. This tcb is * in one of the waiting tasks lists. It must be moved to * the ready-to-run list and, if it is the highest priority - * ready to run taks, executed. + * ready to run task, executed. * ****************************************************************************/ @@ -129,6 +130,16 @@ void up_unblock_task(struct tcb_s *tcb) /* Then switch contexts */ up_restorestate(rtcb->xcp.regs); + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* We are not in an interrupt handler. Copy the user C context @@ -146,6 +157,15 @@ void up_unblock_task(struct tcb_s *tcb) rtcb = (struct tcb_s*)g_readytorun.head; +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif /* Then switch contexts */ up_fullcontextrestore(rtcb->xcp.regs); diff --git a/arch/arm/src/armv7-a/arm_unblocktask.c b/arch/arm/src/armv7-a/arm_unblocktask.c index 750c900f94..a49baac307 100644 --- a/arch/arm/src/armv7-a/arm_unblocktask.c +++ b/arch/arm/src/armv7-a/arm_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/arm/src/armv7-a/arm_unblocktask.c * - * Copyright (C) 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -44,6 +44,7 @@ #include #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -75,7 +76,7 @@ * tcb: Refers to the tcb to be unblocked. This tcb is * in one of the waiting tasks lists. It must be moved to * the ready-to-run list and, if it is the highest priority - * ready to run taks, executed. + * ready to run task, executed. * ****************************************************************************/ @@ -129,6 +130,16 @@ void up_unblock_task(struct tcb_s *tcb) /* Then switch contexts */ up_restorestate(rtcb->xcp.regs); + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* We are not in an interrupt handler. Copy the user C context @@ -146,6 +157,15 @@ void up_unblock_task(struct tcb_s *tcb) rtcb = (struct tcb_s*)g_readytorun.head; +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif /* Then switch contexts */ up_fullcontextrestore(rtcb->xcp.regs); diff --git a/arch/avr/src/avr32/up_unblocktask.c b/arch/avr/src/avr32/up_unblocktask.c index fbbd00c8ec..20e6d3bdf2 100644 --- a/arch/avr/src/avr32/up_unblocktask.c +++ b/arch/avr/src/avr32/up_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/avr/src/avr32/up_unblocktask.c * - * Copyright (C) 2010, 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2010, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -44,6 +44,7 @@ #include #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -75,7 +76,7 @@ * tcb: Refers to the tcb to be unblocked. This tcb is * in one of the waiting tasks lists. It must be moved to * the ready-to-run list and, if it is the highest priority - * ready to run taks, executed. + * ready to run task, executed. * ****************************************************************************/ @@ -129,17 +130,40 @@ void up_unblock_task(struct tcb_s *tcb) /* Then switch contexts */ up_restorestate(rtcb->xcp.regs); + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* No, then we will need to perform the user context switch */ else { - /* Switch context to the context of the task at the head of the - * ready to run list. + /* Restore the exception context of the new task that is ready to + * run (probably tcb). This is the new rtcb at the head of the + * g_readytorun task list. */ struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(nexttcb); +#endif + /* Then switch contexts */ + up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/arch/hc/src/common/up_unblocktask.c b/arch/hc/src/common/up_unblocktask.c index bb232c0bf9..fe1021e132 100644 --- a/arch/hc/src/common/up_unblocktask.c +++ b/arch/hc/src/common/up_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/hc/src/common/up_unblocktask.c * - * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -44,6 +44,7 @@ #include #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -75,7 +76,7 @@ * tcb: Refers to the tcb to be unblocked. This tcb is * in one of the waiting tasks lists. It must be moved to * the ready-to-run list and, if it is the highest priority - * ready to run taks, executed. + * ready to run task, executed. * ****************************************************************************/ @@ -129,6 +130,16 @@ void up_unblock_task(struct tcb_s *tcb) /* Then switch contexts */ up_restorestate(rtcb->xcp.regs); + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* We are not in an interrupt handler. Copy the user C context @@ -146,6 +157,15 @@ void up_unblock_task(struct tcb_s *tcb) rtcb = (struct tcb_s*)g_readytorun.head; +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif /* Then switch contexts */ up_fullcontextrestore(rtcb->xcp.regs); diff --git a/arch/mips/src/mips32/up_unblocktask.c b/arch/mips/src/mips32/up_unblocktask.c index 16da9ab814..522c611333 100644 --- a/arch/mips/src/mips32/up_unblocktask.c +++ b/arch/mips/src/mips32/up_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/mips/src/mips32/up_unblocktask.c * - * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -46,6 +46,7 @@ #include #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -77,7 +78,7 @@ * tcb: Refers to the tcb to be unblocked. This tcb is * in one of the waiting tasks lists. It must be moved to * the ready-to-run list and, if it is the highest priority - * ready to run taks, executed. + * ready to run task, executed. * ****************************************************************************/ @@ -131,17 +132,40 @@ void up_unblock_task(struct tcb_s *tcb) /* Then switch contexts */ up_restorestate(rtcb->xcp.regs); + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* No, then we will need to perform the user context switch */ else { - /* Switch context to the context of the task at the head of the - * ready to run list. + /* Restore the exception context of the new task that is ready to + * run (probably tcb). This is the new rtcb at the head of the + * g_readytorun task list. */ struct tcb_s *nexttcb = (struct tcb_s*)g_readytorun.head; + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(nexttcb); +#endif + /* Then switch contexts */ + up_switchcontext(rtcb->xcp.regs, nexttcb->xcp.regs); /* up_switchcontext forces a context switch to the task at the diff --git a/arch/rgmp/src/nuttx.c b/arch/rgmp/src/nuttx.c index a7a6a2915e..2d7ab192ef 100644 --- a/arch/rgmp/src/nuttx.c +++ b/arch/rgmp/src/nuttx.c @@ -288,6 +288,7 @@ void up_block_task(struct tcb_s *tcb, tstate_t task_state) warn("Disable preemption failed for task block itself\n"); sched_mergepending(); } + nexttcb = (struct tcb_s*)g_readytorun.head; #ifdef CONFIG_ARCH_ADDRENV @@ -344,8 +345,19 @@ void up_unblock_task(struct tcb_s *tcb) // 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; + +#ifdef CONFIG_ARCH_ADDRENV + // Make sure that the address environment for the previously + // running task is closed down gracefully (data caches dump, + // MMU flushed) and set up the address environment for the new + // thread at the head of the ready-to-run list. + + (void)group_addrenv(nexttcb); +#endif // context switch + up_switchcontext(rtcb, nexttcb); } } diff --git a/arch/sh/src/common/up_unblocktask.c b/arch/sh/src/common/up_unblocktask.c index 04832386fe..463dc0bf90 100644 --- a/arch/sh/src/common/up_unblocktask.c +++ b/arch/sh/src/common/up_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/sh/src/common/up_unblocktask.c * - * Copyright (C) 2008-2009, 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2008-2009, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -44,6 +44,7 @@ #include #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -75,7 +76,7 @@ * tcb: Refers to the tcb to be unblocked. This tcb is * in one of the waiting tasks lists. It must be moved to * the ready-to-run list and, if it is the highest priority - * ready to run taks, executed. + * ready to run task, executed. * ****************************************************************************/ @@ -129,6 +130,16 @@ void up_unblock_task(struct tcb_s *tcb) /* Then switch contexts */ current_regs = rtcb->xcp.regs; + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* We are not in an interrupt handler. Copy the user C context @@ -146,6 +157,15 @@ void up_unblock_task(struct tcb_s *tcb) rtcb = (struct tcb_s*)g_readytorun.head; +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif /* Then switch contexts */ up_fullcontextrestore(rtcb->xcp.regs); diff --git a/arch/x86/src/common/up_unblocktask.c b/arch/x86/src/common/up_unblocktask.c index 6778135756..ddbe3e6092 100644 --- a/arch/x86/src/common/up_unblocktask.c +++ b/arch/x86/src/common/up_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/x86/src/common/up_unblocktask.c * - * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2011, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -44,6 +44,7 @@ #include #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -74,7 +75,7 @@ * Inputs: * tcb: Refers to the tcb to be unblocked. This tcb is in one of the * waiting tasks lists. It must be moved to the ready-to-run list and, - * if it is the highest priority ready to run taks, executed. + * if it is the highest priority ready to run task, executed. * ****************************************************************************/ @@ -128,6 +129,16 @@ void up_unblock_task(struct tcb_s *tcb) /* Then switch contexts */ up_restorestate(rtcb->xcp.regs); + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* We are not in an interrupt handler. Copy the user C context @@ -145,6 +156,15 @@ void up_unblock_task(struct tcb_s *tcb) rtcb = (struct tcb_s*)g_readytorun.head; +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif /* Then switch contexts */ up_fullcontextrestore(rtcb->xcp.regs); diff --git a/arch/z80/src/common/up_unblocktask.c b/arch/z80/src/common/up_unblocktask.c index 688bb03f1e..257b19c6fc 100644 --- a/arch/z80/src/common/up_unblocktask.c +++ b/arch/z80/src/common/up_unblocktask.c @@ -1,7 +1,7 @@ /**************************************************************************** * arch/z80/src/common/up_unblocktask.c * - * Copyright (C) 2007-2009, 2013 Gregory Nutt. All rights reserved. + * Copyright (C) 2007-2009, 2013-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -47,6 +47,7 @@ #include "chip/chip.h" #include "chip/switch.h" #include "sched/sched.h" +#include "group/group.h" #include "clock/clock.h" #include "up_internal.h" @@ -78,7 +79,7 @@ * tcb: Refers to the tcb to be unblocked. This tcb is * in one of the waiting tasks lists. It must be moved to * the ready-to-run list and, if it is the highest priority - * ready to run taks, executed. + * ready to run task, executed. * ****************************************************************************/ @@ -130,13 +131,22 @@ void up_unblock_task(FAR struct tcb_s *tcb) */ rtcb = (FAR struct tcb_s*)g_readytorun.head; - /* dbg("New Active Task TCB=%p\n", rtcb); */ /* Then setup so that the context will be performed on exit * from the interrupt. */ SET_IRQCONTEXT(rtcb); + +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif } /* We are not in an interrupt handler. Copy the user C context @@ -153,8 +163,16 @@ void up_unblock_task(FAR struct tcb_s *tcb) */ rtcb = (FAR struct tcb_s*)g_readytorun.head; - /* dbg("New Active Task TCB=%p\n", rtcb); */ +#ifdef CONFIG_ARCH_ADDRENV + /* Make sure that the address environment for the previously + * running task is closed down gracefully (data caches dump, + * MMU flushed) and set up the address environment for the new + * thread at the head of the ready-to-run list. + */ + + (void)group_addrenv(rtcb); +#endif /* Then switch contexts */ RESTORE_USERCONTEXT(rtcb);