cmd/addbadsec/ix_altsctr.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * copyright (c) 1990, 1991 UNIX System Laboratories, Inc.
 * copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T
 * All rights reserved.
 */

/*
 * Copyrighted as an unpublished work.
 * (c) Copyright INTERACTIVE Systems Corporation 1986, 1988, 1990
 * All rights reserved.
 */

#include <sys/types.h>
#include <ctype.h>
#include <fcntl.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/swap.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/vtoc.h>
#include <sys/param.h>
#include <sys/dkio.h>
#include <sys/dktp/altsctr.h>
#include <sys/dktp/fdisk.h>
#include "badsec.h"

#define FAILURE 0
#define SUCCESS 1

#define CMD_READ    0
#define CMD_WRITE   1

struct  badsec_lst *badsl_chain;
int badsl_chain_cnt;
struct  badsec_lst *gbadsl_chain;
int gbadsl_chain_cnt;

extern struct dk_geom   dkg;
extern int  alts_fd;

struct  alts_mempart alts_part = { 0, NULL, 0 };
struct  alts_mempart *ap = &alts_part;  /* pointer to incore alts tables */

static void read_altsctr(struct extpartition *part, int badok);
static void chk_badsec(void);
static void init_altsctr(void);
void wr_altsctr(void);
static void get_badsec(void);
static int count_badsec(void);
static void gen_alts_ent(void);
static void assign_altsctr(void);
static void expand_map(void);
static void compress_map(void);
static int altsmap_getbit(blkaddr_t badsec);
static blkaddr_t altsmap_alloc(blkaddr_t srt_ind, blkaddr_t end_ind,
    int cnt, int dir);
static void ent_sort(struct alts_ent buf[], int cnt);
static void ent_compress(struct alts_ent buf[], int cnt);
static int  ent_merge(
    struct alts_ent buf[],
    struct alts_ent list1[],
    int    lcnt1,
    struct alts_ent list2[],
    int    lcnt2);
static int  ent_bsearch(struct alts_ent buf[], int cnt, struct alts_ent *key);
static int  chk_bad_altsctr(blkaddr_t badsec);
int print_altsec(struct extpartition *part);
int get_altsctr(int);
static void print_altsctr(void);
static int  absdsk_io(int fd, uint_t srtsec, char *bufp, uint_t len,
    int ioflag);

/*
 * updatebadsec () -- update bad sector/track mapping tables
 */
int
updatebadsec(struct extpartition *part, int init_flag)
{
    if (init_flag)
        ap->ap_flag |= ALTS_ADDPART;
    get_badsec();
    read_altsctr(part, 1);
    ent_sort(ap->ap_gbadp, ap->ap_gbadcnt);
    ent_compress(ap->ap_gbadp, ap->ap_gbadcnt);
    gen_alts_ent();
    compress_map();
    return (SUCCESS);
}

/*
 * read_altsctr( ptr to alternate sector partition )
 *      -- read the alternate sector partition tables
 */
