home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 December / simtel1292_SIMTEL_1292_Walnut_Creek.iso / msdos / sysutl / emsuit11.arc / DISKTEST.C next >
Text File  |  1990-02-22  |  14KB  |  448 lines
  1. /***************************************************************************
  2.  *     DISKTEST vers 1.0, DOS                                              *
  3.  *     Checks EMS to EMS-ramdisk writes                                    *
  4.  *     12/30/89                                                            *
  5.  *     by James W. Birdsall                                                *
  6.  *                                                                         *
  7.  *     compiles under Turbo C 2.0 USING THE COMPACT MODEL!                 *
  8.  *                                                                         *
  9.  *   Usage: DISKTEST drive                                                 *
  10.  *   where drive is a single letter corresponding to a valid disk drive.   *
  11.  *   This program is used to test EMS ramdisks. It attempts to write       *
  12.  *   directly from the EMS page frames to the ramdisk and then checks the  *
  13.  *   file written. Many EMS ramdisks do not check the address of the       *
  14.  *   origin and will conflict with one or more pages.                      *
  15.  *                                                                         *
  16.  ***************************************************************************/
  17.  
  18.  
  19. #include <stdio.h>
  20. #include <dos.h>
  21. #include <io.h>
  22. #include <alloc.h>
  23. #include <signal.h>
  24.  
  25.  
  26.  
  27. #define VERSION 1.0
  28. #define COLUMNS 5               /* columns to use printing frame pointers */
  29.  
  30.  
  31.  
  32. char copyright[] = "Copyright (c) 1989 James W. Birdsall. All Rights Reserved";
  33.  
  34.  
  35.  
  36. int checkEMM(void);
  37. void releaseEMS(void);
  38. void restoreEMS(void);
  39. int hardhandler(int, int, int, int);
  40. void breakhandler(void);
  41.  
  42.  
  43.  
  44. int handle;                     /* EMS handle */
  45. int vers;                       /* EMS version */
  46. void *mapbuffer;                /* page map buffer for 4.0 */
  47.  
  48.  
  49.  
  50. /***************************************************************************
  51.  *     FUNCTION MAIN                                                       *
  52.  ***************************************************************************/
  53. main(int argc, char *argv[])
  54. {
  55.    union REGS r;
  56.    struct SREGS s;
  57.    int vers, frames;
  58.    unsigned int *junkbuffer;
  59.    void **framebuffer;
  60.    int t1, t3;
  61.    char filename[] = "c:disktest.tst";
  62.    FILE *testfile;
  63.    unsigned char *walker;
  64.    long t2;
  65.    long trigger1, trigger2;
  66.  
  67.  
  68.    /* check for argument */
  69.    if (argc == 1) {
  70.       printf("Disk letter required to execute tests.\n");
  71.       exit(5);
  72.       }
  73.    /* set up test filename using disk letter */
  74.    filename[0] = argv[1][0];
  75.    /* check for EMM */
  76.    if (checkEMM() == 0) {
  77.       printf("EMS manager not present or malfunctioning.\n");
  78.       exit(3);
  79.       }
  80.    /* install hardware-error and ctrl-brk handlers */
  81.    harderr(hardhandler);
  82.    signal(SIGINT, breakhandler);
  83.  
  84.    printf("DISKTEST vers %.1f by James W. Birdsall\n", VERSION);
  85.    printf("   EMS to disk write tests on disk %c: with ", argv[1][0]);
  86.  
  87.    /* get version */
  88.    r.h.ah = 0x46;
  89.    int86(0x67, &r, &r);
  90.    if (r.h.ah != 0) {
  91.       printf("\nError 0x%x talking to EMS manager.\n", r.h.ah);
  92.       exit(3);
  93.       }
  94.    if ((r.h.al >> 4) < 3) {
  95.       printf("\nDISKTEST requires LIM EMS version 3.0 or better.\n");
  96.       exit(2);
  97.       }
  98.    printf("LIM EMS version %d.%d\n", r.h.al >> 4, r.h.al & 0x0F);
  99.    /* set up vers: 1 if 4.0 or better, 0 if not */
  100.    if ((r.h.al >> 4) >= 4) {
  101.       vers = 1;
  102.       }
  103.      else {
  104.       vers = 0;
  105.       }
  106.  
  107.    /* get/calculate frame addresses */
  108.    if (vers == 0) {
  109.       frames = 4;
  110.       /* 3.0/3.2 get page frame address */
  111.       r.h.ah = 0x41;
  112.       int86(0x67, &r, &r);
  113.       if (r.h.ah != 0) {
  114.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  115.          exit(3);
  116.          }
  117.       /* synthesize buffer in style of 4.0, calculate addresses of */
  118.       /* higher frames */
  119.       if ((junkbuffer = (unsigned int *) farcalloc(frames,
  120.                                       2 * sizeof(unsigned int))) == NULL) {
  121.          printf("Error allocating memory.\n");
  122.          exit(4);
  123.          }
  124.       junkbuffer[0] = r.x.bx;
  125.       junkbuffer[2] = r.x.bx + 0x400;
  126.       junkbuffer[4] = r.x.bx + 0x800;
  127.       junkbuffer[6] = r.x.bx + 0xC00;
  128.       }
  129.      else {
  130.       /* 4.0 get number of mappable pages == number of frames */
  131.       r.x.ax = 0x5801;
  132.       int86(0x67, &r, &r);
  133.       if (r.h.ah != 0) {
  134.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  135.          exit(3);
  136.          }
  137.       frames = r.x.cx;
  138.       /* allocate buffer */
  139.       if ((junkbuffer = (unsigned int *) farcalloc(frames,
  140.                                       2 * sizeof(unsigned int))) == NULL) {
  141.          printf("Error allocating memory.\n");
  142.          exit(4);
  143.          }
  144.       /* and fill: 4.0 get addresses of mappable pages */
  145.       r.x.ax = 0x5800;
  146.       r.x.di = (unsigned int) FP_OFF(junkbuffer);
  147.       s.es = (unsigned int) FP_SEG(junkbuffer);
  148.       int86x(0x67, &r, &r, &s);
  149.       if (r.h.ah != 0) {
  150.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  151.          exit(3);
  152.          }
  153.       }
  154.  
  155.    /* print number of frames */
  156.    printf("%d frames at addresses:\n", frames);
  157.  
  158.    /* create array of far pointers to frames */
  159.    if ((framebuffer = (void **) farcalloc(frames, sizeof(void *))) == NULL) {
  160.       printf("Error allocating memory.\n");
  161.       exit(4);
  162.       }
  163.    /* and print */
  164.    for(t1 = 0; t1 < frames; t1++) {
  165.       framebuffer[t1] = MK_FP(junkbuffer[t1*2], 0);
  166.       printf("%Fp      ", framebuffer[t1]);
  167.       if (((t1 + 1) % COLUMNS) == 0) {
  168.          printf("\n");
  169.          }
  170.       }
  171.    if (t1 % COLUMNS) {
  172.       printf("\n");
  173.       }
  174.    /* get rid of original buffer */
  175.    free(junkbuffer);
  176.  
  177.    /* get number of free pages */
  178.    r.h.ah = 0x42;
  179.    int86(0x67, &r, &r);
  180.    if (r.h.ah != 0) {
  181.       printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  182.       exit(3);
  183.       }
  184.    /* check if enough to fill all frames */
  185.    if (r.x.bx < frames) {
  186.       printf("Insufficient free pages for test.\n");
  187.       exit(5);
  188.       }
  189.  
  190.    /* allocate as many pages as frames */
  191.    r.h.ah = 0x43;
  192.    r.x.bx = frames;
  193.    int86(0x67, &r, &r);
  194.    if (r.h.ah != 0) {
  195.       printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  196.       exit(3);
  197.       }
  198.    handle = r.x.dx;
  199.    /* install exit handler to release pages upon exit */
  200.    atexit(releaseEMS);
  201.  
  202.    /* save page map by version */
  203.    if (vers == 0) {
  204.       /* 3.0/3.2 save page map */
  205.       r.h.ah = 0x47;
  206.       r.x.dx = handle;
  207.       int86(0x67, &r, &r);
  208.       if (r.h.ah != 0) {
  209.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  210.          exit(3);
  211.          }
  212.       }
  213.      else {
  214.       /* 4.0 get size of page-map information */
  215.       r.x.ax = 0x4E03;
  216.       int86(0x67, &r, &r);
  217.       if (r.h.ah != 0) {
  218.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  219.          exit(3);
  220.          }
  221.       /* allocate page-map buffer */
  222.       if ((mapbuffer = (void *) farmalloc(r.h.al)) == NULL) {
  223.          printf("Error allocating memory.\n");
  224.          exit(4);
  225.          }
  226.       /* 4.0 save page map */
  227.       r.x.ax = 0x4E00;
  228.       r.x.di = (unsigned int) FP_OFF(mapbuffer);
  229.       s.es = (unsigned int) FP_SEG(mapbuffer);
  230.       int86x(0x67, &r, &r, &s);
  231.       if (r.h.ah != 0) {
  232.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  233.          exit(3);
  234.          }
  235.       }
  236.    /* install exit handler to restore page map upon exit */
  237.    atexit(restoreEMS);
  238.  
  239.    /* fill each page with unique pattern */
  240.    printf("Filling page ");
  241.    for(t1 = 0; t1 < frames; t1++) {
  242.       /* map logical page into frame 0 */
  243.       r.h.ah = 0x44;
  244.       r.h.al = 0;
  245.       r.x.bx = t1;
  246.       r.x.dx = handle;
  247.       int86(0x67, &r, &r);
  248.       if (r.h.ah != 0) {
  249.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  250.          exit(3);
  251.          }
  252.       printf("%d ", t1);
  253.       /* fill with pattern */
  254.       walker = (unsigned char *) framebuffer[0];
  255.       for(t2 = 0; FP_OFF(walker) < 16384; walker++, t2 += (t1 + 1)) {
  256.          *walker = (t2 % 256);
  257.          }
  258.       }
  259.    printf("\n");
  260.  
  261.    /* remap to fill all frames */
  262.    printf("Pages filled, remapping and checking for accuracy.\n");
  263.    for(t1 = 0; t1 < frames; t1++) {
  264.       /* map logical page into frame with same number */
  265.       r.h.ah = 0x44;
  266.       r.h.al = t1;
  267.       r.x.bx = t1;
  268.       r.x.dx = handle;
  269.       int86(0x67, &r, &r);
  270.       if (r.h.ah != 0) {
  271.          printf("Error 0x%x talking to EMS manager.\n", r.h.ah);
  272.          exit(3);
  273.          }
  274.       }
  275.    /* and check each remapped page */
  276.    printf("Checking page ");
  277.    for(t1 = 0; t1 < frames; t1++) {
  278.       printf("%d ", t1);
  279.       walker = (unsigned char *) framebuffer[t1];
  280.       for(t2 = 0; FP_OFF(walker) < 16384; walker++, t2 += (t1 + 1)) {
  281.          if (*walker != (t2 % 256)) {
  282.             printf("Error encountered in page %d, offset %d!\n", t1,
  283.                                                           FP_OFF(walker));
  284.             exit(6);
  285.             }
  286.          }
  287.       }
  288.    printf("\nAll pages checked out. Starting individual write tests.\n");
  289.  
  290.    /* write each page/frame to file, then read back and check */
  291.    for(t1 = 0; t1 < frames; t1++) {
  292.       printf("Testing %d: Writing. ", t1);
  293.       /* open test file */
  294.       if ((testfile = fopen(filename, "wb")) == NULL) {
  295.          printf("Error opening file\n");
  296.          exit(7);
  297.          }
  298.       /* write from EMS frame */
  299.       if (fwrite(framebuffer[t1], sizeof(char), 16384, testfile) !=
  300.                                                                  16384) {
  301.          printf("Disk write error!\n");
  302.          exit(7);
  303.          }
  304.       /* close file */
  305.       fclose(testfile);
  306.       printf("Reading. ");
  307.       /* reopen for read */
  308.       if ((testfile = fopen(filename, "rb")) == NULL) {
  309.          printf("Error opening file\n");
  310.          exit(7);
  311.          }
  312.       /* check contents of file and contents of EMS frame (which may */
  313.       /* be being used by RAMdisk!                                   */
  314.       walker = (unsigned char *) framebuffer[t1];
  315.       trigger1 = trigger2 = 0;
  316.       for(t2 = 0; FP_OFF(walker) < 16384; walker++, t2 += (t1 + 1)) {
  317.          if ((t3 = fgetc(testfile)) != (t2 % 256)) {
  318.             if (trigger1 == 0) {
  319.                printf("Pattern violation in file.\n");
  320.                trigger1 = 1;
  321.                }
  322.             }
  323.          if (*walker != t3) {
  324.             if (trigger2 == 0) {
  325.                printf("Pattern violation in memory.");
  326.                trigger2 = 1;
  327.                }
  328.             }
  329.          }
  330.       /* if get through reads OK, print */
  331.       if ((trigger1 == 0) && (trigger2 == 0)) {
  332.          printf("Read OK.");
  333.          }
  334.       printf("\n");
  335.       /* close and erase file */
  336.       fclose(testfile);
  337.       unlink(filename);
  338.       }
  339.    printf("Tests completed.\n");
  340.  
  341.    exit(0);
  342. } /* end of function main */
  343.  
  344.  
  345.  
  346. /***************************************************************************
  347.  *     FUNCTION CHECKEMM                                                   *
  348.  *   Checks for function EMM. 1 = OK, 0 = error                            *
  349.  ***************************************************************************/
  350. int checkEMM(void)
  351. {
  352.    FILE *tempfile;
  353.    int temphandle;
  354.  
  355.    /* check if EMM is present */
  356.    if ((tempfile = fopen("EMMXXXX0","rb")) == NULL)
  357.       return 0;
  358.    /* make sure we've found a device and not a file */
  359.    temphandle = fileno(tempfile);
  360.    if ((ioctl(temphandle, 0) & 0x80) != 0x80)
  361.       return 0;
  362.    /* check status of EMM */
  363.    if (ioctl(temphandle, 7) <= 0)
  364.       return 0;
  365.    /* close and return */
  366.    fclose(tempfile);
  367.    return 1;
  368. } /* end of function checkEMM */
  369.  
  370.  
  371.  
  372. /***************************************************************************
  373.  *     FUNCTION RELEASEEMS                                                 *
  374.  *   Exit handler, releases allocated pages upon exit                      *
  375.  ***************************************************************************/
  376. void releaseEMS(void)
  377. {
  378.    union REGS r;
  379.  
  380.    /* release pages */
  381.    r.h.ah = 0x45;
  382.    r.x.dx = handle;
  383.    int86(0x67, &r, &r);
  384.    return;
  385. } /* end of function releaseEMS */
  386.  
  387.  
  388.  
  389. /***************************************************************************
  390.  *     FUNCTION RESTOREEMS                                                 *
  391.  *   Exit handler, restores page map and frees map buffer upon exit        *
  392.  ***************************************************************************/
  393. void restoreEMS(void)
  394. {
  395.    union REGS r;
  396.  
  397.    /* restore page map by version */
  398.    if (vers == 0) {
  399.       /* 3.0/3.2 restore page map */
  400.       r.h.ah = 0x48;
  401.       r.x.dx = handle;
  402.       int86(0x67, &r, &r);
  403.       }
  404.      else {
  405.       /* 4.0 restore page map */
  406.       r.x.ax = 0x4E01;
  407.       r.x.si = (unsigned int) mapbuffer;
  408.       int86(0x67, &r, &r);
  409.       /* free page map buffer */
  410.       free(mapbuffer);
  411.       }
  412.    return;
  413. } /* end of function restoreEMS */
  414.  
  415.  
  416.  
  417. /***************************************************************************
  418.  *     FUNCTION HARDHANDLER                                                *
  419.  *   Error handler. Calls restoreEMS() and releaseEMS() upon fatal disk    *
  420.  *   hardware error.                                                       *
  421.  ***************************************************************************/
  422. int hardhandler(int errval, int ax, int bp, int si)
  423. {
  424.    /* clean up EMS situation */
  425.    restoreEMS();
  426.    releaseEMS();
  427.  
  428.    /* DOS call to print */
  429.    bdosptr(0x09, "\nDISK ERROR!\n$", 0);
  430.  
  431.    /* return code for ABORT */
  432.    return(2);
  433. } /* end of function hardhandler */
  434.  
  435.  
  436.  
  437. /***************************************************************************
  438.  *     FUNCTION BREAKHANDLER                                               *
  439.  *   Ctrl-break handler. Exits immediately, which automatically calls      *
  440.  *   restoreEMS() and releaseEMS()                                         *
  441.  ***************************************************************************/
  442. void breakhandler(void)
  443. {
  444.    exit(10);
  445. } /* end of function breakhandler */
  446.  
  447.  
  448. /* end of file DISKTEST.C */