home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / AHDI / TTFHDX / BSL.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  20.0 KB  |  701 lines
  1. /*
  2.  * BSL.C
  3.  *
  4.  *     Functions to manipulate the Bad Sector List.
  5.  *
  6.  * 25-Nov-87    ml.    Started this mess.
  7.  * 04-Dec-87    ml.    Hmmm, looks OK.
  8.  * 11-Dec-87    ml.    Added bsl2fat().
  9.  * 14-Dec-87    ml.    Structure of BSL is changed (_again_!).
  10.  *            Now, first entry in BSL contains number VENDOR
  11.  *            entries.  First byte of 2nd entry is the checksum
  12.  *            byte, while 2nd and 3rd bytes are reserved for 
  13.  *            future use.
  14.  * 14-Sep-89    ml.    Uses Rwabs() instead of hread() and hwrite().
  15.  *            Will handle SCSI as well as ACSI drives.
  16.  * 21-Sep-89    ml.    Modified to work with big sectors for big 
  17.  *            partitions.
  18.  *
  19.  */
  20.  
  21. #include <obdefs.h>
  22. #include <osbind.h>
  23. #include "fhdx.h"
  24. #include "define.h"
  25. #include "part.h"
  26. #include "bsl.h" 
  27. #include "addr.h" 
  28. #include "lrwabs.h" 
  29.  
  30. /* Globals */
  31. char *bsl;                /* bad sector list */
  32. long bslsiz;                /* num sectors BSL occupies */
  33.  
  34. extern SECTOR *badbuf;
  35.  
  36. /*
  37.  *  Get size of the Bad Sector List (in sectors)
  38.  *    Input:
  39.  *        pdev - physical unit BSL belongs to.
  40.  *    Return:
  41.  *        number of sectors BSL occupies.
  42.  */
  43. long 
  44. gbslsiz(pdev) 
  45. int pdev;    /* physical device number */
  46. {
  47.     char bs[512];    /* boot sector image */
  48.     
  49.     if (getroot(pdev, bs) == ERROR)
  50.         return ((long)err(rootread));
  51.     
  52.     if (((RSECT *)(bs + 0x200 - sizeof(RSECT)))->bsl_st != STBSL) {
  53.         form_alert(1, "[1][No BSL recorded in root sector!][ OK ]");
  54.         return 0L;
  55.     }       
  56.     
  57.     return(((RSECT *)(bs + 0x200 - sizeof(RSECT)))->bsl_cnt);
  58. }
  59.  
  60.  
  61. /*
  62.  *  Set BSL parameters (starting sector and size of BSL) into
  63.  *  root sector image.
  64.  *    Input:
  65.  *        image - root sector image.
  66.  */
  67. sbslparm(image)
  68. char *image;
  69. {
  70.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->bsl_st = STBSL;
  71.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->bsl_cnt = bslsiz;
  72. }
  73.  
  74.  
  75. /* 
  76.  *  Create a BSL in memory.
  77.  *    Input:
  78.  *        pdev - physical unit BSL will belong to.
  79.  *        type - kind of BSL to be created. NEW or EXPAND.
  80.  *        nents - number of VENDOR entries BSL should hold.
  81.  *    Output:
  82.  *        bsl - pointer to the BSL. (in bsl.h)
  83.  *    Return:
  84.  *        OK - everything is fine.
  85.  *        ERROR - anything is wrong.
  86.  *    Comment:
  87.  *        "NEW" means to create a totally new BSL.
  88.  *        "EXPAND" means to expand an existing BSL.
  89.  */
  90. creabsl(pdev, type, nents)
  91. int  pdev;    /* physical unit number */
  92. int  type;    /* kind of BSL to be created */
  93. long  nents;    /* num VENDOR entries in BSL */
  94. {
  95.     BYTE *newbsl;  /* BSL just created */
  96.     long l, size;  /* l - index into BSL;  size - size of BSL in bytes */ 
  97.     long start;       /* where to start initializing entries to zeroes */
  98.     long nument();
  99.  
  100.     if (type == NEW) {
  101.     if (form_alert(1, "[1][Create a new BSL?][ Yes |  No  ]") == 2)
  102.         return ERROR;
  103.     }
  104.     
  105.     if (nents == 0) {    /* no VENDOR entries specified */
  106.         size = 512L;    /* default size of BSL to 1 sector */
  107.     } else {       /* num VENDOR entries is specified */
  108.         /*------------------------------------------------------*/
  109.         /* Calculate length of BSL in bytes.            */
  110.         /* Have to add space for reserved entries and USER list    */
  111.         /* (note: (+1) to round up)                */
  112.         /*------------------------------------------------------*/
  113.     size = ((nents + RENT + WARNBADSECTS)/EPS + 1) * 512L;
  114.     }
  115.     
  116.     /* allocate enough memory for new BSL */
  117.     if ((newbsl = (BYTE *)mymalloc((int)size)) <= 0)
  118.         return err(nomemory);
  119.     
  120.     if (type == NEW) {    /* a new BSL */
  121.         start = 0;    /* start at 0th entry, i.e. init whole BSL to 0s */
  122.     }    
  123.     else {        /* expand the BSL */
  124.         /* start init to 0s after VENDOR list */
  125.     start = (nument(VENDOR) + RENT) * BPE;
  126.     
  127.         /* copy original BSL into this expanded memory */
  128.         for (l = 0; l < start; l++)
  129.             newbsl[l] = bsl[l];
  130.     }
  131.         
  132.     /* free up old BSL */
  133.     if (bsl > 0L) free(bsl);
  134.     bsl = newbsl;
  135.     
  136.     /* init BSL to zeroes beginning at 'start'th entry */
  137.     for (l = start; l < size; l++)
  138.         bsl[l] = 0;
  139.         
  140.     /* install BSL info */
  141.     bslsiz = size/512;    /* current num sectors BSL occupies */
  142.     put3bytes(bsl, nents);  /* num VENDOR entries */
  143.     mkmagic();    /* make the BSL checks sum to BSLMAGIC byte-wise */
  144.                           
  145.     return OK;
  146. }
  147.  
  148.  
  149. /*
  150.  *  Read the BSL into memory.
  151.  *    Input:
  152.  *        pdev - physical unit that contains the BSL.
  153.  *    Output:
  154.  *        bsl - pointer to the BSL.  (in bsl.h)
  155.  *    Return:
  156.  *        OK - everything is fine.
  157.  *        INVALID - BSL doesn't checksum correctly.
  158.  *        ERROR - can't read BSL.
  159.  */
  160. rdbsl(pdev)
  161. int pdev;    /* physical unit to read from */
  162. {
  163.     int ret;
  164.     extern HINFO hinfo;
  165.     
  166. rdagain:    
  167.     if ((ret = Lrwabs(PHYSREAD, bsl, (WORD)bslsiz, (SECTOR)STBSL, pdev+2))
  168.          == ERROR) {
  169.     if (form_alert(1, "[1][Read from BSL timed out!][ Retry | Quit ]")
  170.         == 1) {
  171.         goto rdagain;
  172.     }
  173.         return ERROR;
  174.     } else if (ret > 0) {
  175.         ret = err(bslread);
  176.         errcode(pdev);
  177.         return ERROR;
  178.     } else {
  179.         if ((ret = sumbsl()) == INVALID) {    /* if BSL is INVALID */
  180.             err(cruptbsl);
  181.             dsplybsl(pdev, (UWORD)hinfo.hi_dhc, (UWORD)hinfo.hi_spt);
  182.             return INVALID;
  183.         }
  184.         return OK;
  185.     }
  186. }
  187.  
  188.  
  189. /*
  190.  *  Count number of entries in the requested portion of BSL.
  191.  *    Input:
  192.  *        portion - portion of BSL.  MEDIA, VENDOR, USER or UNUSED.
  193.  *    Return:
  194.  *        Number of entries of the requested portion.
  195.  *    Comments:
  196.  *        There are 3 bytes per entry (BPE), and the first 2 entries
  197.  *    are reserved (RENT) for BSL info.
  198.  */
  199. long
  200. nument(portion)
  201. int portion;        /* portion of BSL to be counted */
  202. {
  203.     long  vdr, usr;        /* num ent in VENDOR list, num ent in USER list */
  204.     long  nbytes, offset;   /* BSL's len in bytes, index into BSL */
  205.     long  get3bytes();
  206.     
  207.     /* 2nd entry in BSL contains num entries in VENDOR list */
  208.     vdr = get3bytes(bsl);
  209.     
  210.     if (portion == VENDOR)  return (vdr);
  211.     
  212.     nbytes = bslsiz*512;    /* num bytes in BSL */
  213.     
  214.     /* num bytes available for valid entries */
  215.     /* (need this because nbytes may not be divisible by BPE) */
  216.     nbytes -= (nbytes % BPE);
  217.     
  218.     /* find out num entries in USER list */
  219.     usr = 0;
  220.     for (offset = (RENT+vdr)*BPE;  /* index into beginning of USER list */
  221.          (offset < nbytes)       /* while not at end of BSL */
  222.      && get3bytes(bsl+offset); /* and it's a used entry */
  223.          offset += BPE)           /* increment index */
  224.         usr++;        /* increment num entries for USER list */
  225.          
  226.     if (portion == USER)
  227.         return (usr);        /* num entries in USER list */
  228.         
  229.     if (portion == MEDIA)
  230.         return (vdr+usr);    /* num entries in MEDIA list */     
  231.         
  232.     /* portion == UNUSED */
  233.     return ((nbytes/BPE)-RENT-vdr-usr);
  234. }
  235.  
  236.  
  237. /*
  238.  *  Write the BSL into the disk.
  239.  *    Input:
  240.  *        pdev - physical unit number BSL belongs to.
  241.  *        bsl - pointer to buffer containing the BSL. (in bsl.h)
  242.  *    Return:
  243.  *        OK - everything is fine.
  244.  *        ERROR - can't write BSL.
  245.  */
  246. wrbsl(pdev)
  247. int pdev;    /* physical unit number */
  248. {
  249.     extern HINFO hinfo;
  250.     int ret;
  251.     
  252. wrtagain:
  253.     if ((ret = Lrwabs(PHYSWRT, bsl, (WORD)bslsiz, (SECTOR)STBSL, pdev+2))
  254.          == ERROR) {
  255.     if (form_alert(1, "[1][Write to BSL timed out!][ Retry | Quit ]")
  256.         == 1) {
  257.         goto wrtagain;
  258.     }
  259.         return ERROR;
  260.     } else if (ret > 0) {
  261.     err(bslwrite);
  262.         errcode(pdev);
  263.         dsplybsl(pdev, (UWORD)hinfo.hi_dhc, (UWORD)hinfo.hi_spt);
  264.         return ERROR;
  265.     }
  266.         
  267.     return OK;
  268. } 
  269.  
  270.  
  271. /*
  272.  *  Sort the BSL in memory in ascending order.
  273.  *    Input:
  274.  *        entries - number of used entries in BSL
  275.  *        bsl - pointer to the BSL. (in bsl.h)
  276.  *    Output:
  277.  *        a sorted bsl.
  278.  *    Algorithm:
  279.  *        Bubble sort.
  280.  *    Comments:
  281.  *        The reserved entries won't be sorted.
  282.  */
  283. sortbsl(entries)
  284. long  entries;    /* num entries in BSL */
  285. {
  286.     long  i, e1, e2;
  287.     long  start;    /* beginning byte of entries in BSL */
  288.     long  end;        /* tail byte of BSL */
  289.     int   change;    /* signal if changes have been made in current pass */
  290.     long  get3bytes();
  291.     
  292.     if (entries == 0L || entries == 1L)  /* BSL doesn't need to be sorted */
  293.         return;
  294.             
  295.     change = 1;        /* assume list is not in order */
  296.     start = RENT*BPE;    /* beginning of entries in BSL */
  297.     end = entries * BPE;
  298.     while (1) {
  299.         if (change == 0)    /* if no changes made, DONE --> HOME */
  300.         return;
  301.         
  302.         change = 0;    /* assume list is in order */
  303.         for (i = start; i <= end; i += BPE) {
  304.             e1 = get3bytes(bsl+i);
  305.             e2 = get3bytes(bsl+i+BPE);
  306.             if (e1 > e2) {            /* switch if out of order */
  307.                 put3bytes(bsl+i, e2);
  308.                 put3bytes(bsl+i+BPE, e1);
  309.                 change = 1;
  310.             }
  311.         }
  312.         end -= BPE;
  313.     }
  314. }
  315.  
  316.  
  317. /*
  318.  *  Search through a sorted BSL for a given sector number.
  319.  *    Input:
  320.  *        sect - sector number searching for.
  321.  *        entries - number of used entries in the BSL.
  322.  *    Return:
  323.  *        YES - if given sector is found.
  324.  *        NO - if given sector is not found.
  325.  *    Algorithm:
  326.  *        Binary Search.
  327.  */
  328. srchbsl(sect, entries)
  329. SECTOR  sect;    /* sector searching for */
  330. long  entries;    /* num used entries in BSL */
  331. {
  332.     long  start, mid, end; /* start, middle and end indices into list */
  333.     SECTOR  temp;       /* sector number in middle of list */
  334.     long  get3bytes();
  335.  
  336.     start = RENT;        /* start after reserved entries */
  337.     end = entries+RENT-1;    /* end of BSL */ 
  338.     
  339.     while (1) {
  340.          mid = (start + end) / 2;        /* middle entry in list */
  341.         temp = get3bytes(bsl+(mid*BPE));    /* sector num at mid entry */
  342.         
  343.         if (sect == temp)    /* given sector == sector at mid entry */
  344.             return YES;        /* given sector found in list */
  345.         else if (sect < temp)    /* given sector < sector at mid entry */
  346.             end = mid - 1;    /* limit search to smaller sector num */
  347.         else            /* given sector > sector at mid entry */
  348.             start = mid + 1;    /* limit search to larger sector num */
  349.             
  350.         if (end < start)    /* list is exhausted */
  351.             return NO;        /* can't find given sector */    
  352.     }
  353. }
  354.  
  355.  
  356. /*
  357.  *  Checksum (byte-wise) the BSL.
  358.  *    Input:
  359.  *        bsl - pointer to the BSL.  (in bsl.h)
  360.  *    Return:
  361.  *        OK - BSL checksum to BSLMAGIC (0xa5).
  362.  *        INVALID - BSL does not checksum to BSLMAGIC.
  363.  */
  364. sumbsl()
  365. {
  366.     register BYTE sum;    /* byte-wise sum of BSL */
  367.     long i;        /* index into BSL */
  368.     long length;    /* length of BSL in bytes */
  369.  
  370.     length = bslsiz*512;    /* length of entire BSL */
  371.     sum = 0;    /* initialize the sum */
  372.     
  373.     /* Sum up values in the BSL by byte */
  374.     for (i = 0; i < length; i++) {
  375.         sum += bsl[i];
  376.     }
  377.     if (sum != BSLMAGIC) {    /* doesn't checksum correctly */
  378.         return INVALID;
  379.     }
  380.     return OK;    /* checksum correctly */
  381. }
  382.  
  383.  
  384. /*
  385.  *  Make the BSL checks sum to BSLMAGIC.
  386.  */
  387. mkmagic()
  388. {
  389.     register BYTE diff;    /* difference to make BSL checks sum correctly */
  390.     long i;        /* index into BSL */
  391.     long len;        /* length of BSL in bytes */
  392.     
  393.     len = bslsiz*512;    /* length of entire BSl */
  394.     diff = BSLMAGIC;    /* initialize the difference */
  395.     
  396.     /* find out what number would make BSL checks sum to BSLMAGIC */
  397.     for (i = 0; i < len; i++) {
  398.         diff -= bsl[i];
  399.     }
  400.     
  401.     /* add that difference to checksum byte (1st byte of 2nd entry of BSL) */
  402.     bsl[BPE] += diff;
  403. }
  404.  
  405.  
  406. /*
  407.  *  Add bad sectors found to the Bad Sector List.
  408.  *    Input:
  409.  *        pdev - physical unit BSL belongs to.
  410.  *        portion - portion of BSL to add to.  VENDOR or USER.
  411.  *        nbad - number of bad sectors to be added.
  412.  *    Return:
  413.  *        nadd - number of new bad sectors added to the BSL.
  414.  *        USRFULL - user part of the BSL is filled up.
  415.  *        NOMEM - not enough memory for add buffer or BSL.
  416.  *        ERROR - something is wrong.
  417.  *    Comment:
  418.  *        The entry will be added only if it is not already on the
  419.  *    bad sector list.  Binary search is performed to guarantee this.
  420.  *        If the VENDOR list is full, this routine will take care
  421.  *    of the expansion of the list also.
  422.  */
  423. addbsl(pdev, portion, nbad) 
  424. int pdev;        /* physical unit number */
  425. int portion;        /* portion of BSL */
  426. int nbad;        /* num of bad sectors to be added */
  427. {
  428.     long  entries;    /* num entries to be retained in BSL */
  429.     long  empty;    /* num empty slots available for adding entries */
  430.     long  end;        /* address of end of BSL */
  431.     int  i, toadd;    /* index to badbuf, num of bad sectors to be added */
  432.     int  ret;        /* return code */
  433.     SECTOR *addbuf;    /* bad sectors to be added to BSL */
  434.     long  nument();
  435.     
  436.     /* Allocate memory for sector numbers of bad sectors to be added */
  437.     if ((addbuf = (SECTOR *)mymalloc(nbad*4)) <= 0) {
  438.         err(nomemory);
  439.         return NOMEM;
  440.     }
  441.     
  442.     if (portion == VENDOR) {    /* adding to VENDOR list */
  443.         entries = nument(VENDOR);   /* only keep the VENDOR list */
  444.         empty = 0;            /* there's no unused slot for VENDOR ent */
  445.     } else {            /* adding to USER list */
  446.         entries = nument(MEDIA);    /* keep entire list */
  447.         empty = nument(UNUSED);     /* slots left unused */
  448.     }
  449.     sortbsl(entries);        /* sort BSL in ascending order */
  450.     toadd = 0;            /* none is to be added to BSL yet */
  451.  
  452.     /* For all bad sectors found, search for them in the current BSL.
  453.        Add them to the list only when they are not already recorded.  */    
  454.     if (entries) {    /* only search if BSL is not empty */
  455.     for (i = 0; i < nbad; i++) {
  456.         if (srchbsl(*(badbuf+i), entries) == NO) {
  457.         addbuf[toadd] = *(badbuf+i);
  458.         toadd++;
  459.         }
  460.         }
  461.     } else {  /* add in all bad sectors found */
  462.     for (i = 0; i < nbad; i++)
  463.         addbuf[i] = *(badbuf+i);
  464.         toadd = nbad;
  465.     }
  466.     
  467.     /* All bad sectors found have been recorded.  Nothing is added to BSL */
  468.     if (toadd == 0) {
  469.         if (portion == USER && (ret = rdbsl(pdev)) != OK) {
  470.             if (ret == INVALID)
  471.                 err(cruptbsl);
  472.         goto togo;
  473.     }
  474.         ret = toadd;
  475.         goto togo;
  476.     }
  477.     
  478.     /*------------------------------------------------------------------*/
  479.     /* Check if there are enough empty slots for new entries.  If not,    */
  480.     /* determine what kind of entries we are adding, VENDOR or USER.    */    
  481.     /* Expand the BSL if we are adding to VENDOR list.  Give warning    */
  482.     /* if we are adding to USER list.                          */
  483.     /*------------------------------------------------------------------*/
  484.     if (toadd > empty) {
  485.         if (portion == VENDOR) {    /* this only happens at format time */
  486.         /* expanded BSL should hold (entries + toadd) VENDOR entries */
  487.         if ((ret = creabsl(pdev, EXPAND, entries+toadd)) != OK)
  488.             goto togo;
  489.         } else {        /* We are adding to USER list */
  490.             err(manybad);
  491.             toadd = empty;    /* num ent to add = empty slots available */
  492.         }
  493.     }
  494.     
  495.     /* Read in orig unsorted list if adding USER entries */
  496.     if (portion == USER) {
  497.         if ((ret = rdbsl(pdev)) != OK) {
  498.             if (ret == INVALID)
  499.                 err(cruptbsl);
  500.             goto togo;
  501.         }
  502.     }
  503.                 
  504.     /* Append new entries to end of BSL */
  505.     end = bsl + (RENT + entries)*BPE;    /* end of BSL */
  506.     for (i = 0; i < toadd; i++) {
  507.         put3bytes((end + i*BPE), addbuf[i]);
  508.     }
  509.     
  510.     /* make BSL checks sum to magic number */
  511.     mkmagic();
  512.  
  513.     if (portion == USER && toadd == empty) {
  514.         ret = USRFULL;
  515.         goto togo;
  516.     }
  517.  
  518.     ret = toadd;
  519. togo:
  520.     if (addbuf > 0L) free(addbuf);            
  521.     return(ret);
  522. }
  523.  
  524.  
  525. /*
  526.  *  Mark bad sectors from the BSL to FATs of a partition.
  527.  *    Input:
  528.  *        ldev - logical device the FATs belong to.
  529.  *        fat0 - logical sector number of where FAT 0 starts.
  530.  *        fatsiz - size of FAT in # log sectors.
  531.  *        data - logical sector number of where data clusters start.
  532.  *        portion - part of BSL to mark from.
  533.  *        sratio - 
  534.  */
  535. bsl2fat(ldev, fat0, fatsiz, data, portion, sratio)
  536. int  ldev;    /* logical device number */
  537. SECTOR fat0;    /* starting sector number (logical) of FAT 0 */ 
  538. WORD fatsiz;    /* FAT size in # log sectors */
  539. SECTOR data;    /* starting sector number (logical) of data clusters */
  540. int portion;    /* part of BSL to mark from, VENDOR or MEDIA */
  541. WORD sratio;    /* log sector size : phys sector size */
  542. {
  543.     long nument(), entries;    /* num entries in the list to be considered */
  544.     long i, end;        /* indices to the list to be considered */
  545.     SECTOR badsect;        /* a bad sector in the list */
  546.     SECTOR pstart;        /* phys sector num where partition starts */
  547.     SECTOR pdata;        /* phys sector num where data block starts */
  548.     SECTOR pend;        /* phys sector num where data block ends */
  549.     extern SECTOR logstart(), logend();
  550.     int nbad;
  551.     
  552.     pstart = logstart(ldev);        /* find partition phys start sector */
  553.     pdata = pstart + (data*sratio);    /* find data phys start sector */
  554.     pend = logend(ldev);        /* find where data block ends */    
  555.     entries = nument(portion);        /* find num entries in given portion */
  556.     sortbsl(entries);            /* sort given portion of BSL */
  557.     
  558.     end = (RENT + entries) * BPE;
  559.     nbad = 0;
  560.     
  561.     /* Store vendor bad sectors of the logical device in badbuf */
  562.     for (i = BPE*RENT; i < end; i += BPE) {
  563.         if ((badsect = get3bytes(bsl+i)) > pend)
  564.             break;
  565.             
  566.         if (badsect >= pdata) {
  567.             *(badbuf+nbad) = badsect;
  568.             nbad++;
  569.             
  570.             /* if badbuf overflows, mark what we have so far in the FAT */
  571.             if (nbad == WARNBADSECTS) {
  572.                 if (fixbadcls(ldev, fat0, fatsiz, data, nbad, sratio) != OK) {
  573.                     return ERROR;
  574.                 }
  575.                 nbad = 0;    /* reinit num bad sectors in partition to 0 */
  576.             }
  577.         }
  578.     }
  579.     
  580.     /* Bad sectors in partition not marked in FAT yet */
  581.     if (nbad) {
  582.         if (fixbadcls(ldev, fat0, fatsiz, data, nbad, sratio) != OK) {
  583.             return ERROR;
  584.         }
  585.     }
  586.     
  587.     return OK;
  588. }
  589.  
  590.  
  591. /*
  592.  *  Count number of bad sectors on a logical drive recorded in BSL.
  593.  *    Input:
  594.  *        ldev - logical drive to be considered.
  595.  *    Return:
  596.  *        nbad - number of bad sectors found.
  597.  */
  598. long
  599. cntbad(ldev)
  600. int  ldev;    /* logical drive number */
  601. {
  602.     SECTOR pstart, pend;    /* phys starting and ending block of ldev */
  603.     extern SECTOR logstart(), logend();
  604.     long nbad=0L;        /* num bad sectors on ldev */
  605.     long entries, nument(), bslend;
  606.     long curr, get3bytes();
  607.     int done, i;
  608.     
  609.     pstart = logstart(ldev);    /* starting block # of partition */
  610.     pend = logend(ldev);    /* ending block # of partition */
  611.     entries = nument(MEDIA);    /* num entries in BSL */
  612.     sortbsl(entries);        /* sort BSL */
  613.     
  614.     done = 0;
  615.     bslend = (RENT+entries) * BPE;
  616.     for (i = RENT*BPE; (!done) && (i < bslend); i += BPE) {
  617.         curr = get3bytes(bsl+i);  /* get next entry in BSL */
  618.         if (curr < pstart)      /* not within logical drive's range yet */
  619.             continue;
  620.         if (curr <= pend)      /* within logical drive's range */
  621.             nbad++;
  622.         else done = 1;          /* pass logical drive's range */
  623.     }
  624.     return (nbad);
  625. }
  626.  
  627.  
  628. /*
  629.  *  Put a word into memory in 68000 format.
  630.  *    Input:
  631.  *        p - pointer to memory.
  632.  *        i - word to be put.
  633.  */
  634. putword(p, i)
  635. BYTE *p;
  636. unsigned int i;
  637. {
  638.     *p = i >> 8;
  639.     *(p+1) = i;
  640. }
  641.  
  642.  
  643. /*
  644.  *  Get a 68000 format word from memory.
  645.  *    Input:
  646.  *        p - pointer to memory.
  647.  *    Return:
  648.  *        i - word read from memory.
  649.  */        
  650. getword(p)
  651. BYTE *p;
  652. {
  653.     unsigned int i;
  654.     
  655.     i = *p;
  656.     i <<= 8;
  657.     i |= *(p+1);
  658.     return (i);
  659. }
  660.  
  661.  
  662. /*
  663.  *  Put 3 bytes (68000 format) into memory.
  664.  *    Input:
  665.  *        p - pointer to memory.
  666.  *        l - long which contains the 3 bytes at the low-bit end.
  667.  */
  668. put3bytes(p, l)
  669. BYTE *p;
  670. long l;
  671. {
  672.     *p = l >> 16;
  673.     *(p+1) = l >> 8;
  674.     *(p+2) = l;
  675. }    
  676.  
  677.  
  678. /*
  679.  *  Get 3 bytes (68000 format) from memory.
  680.  *    Input:
  681.  *        p - pointer to memory.
  682.  *    Return:
  683.  *        l - a long which contains the 3 bytes read in last 3 bytes.
  684.  */
  685. long
  686. get3bytes(p)
  687. BYTE *p;
  688. {
  689.     long  k=0x000000ff, l=0x000000ff;
  690.     
  691.     l &= *p;        /* first byte */
  692.     l <<= 16;
  693.     k &= *(p+1);    /* second byte */
  694.     k <<= 8;
  695.     l |= k;
  696.     k = 0x000000ff;
  697.     k &= *(p+2);    /* third byte */
  698.     l |= k;
  699.     return (l);
  700. }
  701.