static void
read_altsctr(struct extpartition *part, int badok)
{
    if (ap->ap_tblp == NULL) {
/*      allocate buffer for the alts partition table (sector size)  */
        ap->ap_tbl_secsiz = byte_to_secsiz(ALTS_PARTTBL_SIZE, NBPSCTR);
        ap->ap_tblp = (struct alts_parttbl *)malloc(ap->ap_tbl_secsiz);
        if (ap->ap_tblp == NULL) {
        (void) fprintf(stderr,
            "Unable to malloc alternate partition table.\n");
        exit(50);
        }

/*      allocate buffer for the alts partition map (sector size)    */
/*      buffers include the disk image bit map          */
/*      and the incore transformed char map             */

        if ((ap->ap_memmapp = (uchar_t *)malloc(part->p_size)) == NULL) {
        (void) fprintf(stderr,
            "Unable to malloc incore alternate partition map.\n");
        exit(51);
        }
        ap->ap_tblp->alts_map_len = (part->p_size + 8 - 1) / 8;
        ap->ap_map_secsiz = byte_to_secsiz(ap->ap_tblp->alts_map_len,
        NBPSCTR);
        ap->ap_map_sectot = ap->ap_map_secsiz / NBPSCTR;
        if ((ap->ap_mapp = (uchar_t *)malloc(ap->ap_map_secsiz)) == NULL) {
        (void) fprintf(stderr,
            "Unable to malloc alternate partition map.\n");
        exit(52);
        }
/*      clear the buffers to zero                   */
        (void) memset(ap->ap_memmapp, 0, part->p_size);
        (void) memset(ap->ap_mapp, 0, ap->ap_map_secsiz);
        ap->part = *part;       /* struct copy          */

/*
 *      if add alternate partition flag is set, then install the partition
 *      otherwise read the alts partition info from disk
 *      if failed, then assume the first installation
 */
        if (ap->ap_flag & ALTS_ADDPART) {
        (void) fprintf(stderr,
            "WARNING: Manually initializing alternate table.\n");
        init_altsctr();
        } else {
            if (get_altsctr(badok) == SUCCESS)
            chk_badsec();
            else
            init_altsctr();
        }
    }
}


/*
 *  checking duplicate bad sectors or bad sectors in ALTSCTR partition
 */
static void
chk_badsec(void)
{
    blkaddr_t   badsec;
    blkaddr_t   altsp_srtsec = ap->part.p_start;
    blkaddr_t   altsp_endsec = ap->part.p_start + ap->part.p_size - 1;
    int cnt;
    int status;

    for (cnt = 0; cnt < ap->ap_gbadcnt; cnt++) {
        badsec = (ap->ap_gbadp)[cnt].bad_start;

        /* if bad sector is within the ATLSCTR partition */
        if ((badsec >= altsp_srtsec) && (badsec <= altsp_endsec)) {
        if ((ap->ap_memmapp)[badsec - altsp_srtsec] != ALTS_BAD) {
            if ((badsec >= altsp_srtsec) && (badsec <= (altsp_srtsec +
            ap->ap_tbl_secsiz / NBPSCTR - 1))) {
                (void) fprintf(stderr,
                "Alternate partition information table is bad.\n");
                exit(53);
                }
            if ((badsec >= altsp_srtsec+ap->ap_tblp->alts_map_base) &&
            (badsec <= (altsp_srtsec + ap->ap_tblp->alts_map_base +
            ap->ap_map_sectot - 1))) {
                (void) fprintf(stderr,
                "Alternate partition map is bad.\n");
                exit(54);
                }
            if ((badsec >= altsp_srtsec+ap->ap_tblp->alts_ent_base) &&
            (badsec <= (altsp_srtsec + ap->ap_tblp->alts_ent_base +
            ap->ap_ent_secsiz / NBPSCTR - 1))) {
                (void) fprintf(stderr,
                "Alternate partition entry table is bad.\n");
                exit(55);
                }
            (ap->ap_memmapp)[badsec - altsp_srtsec] = ALTS_BAD;
            (ap->ap_gbadp)[cnt].bad_start = (uint32_t)ALTS_ENT_EMPTY;
        } else {
            status = chk_bad_altsctr(badsec);
            (ap->ap_gbadp)[cnt].bad_start = (uint32_t)ALTS_ENT_EMPTY;
        }
        } else {
/*
 *      binary search for bad sector in the alts entry table
 */
        status = ent_bsearch(ap->ap_entp, ap->ap_tblp->alts_ent_used,
                    &((ap->ap_gbadp)[cnt]));
/*
 *      if the bad sector had already been remapped(found in alts_entry)
 *      then ignore the bad sector
 */
        if (status != -1) {
            (ap->ap_gbadp)[cnt].bad_start = (uint32_t)ALTS_ENT_EMPTY;
        }
        }
    }

}

/*
 *  initialize the alternate partition tables
 */
