Desktop/xinu_mips-1.0.2.tar/xinu_mips-1.0.2/system/create.c

Go to the documentation of this file.

/* Embedded XINU, Copyright (C) 2007.  All rights reserved. */
  
#include <kernel.h>
#include <proc.h>
#include <vararg.h>
#include <mips.h>
#include <memory.h>
#include <string.h>

local newpid(void);
void userret(void);

syscall create(void *procaddr, ulong ssize, ushort priority,
               char *name, ulong nargs, ...)
{
        ulong   *saddr;     /* stack address                */
        ulong   *savargs;   /* pointer to arg saving region */
        ulong   pid;        /* stores new process id        */
        pcb     *ppcb;      /* pointer to proc control blk  */
        ulong   i;
        va_list ap;         /* points to list of var args   */
        ulong   pads;       /* padding entries in record.   */
        void    INITRET(void);

        if (ssize < MINSTK) ssize = MINSTK;
        ssize = (ulong)roundew(ssize);  /* round up to even boundary    */
        saddr = (ulong *)getmem(ssize); /* allocate new stack and pid   */
        pid   = newpid();
                                        /* a little error checking      */ 
        if ( (((ulong *)SYSERR) == saddr) || (SYSERR == pid) )
        { return SYSERR; }

        numproc++;
        ppcb = &proctab[ pid ];
                                    /* setup PCB entry for new proc */
        ppcb->state   = PRSUSP;
        ppcb->prio    = priority;
        ppcb->stkbase = saddr;
        saddr = (ulong *)(((ulong)saddr) + ssize - sizeof(ulong));
        ppcb->stklen  = ((ulong)saddr) - (ulong)ppcb->stkbase;
        ppcb->stkptr  = saddr;
        strncpy(ppcb->name, name, PNMLEN);
        ppcb->parent  = (ushort)getpid();

        /* Initialize stack with accounting block. */
        *saddr   = STACKMAGIC;
        *--saddr = pid;
        *--saddr = ppcb->stklen;
        *--saddr = (ulong)ppcb->stkbase;
        
        if (0 == nargs)
        { pads = 4; } 
        else if (0 == (nargs % 4))           /* Must pad record size to      */
        { pads = 0; }                        /*  multiple of native memory   */
        else                                 /*  transfer size.              */
        { pads = 4 - (nargs % 4); }

        for (i = 0; i < pads; i++) { *--saddr = 0; }
                                    /* Reserve space for all args.  */
        for (i = nargs ; i > 0 ; i--) { *--saddr = 0; }
        savargs = saddr;          

        /* Build the context record as expected by ctxsw.               */
                                    /* Clear room for saved state.  */
        for (i = (CONTEXT_WORDS); i > 0; i--) { *--saddr = 0; }
        ppcb->stkptr = saddr;
                                        /* Address of proc entry point  */
        saddr[(CONTEXT_WORDS) - 1] = (ulong)procaddr;      
                                        /* Return Address value         */
        saddr[(CONTEXT_WORDS) - 2] = (ulong)INITRET;      

        /* Place arguments into activation records. */
        va_start(ap, nargs);
        for (i = 0; i < nargs; i++)
        { savargs[i] = va_arg(ap, ulong); }
        va_end(ap);

        return pid;
}

local newpid(void)
{
        int     pid;                    /* process id to return     */
        static int nextpid = 0;

        for (pid = 0 ; pid < NPROC ; pid++) 
        {                       /* check all NPROC slots    */
                nextpid = (nextpid + 1) % NPROC;
            if (PRFREE == proctab[nextpid].state)
                { return nextpid; }
        }
        return SYSERR;
}

void userret(void)
{
        kill( getpid() );
}

---