memcmds.c

完整的Bell实验室的嵌入式文件系统TFS

        for(wptr=(ushort *)start;wptr<(ushort *)finish;wptr++) {
            *wptr = wdata;
            if (*wptr != wdata) {
                err = 1;
                error_at = (ulong)wptr;
                break;
            }
        }
        break;
    case 4:
        ldata = (ulong) strtoul(argv[optind+2],0,0);
        for(lptr=(ulong *)start;lptr<(ulong *)finish;lptr++) {
            *lptr = ldata;
            if (*lptr != ldata) {
                err = 1;
                error_at = (ulong)lptr;
                break;
            }
        }
        break;
    }
    if (err) {
        printf("Error at 0x%lx\n",error_at);
        return(CMD_FAILURE);
    }
    return(CMD_SUCCESS);
}

/* Sm():
 *  Search memory.
 */

char *SmHelp[] = {
    "Search Memory",
    "-[24cnqsx] {start} {finish|byte-cnt} {srchfor}",
    " -2   short access",
    " -4   long access",
    " -c   arg2 is count (in bytes)",
    " -n   srchfor_not (NA for -s or -x)",
    " -q   quit after first search hit",
    " -s   string srch",
    " -x   hexblock srch",
        0,
};

#define SM_NORMAL       1       /* Search for 1 value */
#define SM_STRING       2       /* Search for ascii string */
#define SM_HEXBLOCK     3       /* Search for block of hex data */

int
Sm(int argc,char *argv[])
{
    ulong   start, finish;
    int     width, opt, i, j, mode, arg2iscount, not, quit;
    char    *srchfor, tmp;
    uchar   *cptr, cdata, data[32];
    ushort  *wptr, wdata;
    ulong   *lptr, ldata;

    not = 0;
    quit = 0;
    width = 1;
    arg2iscount = 0;
    mode = SM_NORMAL;
    while((opt=getopt(argc,argv,"24cnqsx")) != -1) {
        switch(opt) {
        case '2':
            width = 2;
            break;
        case '4':
            width = 4;
            break;
        case 'c':
            arg2iscount = 1;
            break;
        case 'n':
            not = 1;                /* opposite logic SM_NORMAL only. */
            break;
        case 'q':
            quit = 1;               /* quit after first [no]match */
            break;
        case 's':
            mode = SM_STRING;       /* ascii string */
            break;
        case 'x':
            mode = SM_HEXBLOCK;     /* hex data */
            break;
        default:
            return(CMD_PARAM_ERROR);
        }
    }

    if (argc != optind+3)
        return(CMD_PARAM_ERROR);

    start = strtoul(argv[optind],(char **)0,0);
    finish = strtoul(argv[optind+1],(char **)0,0);
    if (arg2iscount)
        finish = start + finish;
    srchfor = argv[optind+2];

    if (mode == SM_HEXBLOCK) {
        char    *ex;

        if (not)
            return(CMD_PARAM_ERROR);
        ex = strpbrk(srchfor,"xX");
        if (ex)
            srchfor=ex+1;
        if (strlen(srchfor) % 2)
            return(CMD_PARAM_ERROR);
        for(i=0,j=0;i<(sizeof data);i++,j+=2) {
            if (srchfor[j] == 0)
                break;
            tmp = srchfor[j+2];
            srchfor[j+2] = 0;
            data[i] = (uchar)strtoul(&srchfor[j],0,16);
            srchfor[j+2] = tmp;
        }
        for(cptr=(uchar *)start;cptr<(uchar *)finish;cptr++) {
            if (memcmp(cptr,data,i) == 0) {
                printf("Match @ 0x%lx\n",(ulong)cptr);
                if (quit)
                    break;
            }
        }
        return(CMD_SUCCESS);
    }
    else if (mode == SM_STRING) {
        int len;

        if (not)
            return(CMD_PARAM_ERROR);
        len = strlen(srchfor);
        for(cptr=(uchar *)start;cptr<(uchar *)finish;cptr++) {
            if (strncmp(cptr,srchfor,len) == 0) {
                printf("Match @ 0x%lx\n",(ulong)cptr);
                if (quit)
                    break;
            }
        }
    }
    else if (width == 1) {
        cdata = (uchar)strtoul(srchfor,(char **)0,0);
        for(cptr=(uchar *)start;cptr<(uchar *)finish;cptr++) {
            if (not) {
                if (*cptr != cdata) {
                    printf("Nomatch @ 0x%lx (0x%x)\n",(ulong)cptr,*cptr);
                    if (quit)
                        break;
                }
            }
            else if (*cptr == cdata) {
                printf("Match @ 0x%lx\n",(ulong)cptr);
                if (quit)
                    break;
            }
        }
    }
    else if (width == 2) {
        wdata = (ushort)strtoul(srchfor,(char **)0,0);
        for(wptr=(ushort *)start;wptr<(ushort *)finish;wptr++) {
            if (not) {
                if (*wptr != wdata) {
                    printf("Nomatch @ 0x%lx (0x%x)\n",(ulong)wptr,*wptr);
                    if (quit)
                        break;
                }
            }
            else if (*wptr == wdata) {
                printf("Match @ 0x%lx\n",(ulong)wptr);
                if (quit)
                    break;
            }
        }
    }
    else {
        ldata = (ulong)strtoul(srchfor,(char **)0,0);
        for(lptr=(ulong *)start;lptr<(ulong *)finish;lptr++) {
            if (not) {
                if (*lptr != ldata) {
                    printf("Nomatch @ 0x%lx (0x%lx)\n",(ulong)lptr,*lptr);
                    if (quit)
                        break;
                }
            }
            else if (*lptr == ldata) {
                printf("Match @ 0x%lx\n",(ulong)lptr);
                if (quit)
                    break;
            }
        }
    }
    return(CMD_SUCCESS);
}