static void
init_altsctr(void)
{
    blkaddr_t   badsec;
    blkaddr_t   altsp_srtsec = ap->part.p_start;
    blkaddr_t   altsp_endsec = ap->part.p_start + ap->part.p_size - 1;
    int cnt;

    ap->ap_entp = NULL;
    ap->ap_ent_secsiz = 0;
    ap->ap_tblp->alts_sanity = ALTS_SANITY;
    ap->ap_tblp->alts_version = ALTS_VERSION1;
    ap->ap_tblp->alts_map_len = (ap->part.p_size + 8 - 1) / 8;
    ap->ap_tblp->alts_ent_used = 0;
    ap->ap_tblp->alts_ent_base = 0;
    ap->ap_tblp->alts_ent_end  = 0;
    ap->ap_tblp->alts_resv_base = ap->part.p_size - 1;
    for (cnt = 0; cnt < 5; cnt++)
        ap->ap_tblp->alts_pad[cnt] = 0;

    for (cnt = 0; cnt < ap->ap_gbadcnt; cnt++) {
        badsec = (ap->ap_gbadp)[cnt].bad_start;
        if ((badsec >= altsp_srtsec) && (badsec <= altsp_endsec)) {
        if (badsec == altsp_srtsec) {
            (void) fprintf(stderr,
            "First sector of alternate partition is bad.\n");
            exit(56);
            }
        (ap->ap_memmapp)[badsec - altsp_srtsec] = ALTS_BAD;
        (ap->ap_gbadp)[cnt].bad_start = (uint32_t)ALTS_ENT_EMPTY;
        }
    }

/*  allocate the alts_map on disk skipping possible bad sectors */
    ap->ap_tblp->alts_map_base =
        altsmap_alloc(ap->ap_tbl_secsiz / NBPSCTR,
            ap->part.p_size, ap->ap_map_sectot, ALTS_MAP_UP);
    if (ap->ap_tblp->alts_map_base == NULL) {
        perror("Unable to allocate alternate map on disk: ");
        exit(57);
    }

}


/*
 *  read the alternate partition tables from disk
 */
int
get_altsctr(badok)
int badok;
{
/*  get alts partition table info                   */
    if (absdsk_io(alts_fd, 0, (char *)ap->ap_tblp,
            ap->ap_tbl_secsiz, CMD_READ) == FAILURE) {
        if (badok)
        return(FAILURE);
        perror("Unable to read alternate sector partition: ");
        exit(58);
    }
    if (ap->ap_tblp->alts_sanity != ALTS_SANITY) {
        if (badok)
        return(FAILURE);
        (void) fprintf(stderr, "Bad alternate sector magic number.\n");
        exit(69);
    }

/*  get the alts map                        */
    if (absdsk_io(alts_fd, ap->ap_tblp->alts_map_base,
        (char *)ap->ap_mapp, ap->ap_map_secsiz, CMD_READ) == FAILURE) {
        if (badok)
        return(FAILURE);
        perror("Unable to read alternate sector partition map: ");
        exit(59);
    }

/*  transform the disk image bit-map to incore char map     */
    expand_map();

    if (ap->ap_tblp->alts_ent_used == 0) {
        ap->ap_entp = NULL;
        ap->ap_ent_secsiz = 0;
    } else {
        ap->ap_ent_secsiz = byte_to_secsiz(
            (ap->ap_tblp->alts_ent_used*ALTS_ENT_SIZE),NBPSCTR);
        if ((ap->ap_entp =
        (struct alts_ent *)malloc(ap->ap_ent_secsiz)) == NULL) {
        if (badok)
            return(FAILURE);
        (void) fprintf(stderr,
            "Unable to malloc alternate sector entry table.\n");
        exit(60);
        }

        if (absdsk_io(alts_fd, ap->ap_tblp->alts_ent_base,
            (char *)ap->ap_entp, ap->ap_ent_secsiz,
        CMD_READ) ==FAILURE){
        if (badok)
            return(FAILURE);
        perror("Unable to read alternate sector entry table: ");
        exit(61);
        }
    }
    return(SUCCESS);
}


