Home | History | Annotate | Line # | Download | only in aptck 
      1 /*	$NetBSD: disklbl.c,v 1.6 2009/03/14 21:04:07 dsl Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1995 Waldi Ravens.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *        This product includes software developed by Waldi Ravens.
     18  * 4. The name of the author may not be used to endorse or promote products
     19  *    derived from this software without specific prior written permission.
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 #include <sys/types.h>
     34 #include <stdlib.h>
     35 #include <stdio.h>
     36 #include "libtos.h"
     37 #include "aptck.h"
     38 #include "ahdilbl.h"
     39 #include "disklbl.h"
     40 
     41 static int	dkcksum    PROTO((struct disklabel *));
     42 static int	bsd_label  PROTO((disk_t *, u_int));
     43 static int	ahdi_label PROTO((disk_t *));
     44 static int	ahdi_display PROTO((disk_t *));
     45 static u_int	ahdi_getparts PROTO((disk_t *, u_int, u_int));
     46 
     47 int
     48 readdisklabel(disk_t *dd)
     49 {
     50 	int	e;
     51 
     52 	printf("Device     : %s (%s) [%s]\n", dd->sname, dd->fname,
     53 							 dd->product);
     54 	printf("Medium size: %lu sectors\n", (u_long)dd->msize);
     55 	printf("Sector size: %lu bytes\n\n", (u_long)dd->bsize);
     56 
     57 	e = bsd_label(dd, LABELSECTOR);
     58 	if (e < 0) {
     59 		printf("Device I/O error (hardware problem?)\n\n");
     60 		return(-1);
     61 	}
     62 	if (!e) {
     63 		printf("NetBSD/Atari format, boot block: "
     64 		       "sector %u labeloffset %u\n\n",
     65 		       dd->bblock, dd->lblofs);
     66 		return(0);
     67 	}
     68 
     69 	e = ahdi_label(dd);
     70 	if (e < 0) {
     71 		printf("Device I/O error (hardware problem?)\n\n");
     72 		return(-1);
     73 	}
     74 	if (!e) {
     75 		printf("AHDI format, NetBSD boot block: ");
     76 		if (dd->bblock != NO_BOOT_BLOCK)
     77 			printf("sector %u labeloffset %u\n\n",
     78 			       dd->bblock, dd->lblofs);
     79 		else printf("none\n\n");
     80 		return(0);
     81 	}
     82 
     83 	printf("Unknown label format.\n\n");
     84 	return(-1);
     85 }
     86 
     87 static int
     88 bsd_label(disk_t *dd, u_int offset)
     89 {
     90 	u_char		*bblk;
     91 	u_int		nsec;
     92 	int		rv;
     93 
     94 	nsec = (BBMINSIZE + (dd->bsize - 1)) / dd->bsize;
     95 	bblk = disk_read(dd, offset, nsec);
     96 	if (bblk) {
     97 		u_int	*end, *p;
     98 
     99 		end = (u_int *)&bblk[BBMINSIZE - sizeof(struct disklabel)];
    100 		rv  = 1;
    101 		for (p = (u_int *)bblk; p < end; ++p) {
    102 			struct disklabel *dl = (struct disklabel *)&p[1];
    103 			if (  (  (p[0] == NBDAMAGIC && offset == 0)
    104 			      || (p[0] == AHDIMAGIC && offset != 0)
    105 			      || (u_char *)dl - bblk == 7168
    106 			      )
    107 			   && dl->d_npartitions <= MAXPARTITIONS
    108 			   && dl->d_magic2 == DISKMAGIC
    109 			   && dl->d_magic  == DISKMAGIC
    110 			   && dkcksum(dl)  == 0
    111 			   )	{
    112 		    		dd->lblofs = (u_char *)dl - bblk;
    113 		    		dd->bblock = offset;
    114 				rv = 0;
    115 				break;
    116 			}
    117 		}
    118 		free(bblk);
    119 	}
    120 	else rv = -1;
    121 
    122 	return(rv);
    123 }
    124 
    125 static int
    126 dkcksum(struct disklabel *dl)
    127 {
    128 	u_short	*start, *end, sum = 0;
    129 
    130 	start = (u_short *)dl;
    131 	end   = (u_short *)&dl->d_partitions[dl->d_npartitions];
    132 	while (start < end)
    133 		sum ^= *start++;
    134 	return(sum);
    135 }
    136 
    137 int
    138 ahdi_label(disk_t *dd)
    139 {
    140 	u_int	i;
    141 	int	e;
    142 
    143 	/*
    144 	 * The AHDI format requires a specific block size.
    145 	 */
    146 	if (dd->bsize != AHDI_BSIZE)
    147 		return(1);
    148 
    149 	/*
    150 	 * Fetch the AHDI partition descriptors.
    151 	 */
    152 	i = ahdi_getparts(dd, AHDI_BBLOCK, AHDI_BBLOCK);
    153 	if (i) {
    154 		if (i < dd->msize)
    155 			return(-1);	/* disk read error		*/
    156 		else return(1);		/* reading past end of medium	*/
    157 	}
    158 
    159 	/*
    160 	 * Display and perform sanity checks.
    161 	 */
    162 	i = ahdi_display(dd);
    163 	if (i)
    164 		return(i);
    165 
    166 	/*
    167 	 * Search for a NetBSD disk label
    168 	 */
    169 	dd->bblock = NO_BOOT_BLOCK;
    170 	for (i = 0; i < dd->nparts; ++i) {
    171 		part_t	*pd = &dd->parts[i];
    172 		u_int	id  = *((u_int32_t *)&pd->id) >> 8;
    173 		if (id == AHDI_PID_NBD || id == AHDI_PID_RAW) {
    174 			u_int	offs = pd->start;
    175 			if ((e = bsd_label(dd, offs)) < 0) {
    176 				return(e);		/* I/O error */
    177 			}
    178 			if (!e) {
    179 				dd->bblock = offs;	/* got it */
    180 				return(0);
    181 			}
    182 			if (id == AHDI_PID_NBD && dd->bblock == NO_BOOT_BLOCK)
    183 				dd->bblock = offs;
    184 		}
    185 	}
    186 	return(0);
    187 }
    188 
    189 static int
    190 root_cmp(const void *x1, const void *x2)
    191 {
    192 	const u_int	*r1 = x1,
    193 			*r2 = x2;
    194 
    195 	if (*r1 < *r2)
    196 		return(-1);
    197 	if (*r1 > *r2)
    198 		return(1);
    199 	return(0);
    200 }
    201 
    202 static int
    203 part_cmp(const void *x1, const void *x2)
    204 {
    205 	const part_t	*p1 = x1,
    206 			*p2 = x2;
    207 
    208 	if (p1->start < p2->start)
    209 		return(-1);
    210 	if (p1->start > p2->start)
    211 		return(1);
    212 	if (p1->end < p2->end)
    213 		return(-1);
    214 	if (p1->end > p2->end)
    215 		return(1);
    216 	if (p1->rsec < p2->rsec)
    217 		return(-1);
    218 	if (p1->rsec > p2->rsec)
    219 		return(1);
    220 	if (p1->rent < p2->rent)
    221 		return(-1);
    222 	if (p1->rent > p2->rent)
    223 		return(1);
    224 	return(0);
    225 }
    226 
    227 static int
    228 ahdi_display(disk_t *dd)
    229 {
    230 	int	i, j, rv = 0;
    231 
    232 	printf("Start of bad sector list : %u\n", dd->bslst);
    233 	if (dd->bslst == 0) {
    234 		printf("* Illegal value (zero) *\n"); rv = 1;
    235 	}
    236 	printf("End of bad sector list   : %u\n", dd->bslend);
    237 	if (dd->bslend == 0) {
    238 		printf("* Illegal value (zero) *\n"); rv = 1;
    239 	}
    240 	printf("Medium size (in root sec): %u\n", dd->hdsize);
    241 	if (dd->hdsize == 0) {
    242 		printf("* Illegal value (zero) *\n"); rv = 1;
    243 	}
    244 
    245 	qsort(dd->roots, dd->nroots, sizeof *dd->roots, root_cmp);
    246 	qsort(dd->parts, dd->nparts, sizeof *dd->parts, part_cmp);
    247 	printf("\n    root  desc   id     start       end    MBs\n");
    248 
    249 	for (i = 0; i < dd->nparts; ++i) {
    250 		part_t	*p1 = &dd->parts[i];
    251 		u_int	megs = p1->end - p1->start + 1,
    252 			blpm = (1024 * 1024) / dd->bsize;
    253 		megs = (megs + (blpm >> 1)) / blpm;
    254 		printf("%8u  %4u  %s  %8u  %8u  (%3u)\n",
    255 			p1->rsec, p1->rent, p1->id,
    256 			p1->start, p1->end, megs);
    257 		for (j = 0; j < dd->nroots; ++j) {
    258 			u_int	aux = dd->roots[j];
    259 			if (aux >= p1->start && aux <= p1->end) {
    260 				printf("FATAL: auxiliary root at %u\n", aux);
    261 				rv = 1;
    262 			}
    263 		}
    264 		for (j = i; j--;) {
    265 		    part_t	*p2 = &dd->parts[j];
    266 		    if (p1->start >= p2->start && p1->start <= p2->end) {
    267 			printf("FATAL: clash with %u/%u\n", p2->rsec, p2->rent);
    268 			rv = 1;
    269 		    }
    270 		    if (p2->start >= p1->start && p2->start <= p1->end) {
    271 			printf("FATAL: clash with %u/%u\n", p2->rsec, p2->rent);
    272 			rv = 1;
    273 		    }
    274 		}
    275 		if (p1->start >= dd->bslst && p1->start <= dd->bslend) {
    276 		    printf("FATAL: partition overlaps with bad sector list\n");
    277 		    rv = 1;
    278 		}
    279 		if (dd->bslst >= p1->start && dd->bslst <= p1->end) {
    280 		    printf("FATAL: partition overlaps with bad sector list\n");
    281 		    rv = 1;
    282 		}
    283 	}
    284 
    285 	printf("\nTotal number of auxiliary roots: %u\n", dd->nroots);
    286 	printf("Total number of partitions    : %u\n", dd->nparts);
    287 	if (dd->nparts == 0) {
    288 		printf("* Weird # of partitions (zero) *\n"); rv = 1;
    289 	}
    290 	if (dd->nparts > AHDI_MAXPARTS) {
    291 		printf("* Too many AHDI partitions for the default NetBSD "
    292 			"kernel *\n  Increase MAXAUXROOTS in src/sys/arch/"
    293 			"atari/include/disklabel.h\n  to at least %u, and "
    294 			"recompile the NetBSD kernel.\n", dd->nroots);
    295 		rv = -1;
    296 	}
    297 	return(rv);
    298 }
    299 
    300 static u_int
    301 ahdi_getparts(dd, rsec, esec)
    302 	disk_t			*dd;
    303 	u_int			rsec,
    304 				esec;
    305 {
    306 	struct ahdi_part	*part, *end;
    307 	struct ahdi_root	*root;
    308 	u_int			rv;
    309 
    310 	root = disk_read(dd, rsec, 1);
    311 	if (!root) {
    312 		rv = rsec + (rsec == 0);
    313 		goto done;
    314 	}
    315 
    316 	if (rsec == AHDI_BBLOCK)
    317 		end = &root->ar_parts[AHDI_MAXRPD];
    318 	else end = &root->ar_parts[AHDI_MAXARPD];
    319 	for (part = root->ar_parts; part < end; ++part) {
    320 		u_int	id = *((u_int32_t *)&part->ap_flg);
    321 		if (!(id & 0x01000000))
    322 			continue;
    323 		if ((id &= 0x00ffffff) == AHDI_PID_XGM) {
    324 			u_int	offs = part->ap_offs + esec;
    325 			u_int	i = ++dd->nroots;
    326 			dd->roots = xrealloc(dd->roots, i * sizeof *dd->roots);
    327 			dd->roots[--i] = offs;
    328 			rv = ahdi_getparts(dd, offs,
    329 					esec == AHDI_BBLOCK ? offs : esec);
    330 			if (rv)
    331 				goto done;
    332 		} else {
    333 			part_t	*p;
    334 			u_int	i = ++dd->nparts;
    335 			dd->parts = xrealloc(dd->parts, i * sizeof *dd->parts);
    336 			p = &dd->parts[--i];
    337 			*((u_int32_t *)&p->id) = id << 8;
    338 			p->start = part->ap_offs + rsec;
    339 			p->end   = p->start + part->ap_size - 1;
    340 			p->rsec  = rsec;
    341 			p->rent  = part - root->ar_parts;
    342 		}
    343 	}
    344 	dd->hdsize = root->ar_hdsize;
    345 	dd->bslst  = root->ar_bslst;
    346 	dd->bslend = root->ar_bslst + root->ar_bslsize - 1;
    347 	rv = 0;
    348 done:
    349 	free(root);
    350 	return(rv);
    351 }
    352