/* Cm():
 *  Copy memory.
 *
 *  Arguments...
 *  arg1:       source address
 *  arg2:       destination address
 *  arg3:       byte count
 *
 *  Options...
 *  -2  access as a short.
 *  -4  access as a long.
 *  -f  fifo access (address does not increment).
 *  -v  verify (only) that the range specified, is copied.
 */

char *CmHelp[] = {
    "Copy Memory",
    "-[24fv] {src} {dst} {byte-cnt}",
    " -2   short access",
    " -4   long access",
    " -f   fifo mode",
    " -v   verify only",
    0,
};

int
Cm(int argc,char *argv[])
{
    ulong   src, dest, end, bytecount;
    int opt, width, fifo, verify, verify_failed;

    width = 1;
    fifo = verify = 0;
    verify_failed = 0;
    while((opt=getopt(argc,argv,"24fv")) != -1) {
        switch(opt) {
        case '2':
            width = 2;
            break;
        case '4':
            width = 4;
            break;
        case 'f':
            fifo = 1;
            break;
        case 'v':
            verify = 1;
            break;
        default:
            return(CMD_PARAM_ERROR);
        }
    }

    if (argc != optind+3) {
        return(CMD_PARAM_ERROR);
    }
    if ((verify) && (fifo)) {
        printf("Can't verify in fifo mode\n");
        return(CMD_FAILURE);
    }

    src = strtoul(argv[optind],(char **)0,0);
    dest = strtoul(argv[optind+1],(char **)0,0);
    bytecount = strtoul(argv[optind+2],(char **)0,0);

    end = src+bytecount;
    if (width == 1) {
        while(src < end) {
            if (verify) {
                if (*(uchar *)dest != *(uchar *)src) {
                    verify_failed = 1;
                    break;
                }
            }
            else 
                *(uchar *)dest = *(uchar *)src;
            if (!fifo)
                dest++;
            src++;
        }
    }
    else if (width == 2) {
        while(src < end) {
            if (verify) {
                if (*(ushort *)dest != *(ushort *)src) {
                    verify_failed = 1;
                    break;
                }
            }
            else
                *(ushort *)dest = *(ushort *)src;
            if (!fifo)
                dest += 2;
            src += 2;
        }
    }
    else {  /* width == 4 */
        while(src < end) {
            if (verify) {
                if (*(ulong *)dest != *(ulong *)src) {
                    verify_failed = 1;
                    break;
                }
            }
            else
                *(ulong *)dest = *(ulong *)src;
            if (!fifo)
                dest += 4;
            src += 4;
        }
    }
    if ((verify) && (verify_failed)) {
        printf("Verify failed: *0x%lx != *0x%lx\n",src,dest);
        return(CMD_FAILURE);
    }
    return(CMD_SUCCESS);
}

