CS452 - Real-Time Programming - Fall 2009

Lecture 7 - Creating a Task

Reminder

• Partners and Unix groups

The Software Interrupt

What happens when the execution reaches a software interrupt instruction?

1. The PSR is saved in spsr_svc.
2. The address of the instruction immediately following swi is put in lr_svc
3. In the PSR
   • execution mode is changed to supervisor
   • interrupts are disabled
4. 0x08 is put in the pc.

This is done by the hardware; the rest is up to you.

In the calling code

   swi  n

In the kernel

The order matters

kernel entry:

1. Change to system state
2. Save the user state
   • on its stack
   • This includes the arguments, which you may or may not need later.
   • Put sp_usr in a scratch register
3. Return to supervisor mode
4. Get the request

   ldr r3, [lr, #-4]

5. Retrieve the kernel state, which does not include the scratch registers
   • You now have the kernel frame pointer
   • You can use it to put stuff in kernel memory
6. Put what you want in the task's TD
   • active is indexed off the frame pointer
   • active is a pointer to the TD of the requester
7. Return from getNextRequest( active ) and get to work
   • Don't forget to store the return value in the TD

After a while it's time to leave the kernel

1. Schedule the next task to run
2. Call GetNextRequest( active )
3. Save kernel state on kernel stack
4. From TD
   • set spsr_svc
   • set lr_svc
   • get sp_usr
5. Set return value by overwriting r0 on user stack
6. Switch to system mode
7. Load registers from user stack
8. Return to supervisor mode
9. Let it go

   movs   pc, lr

Creating a Task

In creating a task you have to do two things

1. Get and initialize resources needed by the task
   • TD
   • memory
2. Make the task look as if it had just entered the kernel
   • it's ready to execute

Things you need to do

Get an unused TD and memory for its stack

• memory could be associated with TD during initialization
• actually a form of constant time memory allocation
• unless you implement Destroy

Mostly filling in fields in the TD.

1. task id
2. stack pointer
3. SPSR
4. link register
5. parent tid
   • the active task
6. return value
   • dummy
   • different return value for the active task, which goes in its TD
7. state
   • READY
8. install in the ready queues
   • pointers in the TD

Must also create the initial stack

• exactly as if the task had just done a kernel entry
• look carefully at what your kernel exit code will do
• At the end stack pointer must correspond to stack contents
• I initialize the stack pointer to the top of allocated memory
  • my stacks grow down

  then change it as I push stuff onto the stack imitating the context switch code

The Create Function

You also need a int Create( int priority, void (*code) ( ) ) function to call from user tasks.

Although it's no more than a wrapper there are a few problems to solve.

1. Passing arguments
   • On entry the arguments are somewhere, usually r0 & r1
   • You have to put them where the kernel can find them.
   • gcc's function extry code immediately puts them on the stack.
   • In assembly you can find them using the frame pointer.
2. Jumping into the kernel
3. Getting the return value from the kernel and returning it.
   • You find it where the kernel put it
   • gcc's function exit code expects it to be indexed off the frame pointer
     • from where it does into r0

What follows just seems to say the same thing again. But we might as well leave it here because some student might find it useful.

How do we implement the API for user code?

1. This requires a bit of assembly language.
2. In assembly language all arguments & return values are words.
   • usually pointers
   • stored in registers
   • What happens when there are too many arguments?
3. What happens when Create is called?
   • Two arguments
     • stored in r0 and r1
     • which is which?
   • Immediately placed on the stack, referred to by fp
   • Create puts them in the special place you choose
     • r0, r1 ?
   • swi switches context into the kernel.
4. What happens when Create returns?
   • When the kernel is finished manipulating TDs and PQs
     • it knows the tid to be returned
     • it places the tid in the caller's return value in its TD
   • When the caller is next activated,
     • as part of activation the return value is put in your special place, usually r0
     • user code has to get it and put it in the compiler's special place, r0 for gcc.

Return to:

• Bill Cowan's Fall 2009 CS452 page
• Bill Cowan's CS452 page
• Bill Cowan's teaching page
• Bill Cowan's home page