dbcmd.c

最近在國外網站抓到的作業系統 以Arm為基礎去開發的

//*************************************************************************
//
//  Copyright (C) SEIKO EPSON CORP. 1997
//  All Rights Reserved
//
//  Filename : dbcmd.c
//  Function : debug command for ros33
//  Revision :
//          2001/05/22  Y.Taka      start
//
//*************************************************************************

#include <stdio.h>
#include "ros33.h"
#include "INTERNAL.H"

#define PRT_BUFSZ  2048       /* print buffer size (0x0800) */

#define STID_SYS  0           /* print_queue paramater */
#define STID_TSK  1

int cnt, rtncode;
int stano, endno;
int taskflag;
char syschar[5], tskchar[4], waichar[5];

struct {                      /* sprintf buffer */
    int  size;
    char buf[PRT_BUFSZ];
} tmpbuf;

typedef struct                /* Control Table of Memory Pool */
{
    UW      ulAddrTbl;
    UW      ulSizeTbl;
} sTable;

//***********************************************************************
//  check print buffer size subroutine 
//***********************************************************************
static int chk_prtbuf(int chksize)
{
    if(chksize > (PRT_BUFSZ - tmpbuf.size)){
        cnt = sprintf(tmpbuf.buf+tmpbuf.size,
                  "Warning: Stop by print buffer full.\n");
        tmpbuf.size += cnt;

        return -1;
    }
    return 0;
}

//***********************************************************************
//  check parameter subroutine 
//***********************************************************************
static int chk_param(int arg1, int arg2, int maxnum)
{
    if((arg1 < 0) | (arg1 > maxnum)){   /* illegal parameter */
        return -1;
    }

    if(arg1 == 0){            /* all display (1->maxnum) */
        stano = 1;
        endno = maxnum;
        return 0;
    }

    if(arg2 > arg1){
        if(arg2 > maxnum){ 
            stano = arg1;     /* arg1->maxnum */
            endno = maxnum;
        }else{
            stano = arg1;     /* arg1->arg2 */
            endno = arg2;
        }
    }else{
        stano = arg1;         /* arg1 only */
        endno = arg1;
    }
    return 1;
}

//***********************************************************************
//  print queue list subroutine 
//***********************************************************************
static void print_queue(T_NODE* pMember)
{
    T_NODE* pTskcb;
    int iflag;
    int n;

    pTskcb = pMember->pNxt;             /* get next task-address */
    iflag = 0;

    while(pTskcb != pMember){           /* if next address is head */
        n = 0;                          /* search task(n) */
        while((T_NODE*)&g_sTskcb[n] != pTskcb){
            n++;                        /* task-no count up */
            if(n == TSK_NUM){
                break;                  /* not found(illegal) */ 
            }
        }
        if(iflag == 0){                 /* display head task */
            cnt = sprintf(tmpbuf.buf+tmpbuf.size,"task%d", n+1);
            tmpbuf.size += cnt;
            iflag = 1;
        }else{                          /* display continue task */
            cnt = sprintf(tmpbuf.buf+tmpbuf.size,"->task%d", n+1);
            tmpbuf.size += cnt;
        }
        pTskcb = pTskcb->pNxt;          /* get next task-address */
    }
    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"\n");   /* display end */
    tmpbuf.size += cnt;
    return;
}

//***********************************************************************
//  print handler queue list subroutine 
//***********************************************************************
static void print_hndrque(T_NODE* pMember)
{
    T_NODE* pHndrcb;
    int iflag;
    int n;

    pHndrcb = pMember->pNxt;                      /* get next address */
    iflag = 0;

    while(pHndrcb != pMember){                    /* if next is head */
        n = 0;                                    /* search cyc(n) */
        while((T_NODE*)&g_sCycHndrcb[n] != pHndrcb){
            n++;
            if(n == CYCHNDR_NUM){
                break;                            /* not found */
            }
        }
        if(n < CYCHNDR_NUM){                      /* display cyc(n) */
            if(iflag == 0){
                cnt = sprintf(tmpbuf.buf+tmpbuf.size," cycno%d", n+1);
                tmpbuf.size += cnt;
                iflag = 1;
            }else{
                cnt = sprintf(tmpbuf.buf+tmpbuf.size,"->cycno%d", n+1);
                tmpbuf.size += cnt;
            }

        }else{
            n = 0;                                /* search alm(i) */
            while((T_NODE*)&g_sAlmHndrcb[n] != pHndrcb){
                n++;
                if(n == ALMHNDR_NUM){
                    break;                        /* not found */
                }
            }
            if(n < ALMHNDR_NUM){                  /* display alm(n) */
                if(iflag == 0){
                    cnt = sprintf(tmpbuf.buf+tmpbuf.size," almno%d", n+1);
                    tmpbuf.size += cnt;
                    iflag = 1;
                }else{
                    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"->almno%d", n+1);
                   tmpbuf.size += cnt;
                }
            }
        }

        pHndrcb = pHndrcb->pNxt;          /* get next handler-address */
    }
    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"\n");
    tmpbuf.size += cnt;
    return;
}