/*
 *  update the new alternate partition tables on disk
 */
void
wr_altsctr(void)
{
    if (ap->ap_tblp == NULL)
        return;
    if (absdsk_io(alts_fd, 0, (char *)ap->ap_tblp,
        ap->ap_tbl_secsiz, CMD_WRITE) == FAILURE) {
        perror("Unable to write alternate sector partition: ");
        exit(62);
    }

    if (absdsk_io(alts_fd, ap->ap_tblp->alts_map_base,
        (char *)ap->ap_mapp, ap->ap_map_secsiz, CMD_WRITE) == FAILURE) {
        perror("Unable to write alternate sector partition map: ");
        exit(63);
    }

    if (ap->ap_tblp->alts_ent_used != 0) {
        if (absdsk_io(alts_fd, ap->ap_tblp->alts_ent_base,
                    (char *)ap->ap_entp, ap->ap_ent_secsiz,
                CMD_WRITE) == FAILURE) {
        perror("Unable to write alternate sector entry table: ");
        exit(64);
        }
    }
}


/*
 *  get a list of bad sector
 */
static void
get_badsec(void)
{
    int cnt;
    struct  badsec_lst *blc_p;
    blkaddr_t   curbad;
    blkaddr_t   maxsec = (blkaddr_t)dkg.dkg_nhead *
                    dkg.dkg_ncyl * dkg.dkg_nsect;
    struct  alts_ent *growbadp;
    int i;

    cnt = count_badsec();
    if (!cnt) {
        ap->ap_gbadp = NULL;
        ap->ap_gbadcnt = 0;
    } else {
        ap->ap_gbadp = (struct alts_ent *)malloc(cnt*ALTS_ENT_SIZE);
        (void) memset(ap->ap_gbadp,0,cnt*ALTS_ENT_SIZE);

        for (growbadp = ap->ap_gbadp, cnt=0, blc_p=badsl_chain;
        blc_p; blc_p=blc_p->bl_nxt) {
        for (i=0; i<blc_p->bl_cnt; i++) {
            curbad = blc_p->bl_sec[i];
            if (curbad < (blkaddr_t)dkg.dkg_nsect) {
                (void) fprintf(stderr,
                "Ignoring bad sector %ld which is in first"
                " track of the drive.\n", curbad);
                continue;
            }
            if (curbad >= maxsec) {
                (void) fprintf(stderr,
                "Ignoring bad sector %ld which is past"
                " the end of the drive.\n", curbad);
                continue;
            }
            growbadp[cnt].bad_start = curbad;
            growbadp[cnt].bad_end = curbad;
            cnt++;
        }
        }
    }
    ap->ap_gbadcnt = cnt;
}

/*
 *  count number of bad sector on list
 *  merging the bad sector list from surface analysis and the
 *  one given through the command line
 */
static int
count_badsec(void)
{

    struct badsec_lst *blc_p;

    if (!badsl_chain)
        badsl_chain = gbadsl_chain;
    else {
        for (blc_p = badsl_chain; blc_p->bl_nxt; blc_p = blc_p->bl_nxt)
            ;
        blc_p->bl_nxt = gbadsl_chain;
    }

    badsl_chain_cnt += gbadsl_chain_cnt;
    return(badsl_chain_cnt);
}


/*
 *  generate alternate entry table by merging the existing and
 *  the new entry list.
 */
