disklabel.c revision 1.6
1 /* $NetBSD: disklabel.c,v 1.6 2011/10/01 15:59:00 chs 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 <sys/param.h> 35 #include <ufs/ufs/dinode.h> 36 #include <ufs/ffs/fs.h> 37 #include <sys/disklabel.h> 38 #include <machine/ahdilabel.h> 39 #include <unistd.h> 40 #include <string.h> 41 #include <stdlib.h> 42 #include <fcntl.h> 43 #include <err.h> 44 45 #if (BBSIZE < MINBBSIZE) 46 #error BBSIZE is smaller than MINBBSIZE 47 #endif 48 49 struct ahdilabel { 50 u_int nsecs; 51 daddr_t bslst; 52 daddr_t bslend; 53 u_int nroots; 54 daddr_t *roots; 55 u_int nparts; 56 struct ahdi_part *parts; 57 }; 58 59 u_int dkcksum(struct disklabel *); 60 u_int32_t readdisklabel(char *, struct disklabel *); 61 62 static int bsd_label(int, off_t, struct disklabel *); 63 static int ahdi_label(int, u_int32_t *, struct disklabel *); 64 static int ahdi_getparts(int, daddr_t, daddr_t, struct ahdilabel *); 65 66 u_int 67 dkcksum (struct disklabel *dl) 68 { 69 u_int16_t sum = 0, 70 *st = (u_int16_t *)dl, 71 *end = (u_int16_t *)&dl->d_partitions[dl->d_npartitions]; 72 73 while (st < end) 74 sum ^= *st++; 75 return(sum); 76 } 77 78 u_int32_t 79 readdisklabel (char *fn, struct disklabel *dl) 80 { 81 int fd, e; 82 u_int32_t bbsec; 83 84 memset(dl, 0, sizeof *dl); 85 86 if ((fd = open(fn, O_RDONLY)) < 0) 87 err(EXIT_FAILURE, "%s", fn); 88 89 /* Try NetBSD/Atari format first */ 90 if ((e = bsd_label(fd, (off_t)0, dl)) < 0) 91 err(EXIT_FAILURE, "%s", fn); 92 if (!e) 93 return(0); 94 95 /* Try unprotected AHDI format last */ 96 if ((e = ahdi_label(fd, &bbsec, dl)) < 0) 97 err(EXIT_FAILURE, "%s", fn); 98 if (!e) 99 return(bbsec); 100 101 warnx("%s: Unknown disk label format.", fn); 102 return(NO_BOOT_BLOCK); 103 } 104 105 static int 106 bsd_label (int fd, off_t offs, struct disklabel *label) 107 { 108 struct bootblock bb; 109 struct disklabel *p; 110 111 if (lseek(fd, offs, SEEK_SET) != offs) 112 return(-1); 113 if (read(fd, &bb, sizeof(bb)) != sizeof(bb)) 114 return(-1); 115 116 p = (struct disklabel *)bb.bb_label; 117 if ( (offs == 0 && bb.bb_magic != NBDAMAGIC) 118 || (offs != 0 && bb.bb_magic != AHDIMAGIC) 119 || p->d_npartitions > MAXPARTITIONS 120 || p->d_magic2 != DISKMAGIC 121 || p->d_magic != DISKMAGIC 122 || dkcksum(p) != 0 123 ) { 124 return(1); 125 } 126 127 *label = *p; 128 return(0); 129 } 130 131 static int 132 ahdi_label (int fd, u_int32_t *bbsec, struct disklabel *label) 133 { 134 struct ahdilabel al; 135 u_int i, j; 136 int e; 137 138 memset(&al, 0, sizeof(al)); 139 if ((e = ahdi_getparts(fd, AHDI_BBLOCK, AHDI_BBLOCK, &al))) 140 return(e); 141 142 /* 143 * Perform sanity checks. 144 */ 145 if (al.bslst == 0 || al.bslend == 0) 146 return(1); 147 if (al.nsecs == 0 || al.nparts == 0) 148 return(1); 149 if (al.nparts > AHDI_MAXPARTS) 150 warnx("Too many AHDI partitions (%u).", al.nparts); 151 for (i = 0; i < al.nparts; ++i) { 152 struct ahdi_part *p1 = &al.parts[i]; 153 for (j = 0; j < al.nroots; ++j) { 154 daddr_t aux = al.roots[j]; 155 if (aux >= p1->ap_st && aux <= p1->ap_end) 156 return(1); 157 } 158 for (j = i + 1; j < al.nparts; ++j) { 159 struct ahdi_part *p2 = &al.parts[j]; 160 if (p1->ap_st >= p2->ap_st && p1->ap_st <= p2->ap_end) 161 return(1); 162 if (p2->ap_st >= p1->ap_st && p2->ap_st <= p1->ap_end) 163 return(1); 164 } 165 if (p1->ap_st >= al.bslst && p1->ap_st <= al.bslend) 166 return(1); 167 if (al.bslst >= p1->ap_st && al.bslst <= p1->ap_end) 168 return(1); 169 } 170 171 /* 172 * Search for a NetBSD boot block 173 */ 174 for (i = 0; i < al.nparts; ++i) { 175 struct ahdi_part *pd = &al.parts[i]; 176 u_int id; 177 178 memcpy(&id, &pd->ap_flg, sizeof (id)); 179 if (id == AHDI_PID_NBD || id == AHDI_PID_RAW) { 180 off_t offs = pd->ap_st * AHDI_BSIZE; 181 if ((e = bsd_label(fd, offs, label)) < 0) 182 return(e); 183 if (!e) { 184 *bbsec = pd->ap_st; /* got it */ 185 return(0); 186 } 187 } 188 } 189 *bbsec = NO_BOOT_BLOCK; /* AHDI label, no NetBSD boot block */ 190 return(0); 191 } 192 193 static int 194 ahdi_getparts(fd, rsec, esec, alab) 195 int fd; 196 daddr_t rsec, 197 esec; 198 struct ahdilabel *alab; 199 { 200 struct ahdi_part *part, *end; 201 struct ahdi_root root; 202 off_t ro; 203 204 ro = rsec * AHDI_BSIZE; 205 if (lseek(fd, ro, SEEK_SET) != ro) { 206 off_t mend = lseek(fd, 0, SEEK_END); 207 if (mend == -1 || mend > ro) 208 return(-1); 209 return(1); 210 } 211 if (read(fd, &root, sizeof(root)) != sizeof(root)) 212 return(-1); 213 214 if (rsec == AHDI_BBLOCK) 215 end = &root.ar_parts[AHDI_MAXRPD]; 216 else end = &root.ar_parts[AHDI_MAXARPD]; 217 for (part = root.ar_parts; part < end; ++part) { 218 u_int id; 219 220 memcpy(&id, &part->ap_flg, sizeof (id)); 221 if (!(id & 0x01000000)) 222 continue; 223 if ((id &= 0x00ffffff) == AHDI_PID_XGM) { 224 int e; 225 daddr_t aux = part->ap_st + esec; 226 alab->roots = realloc(alab->roots, 227 (alab->nroots + 1) * sizeof(*alab->roots)); 228 alab->roots[alab->nroots++] = aux; 229 e = ahdi_getparts(fd, aux, 230 esec == AHDI_BBLOCK ? aux : esec, alab); 231 if (e) 232 return(e); 233 } else { 234 struct ahdi_part *p; 235 alab->parts = realloc(alab->parts, 236 (alab->nparts + 1) * sizeof(*alab->parts)); 237 p = &alab->parts[alab->nparts++]; 238 memcpy(&p->ap_flg, &id, sizeof (id)); 239 p->ap_st = part->ap_st + rsec; 240 p->ap_end = p->ap_st + part->ap_size - 1; 241 } 242 } 243 alab->nsecs = root.ar_hdsize; 244 alab->bslst = root.ar_bslst; 245 alab->bslend = root.ar_bslst + root.ar_bslsize - 1; 246 return(0); 247 } 248
Indexes created Tue Sep 30 11:09:46 GMT 2025