//***********************************************************************
//  print status character subroutine 
//***********************************************************************
static void print_status(INT stid, T_TSKCB* pTskcb)
{
    if(stid == STID_SYS){                /* STID = SYS */
        switch(g_ubSysStat){
        case TSS_TSK:        strcpy(syschar, "TSK "); break;
        case TSS_DDSP:       strcpy(syschar, "DDSP"); break;
        case TSS_LOC:        strcpy(syschar, "LOC "); break;
        case TSS_INDP:       strcpy(syschar, "INDP"); break;
        }
        return;
    }
                                        /* STID = TSK */
    strcpy(waichar, "    ");
    if(pTskcb->ubStatus & TTS_DMT){     /* get task status(tskchar) */
        taskflag = 0;                   /* set taskflag=0 DMT */
        strcpy(tskchar, "DMT");
    }else{
        if(pTskcb->ubStatus & TTS_RUN){
            taskflag = 1;               /* set taskflag=1 RUN */
            strcpy(tskchar, "RUN");
        }
        if(pTskcb->ubStatus & TTS_RDY){
            taskflag = 2;               /* set taskflag=2 RDY */
            strcpy(tskchar, "RDY");
        }
                                        /* get wait status(waichar) */
        if(pTskcb->ubStatus & TTS_WAI){
            switch(pTskcb->ubWaitStat){
            case TTW_SLP:        strcpy(waichar, "SLP"); break;
            case TTW_DLY:        strcpy(waichar, "DLY"); break;
            case TTW_FLG:        strcpy(waichar, "FLG"); break;
            case TTW_SEM:        strcpy(waichar, "SEM"); break;
            case TTW_MBX:        strcpy(waichar, "MBX"); break;
            case TTW_SMBF:       strcpy(waichar, "SMBF"); break;
            case TTW_MBF:        strcpy(waichar, "MBF"); break;
            case TTW_MPL:        strcpy(waichar, "MPL"); break;
            case TTW_MPF:        strcpy(waichar, "MPF"); break;
            }
            if(pTskcb->ubStatus & TTS_SUS){
                taskflag = 5;           /* set taskflag=5 WAS */
                strcpy(tskchar, "WAS");
            }else{
                taskflag = 4;           /* set taskflag=4 WAI */
                strcpy(tskchar, "WAI");
            }
        }else{
            if(pTskcb->ubStatus & TTS_SUS){
                taskflag = 3;           /* set taskflag=3 SUS */
                strcpy(tskchar, "SUS");
            }
        }
    }
    return;
}

//***********************************************************************
//  print memory block in memory pool subroutine 
//***********************************************************************
static void print_memblk(T_MPLCB* pMplcb)
{
    sTable* stTblPtr;
    UW  ulSizeWk;
    UW  ulStartadr;
    UW  ulEndadr;
    char usechar[2];
    int n;

    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"### memory pool data\n");
    tmpbuf.size += cnt;

    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"ROW USE    startadr endadr   blocksize\n");
    tmpbuf.size += cnt;

    stTblPtr = (sTable *)(pMplcb->EndAlloc - 8);  /* start table pointer */
    for(n = 0; n < pMplcb->ulRow; n++, stTblPtr--){
        if((stTblPtr->ulSizeTbl & 0x80000000 ) == 0){  /* set usechar(-,*) */
            strcpy(usechar, "-");
        }else{
            strcpy(usechar, "*");
        }

        ulSizeWk = stTblPtr->ulSizeTbl & 0x7fffffff;   /* get block size */
        ulStartadr = stTblPtr->ulAddrTbl;              /* get start address */
        ulEndadr = stTblPtr->ulAddrTbl + ulSizeWk;     /* get end address */

        cnt = sprintf(tmpbuf.buf+tmpbuf.size,"%-3d  %s     %08x %08x %08x\n",
                  n+1, usechar, ulStartadr, ulEndadr, ulSizeWk);
        tmpbuf.size += cnt;
    }
    ulStartadr = (UW)pMplcb->NxtAlcp;                  /* print free erea */
    ulEndadr = (UW)pMplcb->TblPtr;
    ulSizeWk = ulEndadr - ulStartadr;

    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"free area  %08x %08x %08x\n",
              ulStartadr, ulEndadr, ulSizeWk);
    tmpbuf.size += cnt;

    return;
}