static void
gen_alts_ent(void)
{
    uint_t  ent_used;
    struct  alts_ent *entp;

    if (ap->ap_gbadcnt == 0)
        return;

    ent_used = ap->ap_tblp->alts_ent_used + ap->ap_gbadcnt;
    ap->ap_ent_secsiz = byte_to_secsiz(ent_used*ALTS_ENT_SIZE,NBPSCTR);
    entp=(struct alts_ent *) malloc (ap->ap_ent_secsiz);
    ent_used = ent_merge(entp, ap->ap_entp, ap->ap_tblp->alts_ent_used,
                 ap->ap_gbadp, ap->ap_gbadcnt);
    if (ap->ap_entp)
        free(ap->ap_entp);
    if (ap->ap_gbadp)
        free(ap->ap_gbadp);
    ap->ap_entp = entp;
    ap->ap_ent_secsiz = byte_to_secsiz(ent_used*ALTS_ENT_SIZE, NBPSCTR);
    ap->ap_tblp->alts_ent_used = ent_used;
    ap->ap_gbadp = NULL;
    ap->ap_gbadcnt = 0;

/*  assign alternate sectors to the bad sectors         */
    assign_altsctr();

/*  allocate the alts_entry on disk skipping possible bad sectors   */
    ap->ap_tblp->alts_ent_base =
        altsmap_alloc(ap->ap_tblp->alts_map_base + ap->ap_map_sectot,
            ap->part.p_size,
            ap->ap_ent_secsiz / NBPSCTR, ALTS_MAP_UP);
    if (ap->ap_tblp->alts_ent_base == NULL) {
        perror("Unable to allocate alternate entry table on disk: ");
        exit(65);
    }

    ap->ap_tblp->alts_ent_end = ap->ap_tblp->alts_ent_base +
            (ap->ap_ent_secsiz / NBPSCTR) - 1;
}


/*
 *  assign alternate sectors for bad sector mapping
 */
static void
assign_altsctr(void)
{
    uint_t  i;
    uint_t  j;
    blkaddr_t   alts_ind;
    uint_t  cluster;

    for (i = 0; i < ap->ap_tblp->alts_ent_used; i++) {
        if ((ap->ap_entp)[i].bad_start == (uint32_t)ALTS_ENT_EMPTY)
        continue;
        if ((ap->ap_entp)[i].good_start != 0)
        continue;
        cluster = (ap->ap_entp)[i].bad_end-(ap->ap_entp)[i].bad_start +1;
        alts_ind =
        altsmap_alloc(ap->part.p_size-1, ap->ap_tblp->alts_map_base +
            ap->ap_map_sectot - 1, cluster, ALTS_MAP_DOWN);
        if (alts_ind == NULL) {
            (void) fprintf(stderr,
            "Unable to allocate alternates for bad starting"
            " sector %u.\n", (ap->ap_entp)[i].bad_start);
            exit(65);
        }
        alts_ind = alts_ind - cluster + 1;
        (ap->ap_entp)[i].good_start = alts_ind + ap->part.p_start;
        for (j = 0; j < cluster; j++) {
        (ap->ap_memmapp)[alts_ind+j] = ALTS_BAD;
        }

    }

}

/*
 *  transform the disk image alts bit map to incore char map
 */
static void
expand_map(void)
{
    int     i;

    for (i = 0; i < ap->part.p_size; i++) {
        (ap->ap_memmapp)[i] = altsmap_getbit(i);
    }
}

/*
 *  transform the incore alts char map to the disk image bit map
 */
static void
compress_map(void)
{

    int     i;
    int bytesz;
    char    mask = 0;
    int maplen = 0;

    for (i = 0, bytesz = 7; i < ap->part.p_size; i++) {
        mask |= ((ap->ap_memmapp)[i] << bytesz--);
        if (bytesz < 0) {
        (ap->ap_mapp)[maplen++] = mask;
        bytesz = 7;
        mask = 0;
        }
    }
/*
 *  if partition size != multiple number of bytes
 *  then record the last partial byte
 */
    if (bytesz != 7)
        (ap->ap_mapp)[maplen] = mask;

}

/*
 *  given a bad sector number, search in the alts bit map
 *  and identify the sector as good or bad
 */
static int
altsmap_getbit(blkaddr_t badsec)
{
    uint_t  slot = badsec / 8;
    uint_t  field = badsec % 8;
    uchar_t mask;

    mask = ALTS_BAD<<7;
    mask >>= field;
    if ((ap->ap_mapp)[slot] & mask)
         return(ALTS_BAD);
    return(ALTS_GOOD);
}


