17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate * 267c478bd9Sstevel@tonic-gate * copyright (c) 1990, 1991 UNIX System Laboratories, Inc. 277c478bd9Sstevel@tonic-gate * copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T 287c478bd9Sstevel@tonic-gate * All rights reserved. 297c478bd9Sstevel@tonic-gate */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate /* 327c478bd9Sstevel@tonic-gate * Copyrighted as an unpublished work. 337c478bd9Sstevel@tonic-gate * (c) Copyright INTERACTIVE Systems Corporation 1986, 1988, 1990 347c478bd9Sstevel@tonic-gate * All rights reserved. 357c478bd9Sstevel@tonic-gate */ 367c478bd9Sstevel@tonic-gate 377c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 387c478bd9Sstevel@tonic-gate 397c478bd9Sstevel@tonic-gate #include <sys/types.h> 407c478bd9Sstevel@tonic-gate #include <ctype.h> 417c478bd9Sstevel@tonic-gate #include <fcntl.h> 427c478bd9Sstevel@tonic-gate #include <malloc.h> 437c478bd9Sstevel@tonic-gate #include <sys/stat.h> 447c478bd9Sstevel@tonic-gate #include <sys/swap.h> 457c478bd9Sstevel@tonic-gate #include <stdio.h> 467c478bd9Sstevel@tonic-gate #include <string.h> 477c478bd9Sstevel@tonic-gate #include <sys/vtoc.h> 487c478bd9Sstevel@tonic-gate #include <sys/param.h> 497c478bd9Sstevel@tonic-gate #include <sys/dkio.h> 507c478bd9Sstevel@tonic-gate #include <sys/dktp/altsctr.h> 517c478bd9Sstevel@tonic-gate #include <sys/dktp/fdisk.h> 527c478bd9Sstevel@tonic-gate #include "badsec.h" 537c478bd9Sstevel@tonic-gate #include "global.h" 547c478bd9Sstevel@tonic-gate #include "ctlr_ata.h" 557c478bd9Sstevel@tonic-gate #include "misc.h" 567c478bd9Sstevel@tonic-gate 577c478bd9Sstevel@tonic-gate #define FAILURE 1 587c478bd9Sstevel@tonic-gate #define SUCCESS 0 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate #define CMD_READ 0 617c478bd9Sstevel@tonic-gate #define CMD_WRITE 1 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate extern daddr_t altsec_offset; /* Alternate sector offset */ 647c478bd9Sstevel@tonic-gate 657c478bd9Sstevel@tonic-gate struct badsec_lst *badsl_chain = NULL; 667c478bd9Sstevel@tonic-gate int badsl_chain_cnt = 0; 677c478bd9Sstevel@tonic-gate struct badsec_lst *gbadsl_chain = NULL; 687c478bd9Sstevel@tonic-gate int gbadsl_chain_cnt = 0; 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate static struct alts_mempart alts_part = { 0, NULL, 0 }; 717c478bd9Sstevel@tonic-gate struct alts_mempart *ap = &alts_part; /* pointer to incore */ 727c478bd9Sstevel@tonic-gate /* alts tables */ 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate /* prototypes */ 757c478bd9Sstevel@tonic-gate int updatebadsec(struct partition *, int); 767c478bd9Sstevel@tonic-gate int read_altsctr(struct partition *); 777c478bd9Sstevel@tonic-gate static int chk_badsec(); 787c478bd9Sstevel@tonic-gate static int init_altsctr(); 797c478bd9Sstevel@tonic-gate static int get_altsctr(); 807c478bd9Sstevel@tonic-gate int wr_altsctr(); 817c478bd9Sstevel@tonic-gate static void get_badsec(); 827c478bd9Sstevel@tonic-gate static int count_badsec(); 837c478bd9Sstevel@tonic-gate static int gen_alts_ent(); 847c478bd9Sstevel@tonic-gate static int assign_altsctr(); 857c478bd9Sstevel@tonic-gate static void expand_map(); 867c478bd9Sstevel@tonic-gate static void compress_map(); 877c478bd9Sstevel@tonic-gate static int altsmap_getbit(daddr_t); 887c478bd9Sstevel@tonic-gate static int altsmap_alloc(daddr_t, daddr_t, int, int); 897c478bd9Sstevel@tonic-gate static void ent_sort(struct alts_ent *, int); 907c478bd9Sstevel@tonic-gate static void ent_compress(struct alts_ent *, int); 917c478bd9Sstevel@tonic-gate static int ent_merge(struct alts_ent *, struct alts_ent *, int, 927c478bd9Sstevel@tonic-gate struct alts_ent *, int); 937c478bd9Sstevel@tonic-gate static int ent_bsearch(struct alts_ent *, int, struct alts_ent *); 947c478bd9Sstevel@tonic-gate static int chk_bad_altsctr(daddr_t); 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate /* 977c478bd9Sstevel@tonic-gate * updatebadsec () -- update bad sector/track mapping tables 987c478bd9Sstevel@tonic-gate */ 997c478bd9Sstevel@tonic-gate int 1007c478bd9Sstevel@tonic-gate updatebadsec(part, init_flag) 1017c478bd9Sstevel@tonic-gate int init_flag; 1027c478bd9Sstevel@tonic-gate struct partition *part; 1037c478bd9Sstevel@tonic-gate { 1047c478bd9Sstevel@tonic-gate if (init_flag) 1057c478bd9Sstevel@tonic-gate ap->ap_flag |= ALTS_ADDPART; 1067c478bd9Sstevel@tonic-gate get_badsec(); 1077c478bd9Sstevel@tonic-gate (void) read_altsctr(part); 1087c478bd9Sstevel@tonic-gate ent_sort(ap->ap_gbadp, ap->ap_gbadcnt); 1097c478bd9Sstevel@tonic-gate ent_compress(ap->ap_gbadp, ap->ap_gbadcnt); 1107c478bd9Sstevel@tonic-gate (void) gen_alts_ent(); 1117c478bd9Sstevel@tonic-gate compress_map(); 1127c478bd9Sstevel@tonic-gate return (SUCCESS); 1137c478bd9Sstevel@tonic-gate } 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate /* 1167c478bd9Sstevel@tonic-gate * read_altsctr( ptr to alternate sector partition ) 1177c478bd9Sstevel@tonic-gate * -- read the alternate sector partition tables 1187c478bd9Sstevel@tonic-gate */ 1197c478bd9Sstevel@tonic-gate int 1207c478bd9Sstevel@tonic-gate read_altsctr(part) 1217c478bd9Sstevel@tonic-gate struct partition *part; 1227c478bd9Sstevel@tonic-gate { 1237c478bd9Sstevel@tonic-gate if (ap->ap_tblp == NULL) { 1247c478bd9Sstevel@tonic-gate /* allocate buffer for the alts partition table (sector size) */ 1257c478bd9Sstevel@tonic-gate ap->ap_tbl_secsiz = byte_to_secsiz(ALTS_PARTTBL_SIZE, NBPSCTR); 1267c478bd9Sstevel@tonic-gate ap->ap_tblp = (struct alts_parttbl *)malloc(ap->ap_tbl_secsiz); 1277c478bd9Sstevel@tonic-gate if (ap->ap_tblp == NULL) { 1287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1297c478bd9Sstevel@tonic-gate "Unable to malloc alternate partition table.\n"); 1307c478bd9Sstevel@tonic-gate return (50); 1317c478bd9Sstevel@tonic-gate } 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate /* allocate buffer for the alts partition map (sector size) */ 1347c478bd9Sstevel@tonic-gate /* buffers include the disk image bit map */ 1357c478bd9Sstevel@tonic-gate /* and the incore transformed char map */ 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate if ((ap->ap_memmapp = (uchar_t *)malloc(part->p_size)) == NULL) { 1387c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1397c478bd9Sstevel@tonic-gate "Unable to malloc incore alternate partition map.\n"); 1407c478bd9Sstevel@tonic-gate return (51); 1417c478bd9Sstevel@tonic-gate } 1427c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_map_len = (part->p_size + 8 - 1) / 8; 1437c478bd9Sstevel@tonic-gate ap->ap_map_secsiz = byte_to_secsiz(ap->ap_tblp->alts_map_len, 1447c478bd9Sstevel@tonic-gate NBPSCTR); 1457c478bd9Sstevel@tonic-gate ap->ap_map_sectot = ap->ap_map_secsiz / NBPSCTR; 1467c478bd9Sstevel@tonic-gate if ((ap->ap_mapp = (uchar_t *)malloc(ap->ap_map_secsiz)) == NULL) { 1477c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1487c478bd9Sstevel@tonic-gate "Unable to malloc alternate partition map.\n"); 1497c478bd9Sstevel@tonic-gate return (52); 1507c478bd9Sstevel@tonic-gate } 1517c478bd9Sstevel@tonic-gate /* clear the buffers to zero */ 1527c478bd9Sstevel@tonic-gate (void) memset(ap->ap_memmapp, 0, part->p_size); 1537c478bd9Sstevel@tonic-gate (void) memset(ap->ap_mapp, 0, ap->ap_map_secsiz); 1547c478bd9Sstevel@tonic-gate ap->part = *part; /* struct copy */ 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate /* 1577c478bd9Sstevel@tonic-gate * if add alternate partition flag is set, then install the partition 1587c478bd9Sstevel@tonic-gate * otherwise read the alts partition info from disk 1597c478bd9Sstevel@tonic-gate * if failed, then assume the first installation 1607c478bd9Sstevel@tonic-gate */ 1617c478bd9Sstevel@tonic-gate if (ap->ap_flag & ALTS_ADDPART) 1627c478bd9Sstevel@tonic-gate { 1637c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1647c478bd9Sstevel@tonic-gate "WARNING: Manually initializing alternate table.\n"); 1657c478bd9Sstevel@tonic-gate (void) init_altsctr(); 1667c478bd9Sstevel@tonic-gate } else { 1677c478bd9Sstevel@tonic-gate if (get_altsctr() == SUCCESS) 1687c478bd9Sstevel@tonic-gate (void) chk_badsec(); 1697c478bd9Sstevel@tonic-gate else 1707c478bd9Sstevel@tonic-gate (void) init_altsctr(); 1717c478bd9Sstevel@tonic-gate } 1727c478bd9Sstevel@tonic-gate } 1737c478bd9Sstevel@tonic-gate return (SUCCESS); 1747c478bd9Sstevel@tonic-gate } 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate 1777c478bd9Sstevel@tonic-gate /* 1787c478bd9Sstevel@tonic-gate * checking duplicate bad sectors or bad sectors in ALTSCTR partition 1797c478bd9Sstevel@tonic-gate */ 1807c478bd9Sstevel@tonic-gate static int 1817c478bd9Sstevel@tonic-gate chk_badsec() 1827c478bd9Sstevel@tonic-gate { 1837c478bd9Sstevel@tonic-gate daddr_t badsec; 1847c478bd9Sstevel@tonic-gate daddr_t altsp_srtsec = ap->part.p_start; 1857c478bd9Sstevel@tonic-gate daddr_t altsp_endsec = ap->part.p_start + ap->part.p_size - 1; 1867c478bd9Sstevel@tonic-gate int cnt; 1877c478bd9Sstevel@tonic-gate int status; 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < ap->ap_gbadcnt; cnt++) { 1907c478bd9Sstevel@tonic-gate badsec = (ap->ap_gbadp)[cnt].bad_start; 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate /* if bad sector is within the ATLSCTR partition */ 1937c478bd9Sstevel@tonic-gate if ((badsec >= altsp_srtsec) && (badsec <= altsp_endsec)) { 1947c478bd9Sstevel@tonic-gate if ((ap->ap_memmapp)[badsec - altsp_srtsec] != ALTS_BAD) { 1957c478bd9Sstevel@tonic-gate if ((badsec >= altsp_srtsec) && (badsec <= (altsp_srtsec + 1967c478bd9Sstevel@tonic-gate ap->ap_tbl_secsiz / NBPSCTR - 1))) { 1977c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1987c478bd9Sstevel@tonic-gate "Alternate partition information table is bad.\n"); 1997c478bd9Sstevel@tonic-gate return (53); 2007c478bd9Sstevel@tonic-gate } 2017c478bd9Sstevel@tonic-gate if ((badsec >= altsp_srtsec+ap->ap_tblp->alts_map_base) && 2027c478bd9Sstevel@tonic-gate (badsec <= (altsp_srtsec + ap->ap_tblp->alts_map_base + 2037c478bd9Sstevel@tonic-gate ap->ap_map_sectot - 1))) { 2047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 2057c478bd9Sstevel@tonic-gate "Alternate partition map is bad.\n"); 2067c478bd9Sstevel@tonic-gate return (54); 2077c478bd9Sstevel@tonic-gate } 2087c478bd9Sstevel@tonic-gate if ((badsec >= altsp_srtsec+ap->ap_tblp->alts_ent_base) && 2097c478bd9Sstevel@tonic-gate (badsec <= (altsp_srtsec + ap->ap_tblp->alts_ent_base + 2107c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz / NBPSCTR - 1))) { 2117c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 2127c478bd9Sstevel@tonic-gate "Alternate partition entry table is bad.\n"); 2137c478bd9Sstevel@tonic-gate return (55); 2147c478bd9Sstevel@tonic-gate } 2157c478bd9Sstevel@tonic-gate (ap->ap_memmapp)[badsec - altsp_srtsec] = ALTS_BAD; 2167c478bd9Sstevel@tonic-gate (ap->ap_gbadp)[cnt].bad_start = ALTS_ENT_EMPTY; 2177c478bd9Sstevel@tonic-gate } else { 2187c478bd9Sstevel@tonic-gate status = chk_bad_altsctr(badsec); 2197c478bd9Sstevel@tonic-gate (ap->ap_gbadp)[cnt].bad_start = ALTS_ENT_EMPTY; 2207c478bd9Sstevel@tonic-gate } 2217c478bd9Sstevel@tonic-gate } else { 2227c478bd9Sstevel@tonic-gate /* 2237c478bd9Sstevel@tonic-gate * binary search for bad sector in the alts entry table 2247c478bd9Sstevel@tonic-gate */ 2257c478bd9Sstevel@tonic-gate status = ent_bsearch(ap->ap_entp, ap->ap_tblp->alts_ent_used, 2267c478bd9Sstevel@tonic-gate &((ap->ap_gbadp)[cnt])); 2277c478bd9Sstevel@tonic-gate /* 2287c478bd9Sstevel@tonic-gate * if the bad sector had already been remapped(found in alts_entry) 2297c478bd9Sstevel@tonic-gate * then ignore the bad sector 2307c478bd9Sstevel@tonic-gate */ 2317c478bd9Sstevel@tonic-gate if (status != -1) { 2327c478bd9Sstevel@tonic-gate (ap->ap_gbadp)[cnt].bad_start = ALTS_ENT_EMPTY; 2337c478bd9Sstevel@tonic-gate } 2347c478bd9Sstevel@tonic-gate } 2357c478bd9Sstevel@tonic-gate } 2367c478bd9Sstevel@tonic-gate return (SUCCESS); 2377c478bd9Sstevel@tonic-gate } 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate /* 2407c478bd9Sstevel@tonic-gate * initialize the alternate partition tables 2417c478bd9Sstevel@tonic-gate */ 2427c478bd9Sstevel@tonic-gate static int 2437c478bd9Sstevel@tonic-gate init_altsctr() 2447c478bd9Sstevel@tonic-gate { 2457c478bd9Sstevel@tonic-gate daddr_t badsec; 2467c478bd9Sstevel@tonic-gate daddr_t altsp_srtsec = ap->part.p_start; 2477c478bd9Sstevel@tonic-gate daddr_t altsp_endsec = ap->part.p_start + ap->part.p_size - 1; 2487c478bd9Sstevel@tonic-gate int cnt; 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate ap->ap_entp = NULL; 2517c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz = 0; 2527c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_sanity = ALTS_SANITY; 2537c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_version = ALTS_VERSION1; 2547c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_map_len = (ap->part.p_size + 8 - 1) / 8; 2557c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_ent_used = 0; 2567c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_ent_base = 0; 2577c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_ent_end = 0; 2587c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_resv_base = ap->part.p_size - 1; 2597c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < 5; cnt++) 2607c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_pad[cnt] = 0; 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < ap->ap_gbadcnt; cnt++) { 2637c478bd9Sstevel@tonic-gate badsec = (ap->ap_gbadp)[cnt].bad_start; 2647c478bd9Sstevel@tonic-gate if ((badsec >= altsp_srtsec) && (badsec <= altsp_endsec)) { 2657c478bd9Sstevel@tonic-gate if (badsec == altsp_srtsec) { 2667c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 2677c478bd9Sstevel@tonic-gate "First sector of alternate partition is bad.\n"); 2687c478bd9Sstevel@tonic-gate return (56); 2697c478bd9Sstevel@tonic-gate } 2707c478bd9Sstevel@tonic-gate (ap->ap_memmapp)[badsec - altsp_srtsec] = ALTS_BAD; 2717c478bd9Sstevel@tonic-gate (ap->ap_gbadp)[cnt].bad_start = ALTS_ENT_EMPTY; 2727c478bd9Sstevel@tonic-gate } 2737c478bd9Sstevel@tonic-gate } 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate /* allocate the alts_map on disk skipping possible bad sectors */ 2767c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_map_base = 2777c478bd9Sstevel@tonic-gate altsmap_alloc(ap->ap_tbl_secsiz / NBPSCTR, 2787c478bd9Sstevel@tonic-gate ap->part.p_size, ap->ap_map_sectot, ALTS_MAP_UP); 2797c478bd9Sstevel@tonic-gate if (ap->ap_tblp->alts_map_base == NULL) { 2807c478bd9Sstevel@tonic-gate perror("Unable to allocate alternate map on disk: "); 2817c478bd9Sstevel@tonic-gate return (57); 2827c478bd9Sstevel@tonic-gate } 2837c478bd9Sstevel@tonic-gate (void) wr_altsctr(); 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate return (SUCCESS); 2867c478bd9Sstevel@tonic-gate } 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate 2897c478bd9Sstevel@tonic-gate /* 2907c478bd9Sstevel@tonic-gate * read the alternate partition tables from disk 2917c478bd9Sstevel@tonic-gate */ 2927c478bd9Sstevel@tonic-gate static int 2937c478bd9Sstevel@tonic-gate get_altsctr() 2947c478bd9Sstevel@tonic-gate { 2957c478bd9Sstevel@tonic-gate int mystatus = FAILURE; 2967c478bd9Sstevel@tonic-gate int status = 0; 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate /* get alts partition table info */ 2997c478bd9Sstevel@tonic-gate 3007c478bd9Sstevel@tonic-gate status = ata_rdwr(DIR_READ, cur_file, altsec_offset, 3017c478bd9Sstevel@tonic-gate ap->ap_tbl_secsiz / UBSIZE, (char *)ap->ap_tblp, 3027c478bd9Sstevel@tonic-gate 0, NULL); 3037c478bd9Sstevel@tonic-gate if (status == FAILURE) { 3047c478bd9Sstevel@tonic-gate perror("Unable to read alternate sector partition: "); 3057c478bd9Sstevel@tonic-gate return (58); 3067c478bd9Sstevel@tonic-gate } 3077c478bd9Sstevel@tonic-gate if (ap->ap_tblp->alts_sanity != ALTS_SANITY) 3087c478bd9Sstevel@tonic-gate return (mystatus); 3097c478bd9Sstevel@tonic-gate 3107c478bd9Sstevel@tonic-gate /* get the alts map */ 3117c478bd9Sstevel@tonic-gate status = ata_rdwr(DIR_READ, cur_file, 3127c478bd9Sstevel@tonic-gate (ap->ap_tblp->alts_map_base) + altsec_offset, 3137c478bd9Sstevel@tonic-gate ap->ap_map_secsiz / UBSIZE, (char *)ap->ap_mapp, 0, NULL); 3147c478bd9Sstevel@tonic-gate if (status == FAILURE) { 3157c478bd9Sstevel@tonic-gate perror("Unable to read alternate sector partition map: "); 3167c478bd9Sstevel@tonic-gate return (59); 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate /* transform the disk image bit-map to incore char map */ 3207c478bd9Sstevel@tonic-gate expand_map(); 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate if (ap->ap_tblp->alts_ent_used == 0) { 3237c478bd9Sstevel@tonic-gate ap->ap_entp = NULL; 3247c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz = 0; 3257c478bd9Sstevel@tonic-gate } else { 3267c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz = byte_to_secsiz( 3277c478bd9Sstevel@tonic-gate (ap->ap_tblp->alts_ent_used*ALTS_ENT_SIZE), NBPSCTR); 3287c478bd9Sstevel@tonic-gate if ((ap->ap_entp = 3297c478bd9Sstevel@tonic-gate (struct alts_ent *)malloc(ap->ap_ent_secsiz)) == NULL) { 3307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 3317c478bd9Sstevel@tonic-gate "Unable to malloc alternate sector entry table.\n"); 3327c478bd9Sstevel@tonic-gate return (60); 3337c478bd9Sstevel@tonic-gate } 3347c478bd9Sstevel@tonic-gate 3357c478bd9Sstevel@tonic-gate status = ata_rdwr(DIR_READ, cur_file, 3367c478bd9Sstevel@tonic-gate (ap->ap_tblp->alts_ent_base) + altsec_offset, 3377c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz / UBSIZE, (char *)ap->ap_entp, 3387c478bd9Sstevel@tonic-gate 0, NULL); 3397c478bd9Sstevel@tonic-gate if (status == FAILURE) { 3407c478bd9Sstevel@tonic-gate perror("Unable to read alternate sector entry table: "); 3417c478bd9Sstevel@tonic-gate return (61); 3427c478bd9Sstevel@tonic-gate } 3437c478bd9Sstevel@tonic-gate } 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate return (SUCCESS); 3467c478bd9Sstevel@tonic-gate } 3477c478bd9Sstevel@tonic-gate 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * update the new alternate partition tables on disk 3517c478bd9Sstevel@tonic-gate */ 3527c478bd9Sstevel@tonic-gate int 3537c478bd9Sstevel@tonic-gate wr_altsctr() 3547c478bd9Sstevel@tonic-gate { 3557c478bd9Sstevel@tonic-gate int status; 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate if (ap->ap_tblp == NULL) 3587c478bd9Sstevel@tonic-gate return (0); 3597c478bd9Sstevel@tonic-gate status = ata_rdwr(DIR_WRITE, cur_file, altsec_offset, 3607c478bd9Sstevel@tonic-gate ap->ap_tbl_secsiz / UBSIZE, (char *)ap->ap_tblp, 0, NULL); 3617c478bd9Sstevel@tonic-gate if (status) { 3627c478bd9Sstevel@tonic-gate (void) printf("ata_rdwr status = %d need = %d\n", 3637c478bd9Sstevel@tonic-gate status, ap->ap_tbl_secsiz / 512); 3647c478bd9Sstevel@tonic-gate perror("Unable to write with ata_rdwr the alt sector part: "); 3657c478bd9Sstevel@tonic-gate return (62); 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate if (ata_rdwr(DIR_WRITE, cur_file, (ap->ap_tblp->alts_map_base) + 3697c478bd9Sstevel@tonic-gate altsec_offset, ap->ap_map_secsiz / UBSIZE, 3707c478bd9Sstevel@tonic-gate (char *)ap->ap_mapp, 0, NULL) == FAILURE) { 3717c478bd9Sstevel@tonic-gate perror("Unable to write alternate sector partition map: "); 3727c478bd9Sstevel@tonic-gate return (63); 3737c478bd9Sstevel@tonic-gate } 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate if (ap->ap_tblp->alts_ent_used != 0) { 3767c478bd9Sstevel@tonic-gate if (ata_rdwr(DIR_WRITE, cur_file, 3777c478bd9Sstevel@tonic-gate (ap->ap_tblp->alts_ent_base)+ altsec_offset, 3787c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz / UBSIZE, 3797c478bd9Sstevel@tonic-gate (char *)ap->ap_entp, 0, NULL) == FAILURE) { 3807c478bd9Sstevel@tonic-gate perror("Unable to write alternate sector entry table: "); 3817c478bd9Sstevel@tonic-gate return (64); 3827c478bd9Sstevel@tonic-gate } 3837c478bd9Sstevel@tonic-gate } 3847c478bd9Sstevel@tonic-gate return (0); 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate /* 3897c478bd9Sstevel@tonic-gate * get a list of bad sector 3907c478bd9Sstevel@tonic-gate */ 3917c478bd9Sstevel@tonic-gate static void 3927c478bd9Sstevel@tonic-gate get_badsec() 3937c478bd9Sstevel@tonic-gate { 3947c478bd9Sstevel@tonic-gate int cnt; 3957c478bd9Sstevel@tonic-gate struct badsec_lst *blc_p; 3967c478bd9Sstevel@tonic-gate daddr_t curbad; 3977c478bd9Sstevel@tonic-gate long maxsec = (long)cur_dtype->dtype_nhead * 3987c478bd9Sstevel@tonic-gate cur_dtype->dtype_ncyl * 3997c478bd9Sstevel@tonic-gate cur_dtype->dtype_nsect; 4007c478bd9Sstevel@tonic-gate struct alts_ent *growbadp; 4017c478bd9Sstevel@tonic-gate int i; 4027c478bd9Sstevel@tonic-gate 4037c478bd9Sstevel@tonic-gate cnt = count_badsec(); 4047c478bd9Sstevel@tonic-gate if (!cnt) { 4057c478bd9Sstevel@tonic-gate ap->ap_gbadp = NULL; 4067c478bd9Sstevel@tonic-gate ap->ap_gbadcnt = 0; 4077c478bd9Sstevel@tonic-gate } else { 4087c478bd9Sstevel@tonic-gate ap->ap_gbadp = malloc(cnt*ALTS_ENT_SIZE); 4097c478bd9Sstevel@tonic-gate if (ap->ap_gbadp == NULL) { 4107c478bd9Sstevel@tonic-gate err_print("get_badsec: unable to malloc %d bytes\n", 4117c478bd9Sstevel@tonic-gate cnt*ALTS_ENT_SIZE); 4127c478bd9Sstevel@tonic-gate fullabort(); 4137c478bd9Sstevel@tonic-gate } 4147c478bd9Sstevel@tonic-gate (void) memset(ap->ap_gbadp, 0, cnt*ALTS_ENT_SIZE); 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate for (growbadp = ap->ap_gbadp, cnt = 0, blc_p = badsl_chain; 4177c478bd9Sstevel@tonic-gate blc_p; blc_p = blc_p->bl_nxt) { 4187c478bd9Sstevel@tonic-gate for (i = 0; i < blc_p->bl_cnt; i++) { 4197c478bd9Sstevel@tonic-gate curbad = blc_p->bl_sec[i]; 4207c478bd9Sstevel@tonic-gate if (curbad < (daddr_t)cur_dtype->dtype_nsect) { 4217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4227c478bd9Sstevel@tonic-gate "Ignoring bad sector %ld which is in first track of the drive.\n", curbad); 4237c478bd9Sstevel@tonic-gate continue; 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate if (curbad >= maxsec) { 4267c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4277c478bd9Sstevel@tonic-gate "Ignoring bad sector %ld which is past the end of the drive.\n", curbad); 4287c478bd9Sstevel@tonic-gate continue; 4297c478bd9Sstevel@tonic-gate } 4307c478bd9Sstevel@tonic-gate growbadp[cnt].bad_start = curbad; 4317c478bd9Sstevel@tonic-gate growbadp[cnt].bad_end = curbad; 4327c478bd9Sstevel@tonic-gate cnt++; 4337c478bd9Sstevel@tonic-gate } 4347c478bd9Sstevel@tonic-gate } 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate ap->ap_gbadcnt = cnt; 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate /* 4407c478bd9Sstevel@tonic-gate * count number of bad sector on list 4417c478bd9Sstevel@tonic-gate * merging the bad sector list from surface analysis and the 4427c478bd9Sstevel@tonic-gate * one given through the command line 4437c478bd9Sstevel@tonic-gate */ 4447c478bd9Sstevel@tonic-gate static int 4457c478bd9Sstevel@tonic-gate count_badsec() 4467c478bd9Sstevel@tonic-gate { 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate struct badsec_lst *blc_p; 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate if (!badsl_chain) 4517c478bd9Sstevel@tonic-gate badsl_chain = gbadsl_chain; 4527c478bd9Sstevel@tonic-gate else { 4537c478bd9Sstevel@tonic-gate for (blc_p = badsl_chain; blc_p->bl_nxt; blc_p = blc_p->bl_nxt) 4547c478bd9Sstevel@tonic-gate ; 4557c478bd9Sstevel@tonic-gate blc_p->bl_nxt = gbadsl_chain; 4567c478bd9Sstevel@tonic-gate } 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate badsl_chain_cnt += gbadsl_chain_cnt; 4597c478bd9Sstevel@tonic-gate return (badsl_chain_cnt); 4607c478bd9Sstevel@tonic-gate } 4617c478bd9Sstevel@tonic-gate 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate /* 4647c478bd9Sstevel@tonic-gate * generate alternate entry table by merging the existing and 4657c478bd9Sstevel@tonic-gate * the new entry list. 4667c478bd9Sstevel@tonic-gate */ 4677c478bd9Sstevel@tonic-gate static int 4687c478bd9Sstevel@tonic-gate gen_alts_ent() { 4697c478bd9Sstevel@tonic-gate int ent_used; 4707c478bd9Sstevel@tonic-gate struct alts_ent *entp; 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate if (ap->ap_gbadcnt == 0) 4737c478bd9Sstevel@tonic-gate return (0); 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate ent_used = ap->ap_tblp->alts_ent_used + ap->ap_gbadcnt; 4767c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz = byte_to_secsiz(ent_used*ALTS_ENT_SIZE, NBPSCTR); 4777c478bd9Sstevel@tonic-gate entp = malloc(ap->ap_ent_secsiz); 4787c478bd9Sstevel@tonic-gate if (entp == NULL) { 4797c478bd9Sstevel@tonic-gate err_print("get_alts_ent: unable to malloc %d bytes\n", 4807c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz); 4817c478bd9Sstevel@tonic-gate fullabort(); 4827c478bd9Sstevel@tonic-gate } 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate ent_used = ent_merge(entp, ap->ap_entp, ap->ap_tblp->alts_ent_used, 4857c478bd9Sstevel@tonic-gate ap->ap_gbadp, ap->ap_gbadcnt); 4867c478bd9Sstevel@tonic-gate if (ap->ap_entp) 4877c478bd9Sstevel@tonic-gate free(ap->ap_entp); 4887c478bd9Sstevel@tonic-gate if (ap->ap_gbadp) 4897c478bd9Sstevel@tonic-gate free(ap->ap_gbadp); 4907c478bd9Sstevel@tonic-gate ap->ap_entp = entp; 4917c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz = byte_to_secsiz(ent_used*ALTS_ENT_SIZE, NBPSCTR); 4927c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_ent_used = ent_used; 4937c478bd9Sstevel@tonic-gate ap->ap_gbadp = NULL; 4947c478bd9Sstevel@tonic-gate ap->ap_gbadcnt = 0; 4957c478bd9Sstevel@tonic-gate 4967c478bd9Sstevel@tonic-gate /* assign alternate sectors to the bad sectors */ 4977c478bd9Sstevel@tonic-gate (void) assign_altsctr(); 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate /* allocate the alts_entry on disk skipping possible bad sectors */ 5007c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_ent_base = 5017c478bd9Sstevel@tonic-gate altsmap_alloc(ap->ap_tblp->alts_map_base + ap->ap_map_sectot, 5027c478bd9Sstevel@tonic-gate ap->part.p_size, 5037c478bd9Sstevel@tonic-gate ap->ap_ent_secsiz / NBPSCTR, ALTS_MAP_UP); 5047c478bd9Sstevel@tonic-gate if (ap->ap_tblp->alts_ent_base == NULL) { 5057c478bd9Sstevel@tonic-gate perror("Unable to allocate alternate entry table on disk: "); 5067c478bd9Sstevel@tonic-gate return (65); 5077c478bd9Sstevel@tonic-gate } 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate ap->ap_tblp->alts_ent_end = ap->ap_tblp->alts_ent_base + 5107c478bd9Sstevel@tonic-gate (ap->ap_ent_secsiz / NBPSCTR) - 1; 5117c478bd9Sstevel@tonic-gate return (0); 5127c478bd9Sstevel@tonic-gate } 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate /* 5167c478bd9Sstevel@tonic-gate * assign alternate sectors for bad sector mapping 5177c478bd9Sstevel@tonic-gate */ 5187c478bd9Sstevel@tonic-gate static int 5197c478bd9Sstevel@tonic-gate assign_altsctr() 5207c478bd9Sstevel@tonic-gate { 5217c478bd9Sstevel@tonic-gate int i; 5227c478bd9Sstevel@tonic-gate int j; 5237c478bd9Sstevel@tonic-gate daddr_t alts_ind; 5247c478bd9Sstevel@tonic-gate int cluster; 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate for (i = 0; i < ap->ap_tblp->alts_ent_used; i++) { 5277c478bd9Sstevel@tonic-gate if ((ap->ap_entp)[i].bad_start == ALTS_ENT_EMPTY) 5287c478bd9Sstevel@tonic-gate continue; 5297c478bd9Sstevel@tonic-gate if ((ap->ap_entp)[i].good_start != 0) 5307c478bd9Sstevel@tonic-gate continue; 5317c478bd9Sstevel@tonic-gate cluster = (ap->ap_entp)[i].bad_end-(ap->ap_entp)[i].bad_start +1; 5327c478bd9Sstevel@tonic-gate alts_ind = 5337c478bd9Sstevel@tonic-gate altsmap_alloc(ap->part.p_size-1, ap->ap_tblp->alts_map_base + 5347c478bd9Sstevel@tonic-gate ap->ap_map_sectot - 1, cluster, ALTS_MAP_DOWN); 5357c478bd9Sstevel@tonic-gate if (alts_ind == NULL) { 5367c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 537*3ccda647Slclee "Unable to allocate alternates for bad starting sector %u.\n", 5387c478bd9Sstevel@tonic-gate (ap->ap_entp)[i].bad_start); 5397c478bd9Sstevel@tonic-gate return (65); 5407c478bd9Sstevel@tonic-gate } 5417c478bd9Sstevel@tonic-gate alts_ind = alts_ind - cluster + 1; 5427c478bd9Sstevel@tonic-gate (ap->ap_entp)[i].good_start = alts_ind +ap->part.p_start; 5437c478bd9Sstevel@tonic-gate for (j = 0; j < cluster; j++) { 5447c478bd9Sstevel@tonic-gate (ap->ap_memmapp)[alts_ind+j] = ALTS_BAD; 5457c478bd9Sstevel@tonic-gate } 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate } 5487c478bd9Sstevel@tonic-gate return (SUCCESS); 5497c478bd9Sstevel@tonic-gate } 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate /* 5527c478bd9Sstevel@tonic-gate * transform the disk image alts bit map to incore char map 5537c478bd9Sstevel@tonic-gate */ 5547c478bd9Sstevel@tonic-gate static void 5557c478bd9Sstevel@tonic-gate expand_map() 5567c478bd9Sstevel@tonic-gate { 5577c478bd9Sstevel@tonic-gate int i; 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate for (i = 0; i < ap->part.p_size; i++) { 5607c478bd9Sstevel@tonic-gate (ap->ap_memmapp)[i] = altsmap_getbit(i); 5617c478bd9Sstevel@tonic-gate } 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate /* 5657c478bd9Sstevel@tonic-gate * transform the incore alts char map to the disk image bit map 5667c478bd9Sstevel@tonic-gate */ 5677c478bd9Sstevel@tonic-gate static void 5687c478bd9Sstevel@tonic-gate compress_map() 5697c478bd9Sstevel@tonic-gate { 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate int i; 5727c478bd9Sstevel@tonic-gate int bytesz; 5737c478bd9Sstevel@tonic-gate char mask = 0; 5747c478bd9Sstevel@tonic-gate int maplen = 0; 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate for (i = 0, bytesz = 7; i < ap->part.p_size; i++) { 5777c478bd9Sstevel@tonic-gate mask |= ((ap->ap_memmapp)[i] << bytesz--); 5787c478bd9Sstevel@tonic-gate if (bytesz < 0) { 5797c478bd9Sstevel@tonic-gate (ap->ap_mapp)[maplen++] = mask; 5807c478bd9Sstevel@tonic-gate bytesz = 7; 5817c478bd9Sstevel@tonic-gate mask = 0; 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate /* 5857c478bd9Sstevel@tonic-gate * if partition size != multiple number of bytes 5867c478bd9Sstevel@tonic-gate * then record the last partial byte 5877c478bd9Sstevel@tonic-gate */ 5887c478bd9Sstevel@tonic-gate if (bytesz != 7) 5897c478bd9Sstevel@tonic-gate (ap->ap_mapp)[maplen] = mask; 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate } 5927c478bd9Sstevel@tonic-gate 5937c478bd9Sstevel@tonic-gate /* 5947c478bd9Sstevel@tonic-gate * given a bad sector number, search in the alts bit map 5957c478bd9Sstevel@tonic-gate * and identify the sector as good or bad 5967c478bd9Sstevel@tonic-gate */ 5977c478bd9Sstevel@tonic-gate static int 5987c478bd9Sstevel@tonic-gate altsmap_getbit(badsec) 5997c478bd9Sstevel@tonic-gate daddr_t badsec; 6007c478bd9Sstevel@tonic-gate { 6017c478bd9Sstevel@tonic-gate int slot = badsec / 8; 6027c478bd9Sstevel@tonic-gate int field = badsec % 8; 6037c478bd9Sstevel@tonic-gate uchar_t mask; 6047c478bd9Sstevel@tonic-gate 6057c478bd9Sstevel@tonic-gate mask = ALTS_BAD<<7; 6067c478bd9Sstevel@tonic-gate mask >>= field; 6077c478bd9Sstevel@tonic-gate if ((ap->ap_mapp)[slot] & mask) 6087c478bd9Sstevel@tonic-gate return (ALTS_BAD); 6097c478bd9Sstevel@tonic-gate return (ALTS_GOOD); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate /* 6147c478bd9Sstevel@tonic-gate * allocate a range of sectors from the alternate partition 6157c478bd9Sstevel@tonic-gate */ 6167c478bd9Sstevel@tonic-gate static int 6177c478bd9Sstevel@tonic-gate altsmap_alloc(srt_ind, end_ind, cnt, dir) 6187c478bd9Sstevel@tonic-gate daddr_t srt_ind; 6197c478bd9Sstevel@tonic-gate daddr_t end_ind; 6207c478bd9Sstevel@tonic-gate int cnt; 6217c478bd9Sstevel@tonic-gate int dir; 6227c478bd9Sstevel@tonic-gate { 6237c478bd9Sstevel@tonic-gate int i; 6247c478bd9Sstevel@tonic-gate int total; 6257c478bd9Sstevel@tonic-gate int first_ind; 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate for (i = srt_ind, first_ind = srt_ind, total = 0; 6287c478bd9Sstevel@tonic-gate i != end_ind; i += dir) { 6297c478bd9Sstevel@tonic-gate if ((ap->ap_memmapp)[i] == ALTS_BAD) { 6307c478bd9Sstevel@tonic-gate total = 0; 6317c478bd9Sstevel@tonic-gate first_ind = i + dir; 6327c478bd9Sstevel@tonic-gate continue; 6337c478bd9Sstevel@tonic-gate } 6347c478bd9Sstevel@tonic-gate total++; 6357c478bd9Sstevel@tonic-gate if (total == cnt) 6367c478bd9Sstevel@tonic-gate return (first_ind); 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate } 6397c478bd9Sstevel@tonic-gate return (NULL); 6407c478bd9Sstevel@tonic-gate } 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate /* 6457c478bd9Sstevel@tonic-gate * bubble sort the entry table into ascending order 6467c478bd9Sstevel@tonic-gate */ 6477c478bd9Sstevel@tonic-gate static void 6487c478bd9Sstevel@tonic-gate ent_sort(buf, cnt) 6497c478bd9Sstevel@tonic-gate struct alts_ent buf[]; 6507c478bd9Sstevel@tonic-gate int cnt; 6517c478bd9Sstevel@tonic-gate { 6527c478bd9Sstevel@tonic-gate struct alts_ent temp; 6537c478bd9Sstevel@tonic-gate int flag; 6547c478bd9Sstevel@tonic-gate int i, j; 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate for (i = 0; i < cnt-1; i++) { 6577c478bd9Sstevel@tonic-gate temp = buf[cnt-1]; 6587c478bd9Sstevel@tonic-gate flag = 1; 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate for (j = cnt-1; j > i; j--) { 6617c478bd9Sstevel@tonic-gate if (buf[j-1].bad_start < temp.bad_start) { 6627c478bd9Sstevel@tonic-gate buf[j] = temp; 6637c478bd9Sstevel@tonic-gate temp = buf[j-1]; 6647c478bd9Sstevel@tonic-gate } else { 6657c478bd9Sstevel@tonic-gate buf[j] = buf[j-1]; 6667c478bd9Sstevel@tonic-gate flag = 0; 6677c478bd9Sstevel@tonic-gate } 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate buf[i] = temp; 6707c478bd9Sstevel@tonic-gate if (flag) break; 6717c478bd9Sstevel@tonic-gate } 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate } 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate /* 6777c478bd9Sstevel@tonic-gate * compress all the contiguous bad sectors into a single entry 6787c478bd9Sstevel@tonic-gate * in the entry table. The entry table must be sorted into ascending 6797c478bd9Sstevel@tonic-gate * before the compression. 6807c478bd9Sstevel@tonic-gate */ 6817c478bd9Sstevel@tonic-gate static void 6827c478bd9Sstevel@tonic-gate ent_compress(buf, cnt) 6837c478bd9Sstevel@tonic-gate struct alts_ent buf[]; 6847c478bd9Sstevel@tonic-gate int cnt; 6857c478bd9Sstevel@tonic-gate { 6867c478bd9Sstevel@tonic-gate int keyp; 6877c478bd9Sstevel@tonic-gate int movp; 6887c478bd9Sstevel@tonic-gate int i; 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate for (i = 0; i < cnt; i++) { 6917c478bd9Sstevel@tonic-gate if (buf[i].bad_start == ALTS_ENT_EMPTY) 6927c478bd9Sstevel@tonic-gate continue; 6937c478bd9Sstevel@tonic-gate for (keyp = i, movp = i+1; movp < cnt; movp++) { 6947c478bd9Sstevel@tonic-gate if (buf[movp].bad_start == ALTS_ENT_EMPTY) 6957c478bd9Sstevel@tonic-gate continue; 6967c478bd9Sstevel@tonic-gate if (buf[keyp].bad_end+1 != buf[movp].bad_start) 6977c478bd9Sstevel@tonic-gate break; 6987c478bd9Sstevel@tonic-gate buf[keyp].bad_end++; 6997c478bd9Sstevel@tonic-gate buf[movp].bad_start = ALTS_ENT_EMPTY; 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate if (movp == cnt) break; 7027c478bd9Sstevel@tonic-gate } 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate /* 7077c478bd9Sstevel@tonic-gate * merging two entry tables into a single table. In addition, 7087c478bd9Sstevel@tonic-gate * all empty slots in the entry table will be removed. 7097c478bd9Sstevel@tonic-gate */ 7107c478bd9Sstevel@tonic-gate static int 7117c478bd9Sstevel@tonic-gate ent_merge(buf, list1, lcnt1, list2, lcnt2) 7127c478bd9Sstevel@tonic-gate struct alts_ent buf[]; 7137c478bd9Sstevel@tonic-gate struct alts_ent list1[]; 7147c478bd9Sstevel@tonic-gate int lcnt1; 7157c478bd9Sstevel@tonic-gate struct alts_ent list2[]; 7167c478bd9Sstevel@tonic-gate int lcnt2; 7177c478bd9Sstevel@tonic-gate { 7187c478bd9Sstevel@tonic-gate int i; 7197c478bd9Sstevel@tonic-gate int j1, j2; 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate for (i = 0, j1 = 0, j2 = 0; j1 < lcnt1 && j2 < lcnt2; ) { 7227c478bd9Sstevel@tonic-gate if (list1[j1].bad_start == ALTS_ENT_EMPTY) { 7237c478bd9Sstevel@tonic-gate j1++; 7247c478bd9Sstevel@tonic-gate continue; 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate if (list2[j2].bad_start == ALTS_ENT_EMPTY) { 7277c478bd9Sstevel@tonic-gate j2++; 7287c478bd9Sstevel@tonic-gate continue; 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate if (list1[j1].bad_start < list2[j2].bad_start) 7317c478bd9Sstevel@tonic-gate buf[i++] = list1[j1++]; 7327c478bd9Sstevel@tonic-gate else 7337c478bd9Sstevel@tonic-gate buf[i++] = list2[j2++]; 7347c478bd9Sstevel@tonic-gate } 7357c478bd9Sstevel@tonic-gate for (; j1 < lcnt1; j1++) { 7367c478bd9Sstevel@tonic-gate if (list1[j1].bad_start == ALTS_ENT_EMPTY) 7377c478bd9Sstevel@tonic-gate continue; 7387c478bd9Sstevel@tonic-gate buf[i++] = list1[j1]; 7397c478bd9Sstevel@tonic-gate } 7407c478bd9Sstevel@tonic-gate for (; j2 < lcnt2; j2++) { 7417c478bd9Sstevel@tonic-gate if (list2[j2].bad_start == ALTS_ENT_EMPTY) 7427c478bd9Sstevel@tonic-gate continue; 7437c478bd9Sstevel@tonic-gate buf[i++] = list2[j2]; 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate return (i); 7467c478bd9Sstevel@tonic-gate } 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate /* 7507c478bd9Sstevel@tonic-gate * binary search for bad sector in the alternate entry table 7517c478bd9Sstevel@tonic-gate */ 7527c478bd9Sstevel@tonic-gate static int 7537c478bd9Sstevel@tonic-gate ent_bsearch(buf, cnt, key) 7547c478bd9Sstevel@tonic-gate struct alts_ent buf[]; 7557c478bd9Sstevel@tonic-gate int cnt; 7567c478bd9Sstevel@tonic-gate struct alts_ent *key; 7577c478bd9Sstevel@tonic-gate { 7587c478bd9Sstevel@tonic-gate int i; 7597c478bd9Sstevel@tonic-gate int ind; 7607c478bd9Sstevel@tonic-gate int interval; 7617c478bd9Sstevel@tonic-gate int mystatus = -1; 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate if (!cnt) 7647c478bd9Sstevel@tonic-gate return (mystatus); 7657c478bd9Sstevel@tonic-gate 7667c478bd9Sstevel@tonic-gate for (i = 1; i <= cnt; i <<= 1) 7677c478bd9Sstevel@tonic-gate ind = i; 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate for (interval = ind; interval; ) { 7707c478bd9Sstevel@tonic-gate if ((key->bad_start >= buf[ind-1].bad_start) && 7717c478bd9Sstevel@tonic-gate (key->bad_start <= buf[ind-1].bad_end)) { 7727c478bd9Sstevel@tonic-gate return (mystatus = ind-1); 7737c478bd9Sstevel@tonic-gate } else { 7747c478bd9Sstevel@tonic-gate interval >>= 1; 7757c478bd9Sstevel@tonic-gate if (!interval) break; 7767c478bd9Sstevel@tonic-gate if (key->bad_start < buf[ind-1].bad_start) { 7777c478bd9Sstevel@tonic-gate ind = ind - interval; 7787c478bd9Sstevel@tonic-gate } else { 7797c478bd9Sstevel@tonic-gate /* if key is larger than the last element then break */ 7807c478bd9Sstevel@tonic-gate if (ind == cnt) break; 7817c478bd9Sstevel@tonic-gate if ((ind+interval) <= cnt) 7827c478bd9Sstevel@tonic-gate ind += interval; 7837c478bd9Sstevel@tonic-gate } 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate } 7867c478bd9Sstevel@tonic-gate return (mystatus); 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate 7897c478bd9Sstevel@tonic-gate /* 7907c478bd9Sstevel@tonic-gate * check for bad sector in assigned alternate sectors 7917c478bd9Sstevel@tonic-gate */ 7927c478bd9Sstevel@tonic-gate static int 7937c478bd9Sstevel@tonic-gate chk_bad_altsctr(badsec) 7947c478bd9Sstevel@tonic-gate daddr_t badsec; 7957c478bd9Sstevel@tonic-gate { 7967c478bd9Sstevel@tonic-gate int i; 7977c478bd9Sstevel@tonic-gate daddr_t numsec; 7987c478bd9Sstevel@tonic-gate int cnt = ap->ap_tblp->alts_ent_used; 7997c478bd9Sstevel@tonic-gate /* 8007c478bd9Sstevel@tonic-gate * daddr_t intv[3]; 8017c478bd9Sstevel@tonic-gate */ 8027c478bd9Sstevel@tonic-gate 8037c478bd9Sstevel@tonic-gate for (i = 0; i < cnt; i++) { 8047c478bd9Sstevel@tonic-gate numsec = (ap->ap_entp)[i].bad_end - (ap->ap_entp)[i].bad_start; 8057c478bd9Sstevel@tonic-gate if ((badsec >= (ap->ap_entp)[i].good_start) && 8067c478bd9Sstevel@tonic-gate (badsec <= ((ap->ap_entp)[i].good_start + numsec))) { 8077c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 8087c478bd9Sstevel@tonic-gate "Bad sector %ld is an assigned alternate sector.\n", badsec); 8097c478bd9Sstevel@tonic-gate return (66); 8107c478bd9Sstevel@tonic-gate /* 8117c478bd9Sstevel@tonic-gate * if (!numsec) { 8127c478bd9Sstevel@tonic-gate * (ap->ap_entp)[i].good_start = 0; 8137c478bd9Sstevel@tonic-gate * return (FAILURE); 8147c478bd9Sstevel@tonic-gate * } 8157c478bd9Sstevel@tonic-gate * intv[0] = badsec - (ap->ap_entp)[i].good_start; 8167c478bd9Sstevel@tonic-gate * intv[1] = 1; 8177c478bd9Sstevel@tonic-gate * intv[2] = (ap->ap_entp)[i].good_start + numsec - badsec; 8187c478bd9Sstevel@tonic-gate */ 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate } 8217c478bd9Sstevel@tonic-gate /* the bad sector has already been identified as bad */ 8227c478bd9Sstevel@tonic-gate return (SUCCESS); 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate } 825