home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 225_01 / nobad.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-10  |  11.4 KB  |  332 lines
  1. /*-----------------------------------------------------------------*/
  2. /*       STANDARD HEADER FOR BDS C PROGRAMMES
  3.          ------------------------------------
  4.  
  5.          Programme:     NOBAD.C
  6.          ---------
  7.          Purpose:       Finds the bad sectors on a disk and then
  8.          -------        puts these into the file  COLLECT.BAD
  9.                         which is created in User Area 15.
  10.  
  11.                         If the bad sector(s) is in the Reserved
  12.                         Tracks, or the Directory, the disk is not
  13.                         able to be used with safety.   A message
  14.                         to this effect is printed and the programme
  15.                         terminates without checking the data tracks.
  16.  
  17.          Written:       10/09/86
  18.          -------
  19.          Amended:       14/11/86
  20.          -------
  21.          Version:       1.2
  22.          -------
  23.  
  24.          Copyright 1986 - Cogar Computer Services Pty. Ltd.        */
  25. /*-----------------------------------------------------------------*/
  26. #include <bdscio.h>
  27. #include <pec.h>
  28. /*-----------------------------------------------------------------*/
  29. #define    VERSION "1.2\0"
  30. #define NAME    "NOBAD\0"
  31. /*-----------------------------------------------------------------*/
  32.  
  33. main(argc, argv)    /* For Command Line processing             */
  34. int argc;
  35. char *argv[];
  36. {
  37. /*-----------------------------------------------------------------*/
  38. /*  Space reserved for variables used in programme                 */
  39. /*-----------------------------------------------------------------*/
  40.     int i, j,RECORDS, COUNT, FD;
  41.     char c;
  42.     char MST_SIG, LST_SIG;    /* Bytes in an integer             */
  43.     int CPM;    /* To check the CP/M Version number        */
  44.     char DRIVE;    /* The active drive                        */
  45.     char OLD_DRIVE;    /* The starting drive No.                  */
  46.     char OLD_USER;    /* The User No. at start of programme      */
  47.     char USER;    /* The User No. for this programme         */
  48.     struct dpb *THIS;
  49.     int DIRECTORY;    /* The directory track No.                 */
  50.     int TRACK, SECTOR, PHYS_SEC;
  51.     int BAD_BLK[16];    /* Maximum allowed                 */
  52.     int BLK_SIZE;        /* In records                      */
  53.     int BAD_ONE;
  54.     int LAST_TRACK, LAST_SECTOR;
  55.     char dma_buf[128];
  56.     char MY_FCB[36];    /* The file control block          */
  57.     char **skew_table;    /* Pointer to a pointer decl.      */
  58. /*-----------------------------------------------------------------*/
  59.     pec_clear();    /* Universal routine                       */
  60.     printf("%s - Version %s\n",NAME, VERSION);
  61.     printf("Copyright 1986 - Cogar Computer Services Pty.Ltd.\n\n");
  62.     printf("-----------------------------------------------------\n");
  63.     printf("This programme checks the integrity of the disk one\n");
  64.     printf("sector at a time....including both the Reserved tracks\n");
  65.     printf("and the Directory track.    If it finds that either the\n");
  66.     printf("Reserved tracks or the Directory has a faulty sector,\n");
  67.     printf("then it reports this to the User and terminates the\n");
  68.     printf("programme as this disk shouldn't be used.\n");
  69.     printf("If it finds any other bad sectors then it collects\n");
  70.     printf("these into the file ==> COLLECT.BAD which is written\n");
  71.     printf("to the Directory in user area 15.\n");
  72.     printf("-----------------------------------------------------\n");
  73.     line();
  74. /*-----------------------------------------------------------------*/
  75. /*  First check the CP/M Version in use.   If it is less than
  76.     Version 2.0 then inform the user and terminate programme.      */
  77. /*-----------------------------------------------------------------*/
  78.  
  79.     CPM = get_cpm();    /* Obtain the CP/M version and No. */
  80.  
  81.     i = (CPM & 0xff) - 0x20; /* Mask off the MP/M bit          */
  82.  
  83.     if(i < 0)        /* Must be less than V 2.0         */
  84.     {
  85.     printf("This programme requires at least V 2.x of CP/M.\n");
  86.         printf("Sorry but it won't run for you.\n");
  87.         exit();
  88.     }
  89. /*-----------------------------------------------------------------*/
  90. /*  The CP/M Version is OK, so save the starting User No. and the
  91.     Drive No. in case either is changed later.                     */
  92. /*-----------------------------------------------------------------*/
  93.  
  94.     OLD_USER = user_id(0xff);
  95.     OLD_DRIVE = get_default() + 0x41;
  96.  
  97. /*-----------------------------------------------------------------*/
  98. /*  Now check the Command Line to see if a Drive Code was entered.
  99.     Other checks can also be used, as required but then it will be
  100.     necessary to change this coding.                               */
  101. /*-----------------------------------------------------------------*/
  102.     if(argc != 2)
  103.     {
  104.         printf("Please enter the DRIVE to check...A, B, C...\n");
  105.         DRIVE = toupper(getchar());
  106.     }
  107.     else DRIVE = toupper(argv[1][0]);
  108.     lines(2);
  109. /*-----------------------------------------------------------------*/
  110. /*  Check that the selected drive is available/on-line.   If not
  111.     then terminate the programme.   You may need to add a message
  112.     about what is going on if your version of CP/M doesn't do
  113.     this automatically, as mine does.                              */
  114. /*-----------------------------------------------------------------*/
  115.     if(!(skew_table = seldsk(DRIVE)))
  116.         exit();
  117.     if(select_dsk(DRIVE) != 0)
  118.         exit();
  119. /*-----------------------------------------------------------------*/
  120. /*  Get the disk parameters needed in programme.                   */
  121. /*-----------------------------------------------------------------*/
  122.     THIS = dpb_adr();    /* Point to disk parameter block   */
  123.  
  124.     DIRECTORY = THIS->OFF;
  125.  
  126.     LAST_SECTOR = THIS->DSM;    /* Starting value          */
  127.     for(i = 0; i < THIS->BSH; i++)
  128.     {
  129.         LAST_SECTOR = LAST_SECTOR + LAST_SECTOR;
  130.     }
  131.     LAST_TRACK = (LAST_SECTOR/THIS->SPT) + THIS->OFF;
  132.     BLK_SIZE = 1;
  133.     for(i = 0; i < THIS->BSH; i++)
  134.     {
  135.         BLK_SIZE = BLK_SIZE*2;
  136.     }
  137. /*-----------------------------------------------------------------*/
  138. /*  See if disk has been checked before, if so erase old file.     */
  139. /*-----------------------------------------------------------------*/
  140.     user_id(15);
  141.     if(open("COLLECT.BAD", 0) != -1)
  142.     {
  143.         unlink("COLLECT.BAD");
  144.         printf("Erasing old COLLECT.BAD\n\n");
  145.     }
  146.     user_id(OLD_USER);
  147. /*-----------------------------------------------------------------*/
  148. /*  First check the Reserved Tracks.                               */
  149. /*-----------------------------------------------------------------*/
  150.     set_dma(&dma_buf[0]);
  151.     printf("\tTesting Reserved Tracks.\n");
  152.     printf("\t-----------------------\n\n");
  153.  
  154.     for(i = 0; i < DIRECTORY; i++)
  155.     {
  156.         set_trk(i);
  157.         if(i == 0)
  158.             RECORDS = 26;
  159.         else RECORDS = THIS->SPT;
  160.         for(j = 0; j < RECORDS; j++)
  161.         {
  162.             set_sec(j);
  163.             if(read_sec() != 0)
  164.             {
  165.                 if(write_sec() != 0)
  166.                 {
  167.     printf("Bad sector in Reserved Track - %d\n", i);
  168.     printf("This makes the disc VERY suspect.");
  169.     exit();
  170.                 }
  171.             }
  172.         }
  173.     }
  174.     printf("The Reserved Tracks are OK.\n\n");
  175. /*-----------------------------------------------------------------*/
  176. /*  Now check the Directory Track.                                 */
  177. /*-----------------------------------------------------------------*/
  178.     printf("\tChecking Directory Track.\n");
  179.     printf("\t------------------------\n\n");
  180.     set_trk(DIRECTORY);
  181.     for(j = 0; j < RECORDS; j++)
  182.     {
  183.         PHYS_SEC = biosh(16, j, *skew_table);
  184.         set_sec(PHYS_SEC);
  185.         if(read_sec() != 0)
  186.         {
  187.             if(write_sec() != 0)
  188.             {
  189.     printf("Bad sector in Directory Track - %d\n", i);
  190.     printf("This makes the disc VERY suspect.");
  191.     exit();
  192.             }
  193.         }
  194.     }
  195.     printf("The Directory Track is OK.\n\n");
  196. /*-----------------------------------------------------------------*/
  197. /*  And finally, check the data tracks.                            */
  198. /*-----------------------------------------------------------------*/
  199.     COUNT = 0;
  200.     RECORDS = THIS->SPT;
  201.     printf("\tChecking Data Tracks.\n");
  202.     printf("\t--------------------\n\n");
  203.  
  204.     for(i = DIRECTORY + 1; i < LAST_TRACK; i++)
  205.     {
  206.         set_trk(i);
  207.         for(j = 0; j < RECORDS; j++)
  208.         {
  209.             PHYS_SEC = biosh(16, j, *skew_table);
  210.             set_sec(PHYS_SEC);
  211.  
  212.             if(read_sec() != 0)
  213.             {
  214.                 if(write_sec() != 0)
  215.                 {
  216.     BAD_ONE = ((i - DIRECTORY)*RECORDS + j)/BLK_SIZE;
  217.     BAD_BLK[COUNT] = BAD_ONE;
  218. printf("\tBad sector in Track - %d  Sector - %d  Block - %d\n", i, j, BAD_ONE);
  219.     if(COUNT != 0 && BAD_BLK[COUNT] != BAD_BLK[COUNT - 1])
  220.         COUNT++;
  221.     if(COUNT == 0)
  222.         COUNT++;
  223.                 }
  224.             }
  225.         }
  226.     if(i%10 == 0)
  227.         printf("Finished reading Track - %d\n", i);
  228.     }
  229.     if(COUNT != 0)
  230.         printf("%d  bad blocks found.\n", COUNT);
  231.     else printf("No bad blocks found...disk is OK.");
  232. /*-----------------------------------------------------------------*/
  233. /*  If any bad blocks found then write them to file  COLLECT.BAD   */
  234. /*-----------------------------------------------------------------*/
  235.     if(COUNT > 0)
  236.     {
  237.         setmem(&MY_FCB[0], 36, 0); /* Zero the buffers     */
  238.         setmem(&dma_buf[0], 128, 0);
  239.  
  240.         MY_FCB[0] = 15;    /* The User No.                    */
  241.         strcpy(&MY_FCB[1],"COLLECT BAD");
  242.         MY_FCB[15] = COUNT*BLK_SIZE;    /* Records         */
  243.  
  244.         j = 16;        /* Starting value                  */
  245.         if((THIS->DSM >> 8) == 0)
  246.         {
  247.         if(COUNT > 16)
  248.         {
  249.         printf("Too many bad blocks to make disk safe to use.");
  250.         user_id(OLD_USER);
  251.         exit();
  252.         }
  253.         for(i = 0; i < COUNT; i++)
  254.         {
  255.             MY_FCB[j] = (LST_SIG = BAD_BLK[i] & 0xff);
  256.             j++;
  257.         }
  258.         }
  259.         else if((THIS->DSM >> 8) != 0)
  260.         {
  261.         if(COUNT > 8)
  262.         {
  263.         printf("Too many bad blocks to make disk safe to use.");
  264.         user_id(OLD_USER);
  265.         exit();
  266.         }
  267.         for(i = 0; i < COUNT; i++)
  268.         {
  269.             MY_FCB[j] = (LST_SIG = BAD_BLK[i] & 0xff);
  270.             MY_FCB[j + 1] = (MST_SIG = (BAD_BLK[i] >> 8) & 0xff);
  271.             j = j + 2;
  272.         }
  273.         }
  274. /*-----------------------------------------------------------------*/
  275. /*  We now have a formulated FCB entry for the file COLLECT.BAD so
  276.     all that has to be done is to write this entry into the disk
  277.     directory.                                                     */
  278. /*-----------------------------------------------------------------*/
  279.  
  280.     set_trk(DIRECTORY);
  281.     set_dma(&dma_buf[0]);
  282.  
  283.     for(i = 0; i < RECORDS; i++)
  284.     {
  285.         PHYS_SEC = biosh(16, i, *skew_table);
  286.         set_sec(PHYS_SEC);
  287.         read_sec();
  288.     for(j = 0; j < 128; j = j + 32)
  289.     {
  290.         if(dma_buf[j] == 0xe5)    /* Found a vacant slot     */
  291.         {
  292. /*-----------------------------------------------------------------*/
  293. /*  Copy COLLECT.BAD into the directory entry slot.                */
  294. /*-----------------------------------------------------------------*/
  295.         movmem(&MY_FCB[0], &dma_buf[j], 32);
  296.         write_sec();
  297.         user_id(OLD_USER);
  298.         printf("Have created file  COLLECT.BAD  to hold ");
  299.         printf("the bad blocks.");
  300.         exit();
  301.         }
  302.     }
  303.     }
  304.     }
  305. /*-----------------------------------------------------------------*/
  306. /*  Before closing, make sure the User No. and Drive No. return
  307.     to original settings.                                          */
  308. /*-----------------------------------------------------------------*/
  309.  
  310.     user_id(OLD_USER);
  311.     if(select_dsk(OLD_DRIVE) != 0)
  312.     {
  313.         printf("\nUnable to return to original drive.");
  314.         exit();
  315.     }
  316.     if((FD = open("UTIL.COM", 0)) != -1)
  317.     {
  318.         close(FD);
  319.         exec("UTIL");
  320.     }
  321.     else printf("\nUnable to find  UTIL.COM.   Returning to CP/M.");
  322.  
  323. }
  324. /*-----------------------------------------------------------------*/< COUNT; i++)
  325.         {
  326.             MY_FCB[j] = (LST_SIG = BAD_BLK[i] & 0xff);
  327.             j++;
  328.         }
  329.         }
  330.         else if((THIS->DSM >> 8) != 0)
  331.         {
  332.