/*
 *  allocate a range of sectors from the alternate partition
 */
static blkaddr_t
altsmap_alloc(blkaddr_t srt_ind, blkaddr_t end_ind, int cnt, int dir)
{
    blkaddr_t   i;
    blkaddr_t   total;
    blkaddr_t   first_ind;

    for (i = srt_ind, first_ind = srt_ind, total = 0;
        i != end_ind; i += dir) {
        if ((ap->ap_memmapp)[i] == ALTS_BAD) {
        total = 0;
        first_ind = i + dir;
        continue;
        }
        total++;
        if (total == cnt)
        return(first_ind);

    }
    return(0);
}


/*
 *  bubble sort the entry table into ascending order
 */
static void
ent_sort(struct alts_ent buf[], int cnt)
{
struct  alts_ent temp;
int flag;
int i, j;

    for (i = 0; i < cnt-1; i++) {
        temp = buf[cnt-1];
        flag = 1;

        for (j = cnt-1; j > i; j--) {
        if (buf[j-1].bad_start < temp.bad_start) {
            buf[j] = temp;
            temp = buf[j-1];
        } else {
            buf[j] = buf[j-1];
            flag = 0;
        }
        }
        buf[i] = temp;
        if (flag) break;
    }

}


/*
 *  compress all the contiguous bad sectors into a single entry
 *  in the entry table. The entry table must be sorted into ascending
 *  before the compression.
 */
static void
ent_compress(struct alts_ent buf[], int cnt)
{
int keyp;
int movp;
int i;

    for (i = 0; i < cnt; i++) {
        if (buf[i].bad_start == (uint32_t)ALTS_ENT_EMPTY)
        continue;
        for (keyp = i, movp = i+1; movp < cnt; movp++) {
        if (buf[movp].bad_start == (uint32_t)ALTS_ENT_EMPTY)
            continue;
        if (buf[keyp].bad_end+1 != buf[movp].bad_start)
            break;
        buf[keyp].bad_end++;
        buf[movp].bad_start = (uint32_t)ALTS_ENT_EMPTY;
        }
        if (movp == cnt) break;
    }
}


/*
 *  merging two entry tables into a single table. In addition,
 *  all empty slots in the entry table will be removed.
 */
static int
ent_merge(
    struct alts_ent buf[],
    struct alts_ent list1[],
    int    lcnt1,
    struct alts_ent list2[],
    int    lcnt2)
{
    int i;
    int j1, j2;

    for (i = 0, j1 = 0, j2 = 0; j1 < lcnt1 && j2 < lcnt2; ) {
        if (list1[j1].bad_start == (uint32_t)ALTS_ENT_EMPTY) {
        j1++;
        continue;
        }
        if (list2[j2].bad_start == (uint32_t)ALTS_ENT_EMPTY) {
        j2++;
        continue;
        }
        if (list1[j1].bad_start < list2[j2].bad_start)
        buf[i++] = list1[j1++];
        else
        buf[i++] = list2[j2++];
    }
    for (; j1 < lcnt1; j1++) {
        if (list1[j1].bad_start == (uint32_t)ALTS_ENT_EMPTY)
        continue;
        buf[i++] = list1[j1];
    }
    for (; j2 < lcnt2; j2++) {
        if (list2[j2].bad_start == (uint32_t)ALTS_ENT_EMPTY)
        continue;
        buf[i++] = list2[j2];
    }
    return (i);
}


/*
 *  binary search for bad sector in the alternate entry table
 */
