disklabel.c revision 1.6.12.1
1 /* $NetBSD: disklabel.c,v 1.6.12.1 2017/12/03 11:35:58 jdolecek 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 uint32_t readdisklabel(char *, struct disklabel *); 61 62 static int bsd_label(int, off_t, struct disklabel *); 63 static int ahdi_label(int, uint32_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 uint16_t sum = 0, 70 *st = (uint16_t *)dl, 71 *end = (uint16_t *)&dl->d_partitions[dl->d_npartitions]; 72 73 while (st < end) 74 sum ^= *st++; 75 return sum; 76 } 77 78 uint32_t 79 readdisklabel(char *fn, struct disklabel *dl) 80 { 81 int fd, e; 82 uint32_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 == 0) 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 == 0) 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 return 1; 124 } 125 126 *label = *p; 127 return 0; 128 } 129 130 static int 131 ahdi_label(int fd, uint32_t *bbsec, struct disklabel *label) 132 { 133 struct ahdilabel al; 134 u_int i, j; 135 int e; 136 137 memset(&al, 0, sizeof(al)); 138 if ((e = ahdi_getparts(fd, AHDI_BBLOCK, AHDI_BBLOCK, &al)) != 0) 139 return e; 140 141 /* 142 * Perform sanity checks. 143 */ 144 if (al.bslst == 0 || al.bslend == 0) 145 return 1; 146 if (al.nsecs == 0 || al.nparts == 0) 147 return 1; 148 if (al.nparts > AHDI_MAXPARTS) 149 warnx("Too many AHDI partitions (%u).", al.nparts); 150 for (i = 0; i < al.nparts; ++i) { 151 struct ahdi_part *p1 = &al.parts[i]; 152 for (j = 0; j < al.nroots; ++j) { 153 daddr_t aux = al.roots[j]; 154 if (aux >= p1->ap_st && aux <= p1->ap_end) 155 return 1; 156 } 157 for (j = i + 1; j < al.nparts; ++j) { 158 struct ahdi_part *p2 = &al.parts[j]; 159 if (p1->ap_st >= p2->ap_st && p1->ap_st <= p2->ap_end) 160 return 1; 161 if (p2->ap_st >= p1->ap_st && p2->ap_st <= p1->ap_end) 162 return 1; 163 } 164 if (p1->ap_st >= al.bslst && p1->ap_st <= al.bslend) 165 return 1; 166 if (al.bslst >= p1->ap_st && al.bslst <= p1->ap_end) 167 return 1; 168 } 169 170 /* 171 * Search for a NetBSD boot block 172 */ 173 for (i = 0; i < al.nparts; ++i) { 174 struct ahdi_part *pd = &al.parts[i]; 175 u_int id; 176 177 memcpy(&id, &pd->ap_flg, sizeof (id)); 178 if (id == AHDI_PID_NBD || id == AHDI_PID_RAW) { 179 off_t offs = pd->ap_st * AHDI_BSIZE; 180 if ((e = bsd_label(fd, offs, label)) < 0) 181 return e; 182 if (e == 0) { 183 *bbsec = pd->ap_st; /* got it */ 184 return 0; 185 } 186 } 187 } 188 *bbsec = NO_BOOT_BLOCK; /* AHDI label, no NetBSD boot block */ 189 return 0; 190 } 191 192 static int 193 ahdi_getparts(int fd, daddr_t rsec, daddr_t esec, struct ahdilabel *alab) 194 { 195 struct ahdi_part *part, *end; 196 struct ahdi_root root; 197 off_t ro; 198 199 ro = rsec * AHDI_BSIZE; 200 if (lseek(fd, ro, SEEK_SET) != ro) { 201 off_t mend = lseek(fd, 0, SEEK_END); 202 if (mend == -1 || mend > ro) 203 return -1; 204 return 1; 205 } 206 if (read(fd, &root, sizeof(root)) != sizeof(root)) 207 return -1; 208 209 if (rsec == AHDI_BBLOCK) 210 end = &root.ar_parts[AHDI_MAXRPD]; 211 else 212 end = &root.ar_parts[AHDI_MAXARPD]; 213 for (part = root.ar_parts; part < end; ++part) { 214 u_int id; 215 216 memcpy(&id, &part->ap_flg, sizeof (id)); 217 if ((id & 0x01000000) == 0) 218 continue; 219 if ((id &= 0x00ffffff) == AHDI_PID_XGM) { 220 int e; 221 daddr_t aux = part->ap_st + esec; 222 alab->roots = realloc(alab->roots, 223 (alab->nroots + 1) * sizeof(*alab->roots)); 224 alab->roots[alab->nroots++] = aux; 225 e = ahdi_getparts(fd, aux, 226 esec == AHDI_BBLOCK ? aux : esec, alab); 227 if (e != 0) 228 return e; 229 } else { 230 struct ahdi_part *p; 231 alab->parts = realloc(alab->parts, 232 (alab->nparts + 1) * sizeof(*alab->parts)); 233 p = &alab->parts[alab->nparts++]; 234 memcpy(&p->ap_flg, &id, sizeof (id)); 235 p->ap_st = part->ap_st + rsec; 236 p->ap_end = p->ap_st + part->ap_size - 1; 237 } 238 } 239 alab->nsecs = root.ar_hdsize; 240 alab->bslst = root.ar_bslst; 241 alab->bslend = root.ar_bslst + root.ar_bslsize - 1; 242 return 0; 243 } 244
Indexes created Tue Sep 30 11:09:46 GMT 2025