home *** CD-ROM | disk | FTP | other *** search
/ PC-Test Pro / PCTESTPRO.iso / disktool / eidetest / entp / eidetest.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-30  |  13.8 KB  |  536 lines
  1. /*  EIDEtest 1.5
  2.     Tests if simultaneous I/O corrupts disk reading.  If so, likely causes are the
  3.     PCI RZ-1000 EIDE chip, the CMD PCIO640B EIDE chip or a faulty DMA controller.
  4.     Runs under DOS, DESQview, Windows, NT and OS/2 in DOS emulation mode.
  5.  
  6.     This program may be copied freely and used for any purpose except military.
  7.     (c) copyright 1995 by
  8.     Roedy Green
  9.     Canadian Mind Products
  10.     #601 - 1330 Burrard Street
  11.     Vancouver, BC Canada V6Z 2B8
  12.     (604) 685-8412
  13.     Internet Roedy@bix.com
  14.  
  15.     compiled under SMALL model
  16.  
  17.     It works by writing a file with no I/O interfering, then
  18.     reads it back multiple times with as much DMA as possible
  19.     interfering.  It ensures the same pattern written comes back.
  20.  
  21.     This code is written in an extremely pedestrian C-like way.  My intent was
  22.     that the widest audience of programmers should understand it,
  23.     and to make it as easy as possible to port to other operating systems.
  24.  
  25.     Version history
  26.  
  27.  
  28.     1.5 - correct minor typos in the prompts.
  29.           focus on simultaneous floppy/tape I/O.
  30.  
  31.     1.4 - make mention also of the flawed CMD PCIO640B chip
  32.         - Suggest running modem, mouse, sound card as well.
  33.         - Warning that a pass does not mean a perfect chip.
  34.  
  35.     1.3 - give different prompts on which background tests to
  36.           use depending on which OS you are using.
  37.           Make clear you must turn on simultaneous I/O in backup.
  38.  
  39.     1.2 - give proper fail if wrong length read comes back.
  40.         - Formerly code was hidden by an ill-formed comment.
  41.         - lint tidy up.
  42.         - Change prompts to indicate new understanding that
  43.         - simultaneou DMA rather than interrupts trigger the flaw.
  44.         - Allow abort at each prompt.
  45.         - Extra pause at the start.
  46.         - More status messages.
  47.         - Re-order routines top-down.
  48.         - clear screen at various stages to hide previous prompts.
  49.         - ack invalid ignored keystrokes with a beep
  50.  
  51.     1.1 - get rid of all 8-bit chars in source
  52.         - run test indefinitely, till the user hits ESC
  53.         - more elaborate prompting.
  54.  
  55.     1.0 - first release beta.
  56.  
  57.     */
  58.  
  59. /* ***************************************** */
  60.  
  61. /* D E F I N E S */
  62.  
  63. /* By redefining these constants, you could create a program to test a
  64.    floppy.  You would need to use a smaller file, and turn off caching on
  65.    the floppy. */
  66.  
  67. #define BufferSizeInWords 15872
  68. #define BufferSizeInBytes 31744
  69. /* size of buffer for write/reading the file.
  70.    This size should generate lots of physical I/O.
  71.    Smaller sizes might come out of cache.
  72.    Bigger sizes do only a few big I/Os */
  73.  
  74. #define NumChunks  240
  75. /* size of test file in blocks.  Size in bytes is 240 * 31744 = 7,618,560.
  76.    File must be bigger than cache, or little physical I/O will occur */
  77.  
  78. #define WORD unsigned short
  79.  
  80. #define StartDecorate "\xb0\xb1\xb2\xdb"
  81. /* line of pretty blobs in oemfont to attract attention */
  82. #define EndDecorate   "\xdb\xb2\xb1\xb0"
  83.  
  84. #define Esc   '\x1b'
  85.  
  86. /* ***************************************** */
  87.  
  88. /* I N C L U D E S */
  89.  
  90. #include <stdlib.h>
  91. // e.g. exit
  92.  
  93. #include <stdio.h>
  94. // e.g. FILE, printf, fopen
  95.  
  96. #include <conio.h>
  97. // e.g. getch kbhit crlscr
  98.  
  99. #include <alloc.h>
  100. // e.g. malloc free
  101.  
  102. /* ***************************************** */
  103.  
  104. /* G L O B A L S */
  105.  
  106. FILE *TempFile;
  107. /* temporary Test file */
  108.  
  109. char TempFileName[] = "C:\\EIDETEST.TMP";
  110. /* name of the temporary file on an EIDE drive */
  111.  
  112. WORD *Buffer;
  113. /* buffer for I/O on TempFile */
  114.  
  115. /* ***************************************** */
  116.  
  117. /* P R O T O T Y P E S */
  118.  
  119. int main( int argc,  char *argv[] );
  120. void banner ( void );
  121. int Phase1 ( void );
  122. int Phase2 ( void );
  123. void DisplayResults( int RetCode );
  124.  
  125. void beep (void );
  126. int pause ( void );
  127. int DoesOSDoSimultaneousIO ( void );
  128. int CheckForEsc ( void );
  129.  
  130. /* ***************************************** */
  131.  
  132. /* F U N C T I O N   D E F I N I T I O N S */
  133.  
  134. int main( int argc,  char *argv[] )
  135.  
  136. {
  137.     int RetCode = 0;
  138.  
  139.     banner();
  140.  
  141.     /* allocate RAM for buffer */
  142.     Buffer = (WORD *) malloc( BufferSizeInBytes );
  143.     if ( Buffer == 0)
  144.     {
  145.     printf("Oops!  not enough RAM to run the test.");
  146.     exit (2);
  147.     }
  148.  
  149.     if ( argc != 2 /*  0=EIDEtest.Exe 1=C: */ )
  150.     {
  151.     printf("Oops!  usage:  EIDEtest  C:"
  152.         "\nwhere C: is the EIDE hard drive to test.");
  153.     exit (2);
  154.     }
  155.  
  156.     /* replace first letter of TempFilename with Drive Letter */
  157.     /* e.g. TempFileName might now read:  D:\EIDETEST.TMP */
  158.     TempFileName[0] = *argv[1];
  159.  
  160.     printf("\nTesting by writing and reading file %s"
  161.     "\nwhich will need %lu bytes."
  162.     "\nThe test will not prove anything unless this file is on an EIDE hard disk.\n",
  163.     TempFileName, (long) NumChunks * (long) BufferSizeInBytes);
  164.  
  165.     if ( pause() == 2 ) RetCode = 2; /* user ESC abort */
  166.  
  167.     /* Stop processing when non-zero RetCode indicates trouble */
  168.  
  169.     /* do Phase 1 */
  170.     if (RetCode == 0) RetCode = Phase1();
  171.     beep(); /* announce Phase1 over */
  172.  
  173.     /* do Phase 2 */
  174.     if (RetCode == 0) RetCode = Phase2();
  175.     beep(); /* announce Phase2 over */
  176.  
  177.     DisplayResults(RetCode); /* report good or bad news */
  178.  
  179.     /* We are now done without background I/O, so these should be safe. */
  180.     fclose(TempFile);
  181.     unlink(TempFileName);
  182.     free (Buffer);
  183.  
  184.     return RetCode;
  185.  
  186. } /* end main */
  187.  
  188. /* ***************************************** */
  189.  
  190. void banner(void)
  191. {
  192.     /* display copyright banner. */
  193.  
  194.     clrscr(); /* clear screen */
  195.  
  196.     printf("\n" StartDecorate " EIDEtest 1.5 " EndDecorate
  197.     "\n"
  198.     "\nFreeware to test for the flawed EIDE controllers such as the"
  199.     "\nPC-Tech RZ-1000 and the CMD PCIO640B."
  200.     "\nRuns under DESQview, Windows, Windows For WorkGroups, Windows-95, NT"
  201.     "\nand OS/2 all in DOS emulation mode."
  202.     "\n"
  203.     "\nCopyright (c) 1995 Canadian Mind Products"
  204.     "\n#601 - 1330 Burrard Street, Vancouver BC CANADA V6Z 2B8  (604) 685-8412"
  205.     "\nInternet: Roedy@bix.com <Roedy Green>"
  206.     "\nMay be used freely for non-military use only."
  207.     "\n\n");
  208.  
  209. } /* end banner */
  210.  
  211. /* ***************************************** */
  212.  
  213. int Phase1 ( void )
  214.  
  215. { /* returns:
  216.      0 = ok
  217.      1 = failed
  218.      2 = could not run test */
  219.  
  220.     WORD Chunk; /* indexing chunks/blocks of file */
  221.     WORD i;     /* indexing chars in buffer */
  222.  
  223.  
  224.     clrscr(); /* clear screen */
  225.  
  226.     printf("\n" StartDecorate " PHASE 1 " EndDecorate
  227.     "\n"
  228.     "\nDuring phase 1, do not run any other programs."
  229.     "\nEspecially avoid using the tape or floppy drive."
  230.     "\nShutdown all background programs BEFORE you proceed."
  231.     "\nIf you can't get them all, not to worry;"
  232.     "\nthe test results will still be valid."
  233.     "\n");
  234.  
  235.     if ( pause() == 2 )
  236.     return 2; /* user abort */
  237.  
  238.     printf("\nPhase 1 in progress.  Please stand by...\n");
  239.  
  240.     /* create a temporary file */
  241.     TempFile = fopen(TempFileName,"w+b"); /* create binary mode */
  242.     if (TempFile == 0 )
  243.     {
  244.     return 2; /* Failed to create test file */
  245.     }
  246.  
  247.     /* fill buffer with pattern */
  248.     for ( i=0 ; i < BufferSizeInWords ; i++ )
  249.     { Buffer [i] = i;}
  250.  
  251.     /* write a test file full of a set pattern */
  252.  
  253.     for ( Chunk=0 ; Chunk < NumChunks ; Chunk++ )
  254.     {
  255.  
  256.     if (fwrite(Buffer, BufferSizeInBytes , 1, TempFile) != 1)
  257.         {
  258.         return 2; /* could not create test file */
  259.         }
  260.     }
  261.     /* all ok */
  262.     return 0;
  263.  
  264. } /* end Phase1 */
  265.  
  266. /* ***************************************** */
  267.  
  268. int Phase2 ( void )
  269.  
  270. { /* returns:
  271.     0 = ok
  272.     1 = failed
  273.     2 = could not run test */
  274.  
  275.     WORD Chunk; /* indexing chunks/blocks of file */
  276.     WORD i;     /* indexing chars in buffer */
  277.     switch (DoesOSDoSimultaneousIO())
  278.     {
  279.  
  280.     case 0: /* DOS */
  281.         clrscr(); /* clear screen */
  282.         printf( "\n" StartDecorate " PHASE 2 " EndDecorate
  283.         "\n"
  284.         "\nDURING phase 2, do as many of these tests as you can"
  285.         "\nto generate simultaneous I/O:"
  286.         "\n"
  287.         "\n- Backup some files to floppy with MWBackup, MSBackup, Norton Backup"
  288.         "\n  or other high performance floppy backup program with fast-mode"
  289.         "\n  simultaneous disk I/O configured."
  290.         "\n- Backup a file using your mag tape backup software with fast-mode"
  291.         "\n  simultaneous disk I/O configured."
  292.         "\n- Exercise any simultaneous I/O devices e.g. modem, mouse or sound card."
  293.         "\n");
  294.         break;
  295.  
  296.     case 1: /* OS */
  297.         clrscr(); /* clear screen */
  298.         printf( "\n" StartDecorate " PHASE 2 " EndDecorate
  299.         "\n"
  300.         "\nDURING phase 2, do as many of these tests as you can"
  301.         "\nto generate simultaneous I/O:"
  302.         "\n"
  303.         "\n- Format a floppy."
  304.         "\n- Backup some files to floppy with MWBackup, MSBackup, Norton Backup"
  305.         "\n  or other high performance floppy backup program with fast-mode"
  306.         "\n  simultaneous disk I/O configured."
  307.         "\n- Backup a file using your mag tape backup software with fast-mode"
  308.         "\n  simultaneous disk I/O configured."
  309.         "\n- Scan a document with your scanner."
  310.         "\n- Browse some files on other hard disks and CD-ROM."
  311.         "\n- Exercise any simultaneous I/O devices e.g. modem, mouse or sound card."
  312.         "\n");
  313.         break;
  314.  
  315.     case 2: /* esc */
  316.         return 2;
  317.     }
  318.  
  319.  
  320.     printf("\nYour experiments may run slowly because of EIDEtest's disk overhead."
  321.     "\n"
  322.     "\nBEGIN YOUR EXPERIMENTS NOW!"
  323.     "\n"
  324.     "\nTake all the time you want -- days even."
  325.     "\nWhen you have FINISHED your experiments, come back and hit the space bar."
  326.     "\n"
  327.     "\nPhase 2 in progress..."
  328.     "\n");
  329.  
  330.     /* read a test file full of the test pattern, over and over */
  331.     /* keep going till user hits Esc */
  332.  
  333.     while ( 1 )
  334.     {
  335.  
  336.     /* seek to the beginning of the file */
  337.     fseek(TempFile, SEEK_SET, 0);
  338.  
  339.     for ( Chunk=0 ; Chunk < NumChunks ; Chunk++)
  340.         {
  341.         if (CheckForEsc())
  342.         {
  343.         /* all went well, we ran without incident until the user hit space or ESC */
  344.         return 0;  /* EXIT */
  345.         }
  346.         if (fread(Buffer, BufferSizeInBytes, 1, TempFile) != 1)
  347.         {
  348.         /* File corrupted */
  349.         return 1; /* EXIT */
  350.         }
  351.         /* check that buffer is same pattern as written */
  352.         for ( i=0 ; i < BufferSizeInWords ; i++ )
  353.         {
  354.         if (Buffer [i] != i)
  355.             {
  356.             /* discrepancy detected */
  357.             return 1;  /* EXIT */
  358.             }
  359.         }
  360.         }
  361.     } /* end while forever */
  362.  
  363.     /* never get here */
  364.  
  365. } /* end Phase2 */
  366.  
  367. /* ***************************************** */
  368.  
  369. void DisplayResults( int RetCode )
  370. {
  371.     /* display results of the test */
  372.     /*  0 = test ok
  373.     1 = fail
  374.     2 = could not run test */
  375.  
  376.     clrscr(); /* clear screen */
  377.  
  378.     printf( "\n" StartDecorate " TEST RESULTS " EndDecorate
  379.     "\n\n");
  380.  
  381.     switch (RetCode)
  382.     {
  383.     case 0:
  384.         printf("\n\nEIDEtest passed.  No flaws found."
  385.         "\nYou may still have a flawed EIDE controller chip with a"
  386.         "\nsuccessful software bypass."
  387.         "\nKeep in mind, that unless you carefully followed the"
  388.         " instructions on the,"
  389.         "\nscreen, the results of this test are meaningless."
  390.         "\n");
  391.         break;
  392.  
  393.     case 1:
  394.         printf("\n\nEIDEtest failed."
  395.         "\nIf you have a PCI motherboard the failure is probably due to a faultly"
  396.         "\nPC-Tech RZ-1000 or CMD PCIO640B EIDE controller chip."
  397.         "\nIt could also be due to overheating, a faulty DMA controller,"
  398.         "\nor software bugs."
  399.         "\nPlease ensure you have stopped all your experiments that were"
  400.         "\ngenerating background I/O activity.");
  401.         break;
  402.  
  403.     case 2:
  404.     default:
  405.         printf("\n\nEIDEtest could not be run."
  406.         "\nPossibly a user abort or problems creating the test file."
  407.         "\nProbably not enough room on the test disk drive."
  408.         "\n");
  409.         break;
  410.  
  411.     }
  412.     printf("\nPlease admire the test results.\n");
  413.     pause();
  414.  
  415. } /* end DisplayResults */
  416.  
  417. /* ***************************************** */
  418.  
  419. void beep (void)
  420. {
  421.     /* long beep to attract attention */
  422.     printf("\x07\x07\x07\x07");
  423.  
  424. } /* end beep */
  425.  
  426. /* ***************************************** */
  427.  
  428. int pause (void)
  429. {
  430.     /*
  431.     returns 1=user hit space
  432.     returns 2=user hit ESC
  433.     */
  434.     int Result = 0;
  435.     /* pause until the user hits the space bar */
  436.     printf ("\nWhen you are ready to proceed, hit the space bar; hit ESC to abort");
  437.  
  438.     while (!Result)
  439.     {
  440.     switch (getch())
  441.         {
  442.         case ' ':
  443.         Result = 1; /*  space we are done */
  444.         break;
  445.         case Esc:
  446.         Result = 2; /* Esc, Abort */
  447.         break;
  448.         default:
  449.         printf("\x07" );  /* beep to indicate char ignored. */
  450.         break;
  451.         }
  452.     }
  453.     printf("\r                                                                  \n\n");
  454.     /* erase the  prompt line, to acknowledge the space bar */
  455.     return Result;
  456.  
  457. } /* end pause */
  458.  
  459. /* ***************************************** */
  460.  
  461. int DoesOSDoSimultaneousIO (void)
  462. {
  463.     /*
  464.       returns 0= no, DESQiew, Windows,...
  465.       returns 1= yes. OS/2, NT...
  466.       returns 2=user hit ESC
  467.        */
  468.     int Result = -1;
  469.  
  470.     printf( "\nDoes your operating system do more than one I/O at a time?"
  471.     "\nAnswer N for DOS, DESQview, Windows, Windows for Workgroups or Windows-95."
  472.     "\nAnswer Y for OS/2, Warp, NT, Linux, SCO XENIX or UNIX.");
  473.     /* don't advertise the ESC possibility */
  474.  
  475.     while (Result == -1)
  476.     {
  477.     switch (getch())
  478.         {
  479.         case 'N':
  480.         case 'n':
  481.         Result = 0; /*  No */
  482.         break;
  483.         case 'Y':
  484.         case 'y':
  485.         Result = 1; /* Yes */
  486.         break;
  487.         case Esc:
  488.         Result = 2; /* Esc, Abort */
  489.         break;
  490.         default:
  491.         printf("\x07" );  /* beep to indicate char ignored. */
  492.         break;
  493.         }
  494.     }
  495.  
  496.     return Result;
  497. } /* end DoesOSDoSimultaneousIO */
  498.  
  499. /* ***************************************** */
  500.  
  501. int CheckForEsc (void)
  502. {
  503.  
  504.     /*
  505.       returns 0=user did nothing.  We don't wait for him to hit a key.
  506.       returns 1=user hit space
  507.       returns 2=user hit ESC
  508.        */
  509.     int Result = 0;
  510.  
  511.     if (kbhit())
  512.     {
  513.     switch (getch())
  514.         {
  515.         case ' ':
  516.         Result = 1; /*  space we are done */
  517.         break;
  518.         case Esc:
  519.         Result = 2; /* Esc, Abort */
  520.         break;
  521.         default:
  522.         printf("\x07" );  /* beep to indicate char ignored. */
  523.         Result = 0;
  524.         break;
  525.         }
  526.     }
  527.     else
  528.     Result = 0; /* no key hit */
  529.     return Result;
  530. } /* end CheckForEsc */
  531.  
  532. /* ***************************************** */
  533.  
  534. /* -30- */
  535.  
  536.