static int
ent_bsearch(struct alts_ent buf[], int cnt, struct alts_ent *key)
{
    int i;
    int ind;
    int interval;
    int mystatus = -1;

    if (!cnt)
        return(mystatus);

    for (i = 1; i <= cnt; i <<= 1)
        ind = i;

    for (interval = ind; interval; ) {
/*
        printf("ind= %d, intv= %d; ",ind, interval);
*/
        if ((key->bad_start >= buf[ind-1].bad_start) &&
        (key->bad_start <= buf[ind-1].bad_end)) {
        return(mystatus = ind-1);
        } else {
        interval >>= 1;
        if (!interval) break;
        if (key->bad_start < buf[ind-1].bad_start) {
            ind = ind - interval;
        } else {
 /*             if key is larger than the last element then break   */
            if (ind == cnt) break;
            if ((ind+interval) <= cnt)
                ind += interval;
        }
        }
    }
    return(mystatus);
}

/*
 *  check for bad sector in assigned alternate sectors
 */
static int
chk_bad_altsctr(blkaddr_t badsec)
{
    int i;
    blkaddr_t   numsec;
    int cnt = ap->ap_tblp->alts_ent_used;
/*
 *  blkaddr_t intv[3];
 */

    for (i = 0; i < cnt; i++) {
        numsec = (ap->ap_entp)[i].bad_end - (ap->ap_entp)[i].bad_start;
        if ((badsec >= (ap->ap_entp)[i].good_start) &&
        (badsec <= ((ap->ap_entp)[i].good_start + numsec))) {
        (void) fprintf(stderr, "Bad sector %ld is an assigned"
            " alternate sector.\n", badsec);
        exit(66);
/*
 *      if (!numsec) {
 *          (ap->ap_entp)[i].good_start = 0;
 *          return (FAILURE);
 *      }
 *      intv[0] = badsec - (ap->ap_entp)[i].good_start;
 *      intv[1] = 1;
 *      intv[2] = (ap->ap_entp)[i].good_start + numsec - badsec;
 */
        }
    }
    /* the bad sector has already been identified as bad */
    return(SUCCESS);
}


/*
 * print_altsec () -- print alternate sector information
 */
int
print_altsec(struct extpartition *part)
{
    ap->ap_tblp = NULL;
    ap->ap_flag &= ~ALTS_ADDPART;
    read_altsctr(part, 0);
    print_altsctr();
    return(SUCCESS);
}

static void
print_altsctr(void)
{
    int i;
    int totalloc;
    int avail;

/*  find # of available alternate sectors               */
    for (i=0, totalloc=0; i<ap->part.p_size; i++) {
        if ((ap->ap_memmapp)[i])
        totalloc++;
    }
/*
 *  available = size of partition - allocated sectors/bad sectors
 *          - partition table - partition map
 *          - entry table
 */
    avail = ap->part.p_size - totalloc;
    avail = avail - (ap->ap_tbl_secsiz/NBPSCTR)
        - ap->ap_map_sectot;
    avail = avail-(ap->ap_tblp->alts_ent_end -ap->ap_tblp->alts_ent_base+1);
    if (avail < 0) avail = 0;

    (void) printf("\nALTERNATE SECTOR/TRACK MAPPING TABLE:\n");
    (void) printf("\nBad Sector Start\tAlternate Sector Start\t\tCount\n");

    for (i=0; i<ap->ap_tblp->alts_ent_used; i++) {
         (void) printf("\t%u\t     ->\t\t%u\t\t\t   %u\n",
        (ap->ap_entp)[i].bad_start,
        (ap->ap_entp)[i].good_start,
        ((ap->ap_entp)[i].bad_end - (ap->ap_entp)[i].bad_start + 1));
    }
    (void) printf("\n      %d alternate sector(s) left for allocation.\n",
        avail);

}

static int
absdsk_io(int fd, uint_t srtsec, char *bufp, uint_t len, int ioflag)
{
    int rc;

    if (llseek (fd, (offset_t)srtsec * NBPSCTR, SEEK_SET) == -1)
        return(FAILURE);
    switch (ioflag)
    {
    case CMD_READ:
        rc = read (fd, bufp, len);
        break;
    case CMD_WRITE:
        rc = write (fd, bufp, len);
        break;
    default:
        break;
    }
    if (rc == -1)
        return(FAILURE);
    return(SUCCESS);
}