1 /* $NetBSD: disklabel.c,v 1.7 2016/03/13 08:54:45 tsutsui 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
dkcksum(struct disklabel * dl)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
readdisklabel(char * fn,struct disklabel * dl)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
bsd_label(int fd,off_t offs,struct disklabel * label)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
ahdi_label(int fd,uint32_t * bbsec,struct disklabel * label)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
ahdi_getparts(int fd,daddr_t rsec,daddr_t esec,struct ahdilabel * alab)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