//***********************************************************************
//  1.1 Management Data (call mng)
//  This function is called from db33.This iprint_mng command prints 
//  ROS33 management data.
//***********************************************************************
int *iprint_mng(int arg1, int arg2, int arg3)
{
    int i;

    print_status(STID_SYS, 0);               /* get system status(syschar) */

    cnt = sprintf(tmpbuf.buf,"system status    (%08x): %-4s\n",
                     &g_ubSysStat, syschar);
    tmpbuf.size = cnt;

    i = 0;                                   /* search task number(taski) */
    while(&g_sTskcb[i] != g_pCurTsk){
        i++;
        if(i == TSK_NUM){
            break;
        }
    }
    if(i < TSK_NUM){
        cnt = sprintf(tmpbuf.buf+tmpbuf.size,"task ID          (%08x): task%d\n",
                  &g_pCurTsk, i+1);
    }else{                                   /* not found of task */
        cnt = sprintf(tmpbuf.buf+tmpbuf.size,"task ID          (%08x): -\n",
                  &g_pCurTsk);
    }
    tmpbuf.size += cnt;

    i = 0;                                   /* search cyc number(cycnoi) */
    while(&g_sCycHndrcb[i] != g_pCurHndr){
        i++;
        if(i == CYCHNDR_NUM){
            break;
        }
    }
    if(i < CYCHNDR_NUM){
        cnt = sprintf(tmpbuf.buf+tmpbuf.size,"handler ID       (%08x): cycno%d\n",
                  &g_pCurHndr, i+1);
    }else{
        i = 0;                               /* search alm number(almnoi) */
        while(&g_sAlmHndrcb[i] != g_pCurHndr){
            i++;
            if(i == ALMHNDR_NUM){
            break;
            }
        }
        if(i < ALMHNDR_NUM){
            cnt = sprintf(tmpbuf.buf+tmpbuf.size,
                      "handler ID       (%08x): %08x(almno%d)\n",
                      &g_pCurHndr, g_pCurHndr, i+1);

        }else{                               /* not found of cyc,alm handler */
            cnt = sprintf(tmpbuf.buf+tmpbuf.size,"handler ID       (%08x): -\n",
                      &g_pCurHndr);
        }
    }
    tmpbuf.size += cnt;

    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"system time      (%08x): %04x %08x\n",
            &g_sSysTime, g_sSysTime.utime, g_sSysTime.ltime);
    tmpbuf.size += cnt;

    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"delay dispatch   (%08x): %d\n",
                     &g_blDelay, g_blDelay);
    tmpbuf.size += cnt;

    cnt = sprintf(tmpbuf.buf+tmpbuf.size,"int nest counter (%08x): %d\n",
                     &g_ubIntNestCnt, g_ubIntNestCnt);
    tmpbuf.size += cnt;

    tmpbuf.size ++;                     /* ++ is null */
    return (int*)&tmpbuf;
}

//***********************************************************************
//  2.1 Queue List Data (call rdy)
//  This function is called from db33.This iprint_rdy command prints 
//  ROS33 ready queue list data.
//***********************************************************************
int *iprint_rdy(int arg1, int arg2, int arg3)
{
    T_NODE* pTskcb;
    int i;

    rtncode = chk_param(arg1, arg2, MAX_TSKPRI);

    if(rtncode < 0){              /* illegal parameter */
        cnt = sprintf(tmpbuf.buf,"NONE\n");
        tmpbuf.size = cnt+1;      /* +1 is null */
        return (int*)&tmpbuf;