/* Mt():
 *  Memory test
 *  Walking ones and address-in-address tests for data and address bus
 *  testing respectively.  This test, within the context of a monitor
 *  command, has limited value.  It must assume that the memory space
 *  from which this code is executing is sane (obviously, or the code
 *  would not be executing) and the ram used for stack and bss must
 *  already be somewhat useable.
 */
char *MtHelp[] = {
    "Memory test",
    "-[w] {addr} {length}",
    " -w   wait-for-user between addr write and readback",
    "Walking ones followed by address-in-address",
    "Note: hit any key to abort test with errors",
    0,
};

int
Mt(int argc,char *argv[])
{
    int errcnt, len, testaborted, opt;
    ulong   arg1, arg2, *start, wait_for_user;
    register ulong *end, walker, readback;
    register volatile ulong *addr;

    wait_for_user = 0;
    while((opt=getopt(argc,argv,"w")) != -1) {
        switch(opt) {
        case 'w':
            wait_for_user = 1;
            break;
        default:
            return(CMD_PARAM_ERROR);
        }
    }

    if (argc != optind+2)
        return(CMD_PARAM_ERROR);

    arg1 = strtoul(argv[optind],(char **)0,0);      /* start */
    arg2 = strtoul(argv[optind+1],(char **)0,0);    /* length */

    arg1 &= ~0x3;   /* Word align */
    arg2 &= ~0x3;

    printf("Testing 0x%lx .. 0x%lx\n",arg1,arg1+arg2);

    start = (ulong *)arg1;
    len = (int)arg2;
    testaborted = errcnt = 0;

    /***********************************************************/
    /****** Walking Ones test for data-bus verification: *******/
    /***********************************************************/

    /* Write 32 locations, each with a different bit set, then */
    /* read back those 32 locations and make sure the bit is set. */
    walker = 1;
    end = start + 32;
    for (addr=(ulong *)start;addr<end;addr++) {
        *addr = walker;
        walker <<= 1;
    }

    walker = 1;
    for (addr=start;addr<end;addr++) {
        readback = *addr;
        if (readback != walker) {
            errcnt++;
            printf("WalkingOnesErr @ 0x%08lx read 0x%08lx expected 0x%08lx\n",
                (ulong)addr,readback,walker);
            if (gotachar()) {
                testaborted = 1;
                break;
            }
        }
        walker <<= 1;
    }

    /********************************************************************/
    /****** Address-in-address test for address-bus verification: *******/
    /********************************************************************/

    /* If the walking-ones test detected an error in the data bus, then */
    /* don't bother running the address bus test. */

    if (!errcnt && !testaborted) {

        /* Store the address in each address, then read it back. */
        end = (ulong *)((int)start + len);
        for (addr=start;addr<end;addr++)
            *addr = (ulong)addr;

        /* If -w is specified, then wait for user to say continue. */
        if (wait_for_user)
            hitakey();
    
        /* check that each address contains its address */
        for (addr=start;addr<end;addr++) {
            readback = *addr;
            if (readback != (ulong)addr) {
                errcnt++;
                printf("AddInAddErr @ 0x%08lx read 0x%08lx\n",
                    (ulong)addr,readback);
                if (gotachar()) {
                    testaborted = 1;
                    break;
                }
            }
        }
    }
    printf("Found %d errors\n", errcnt);
    if (errcnt)
        return(CMD_FAILURE);
    else
        return(CMD_SUCCESS);
}


#endif