xref: /netbsd-src/sys/arch/hpc/hpc/disksubr.c (revision 1cd43426d582b6650b153797f2db305dcd93c554)
1 /*	$NetBSD: disksubr.c,v 1.23 2024/02/10 18:43:51 andvar Exp $	*/
2 
3 /*
4  * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
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. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  *	@(#)ufs_disksubr.c	7.16 (Berkeley) 5/4/91
32  */
33 
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: disksubr.c,v 1.23 2024/02/10 18:43:51 andvar Exp $");
36 
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/buf.h>
40 #include <sys/disklabel.h>
41 #include <sys/disk.h>
42 #include <sys/syslog.h>
43 
44 #include "opt_mbr.h"
45 
46 int fat_types[] = { MBR_PTYPE_FAT12, MBR_PTYPE_FAT16S,
47 		    MBR_PTYPE_FAT16B, MBR_PTYPE_FAT32,
48 		    MBR_PTYPE_FAT32L, MBR_PTYPE_FAT16L,
49 		    -1 };
50 
51 #define NO_MBR_SIGNATURE ((struct mbr_partition *) -1)
52 
53 static struct mbr_partition *
54 mbr_findslice(struct mbr_partition* dp, struct buf *bp);
55 
56 /*
57  * Scan MBR for  NetBSD partition.  Return NO_MBR_SIGNATURE if no MBR found
58  * Otherwise, copy valid MBR partition-table into dp, and if a NetBSD
59  * partition is found, return a pointer to it; else return  NULL.
60  */
61 static
62 struct mbr_partition *
mbr_findslice(struct mbr_partition * dp,struct buf * bp)63 mbr_findslice(struct mbr_partition *dp, struct buf *bp)
64 {
65 	struct mbr_partition *ourdp = NULL;
66 	uint16_t *mbrmagicp;
67 	int i;
68 
69 	/* Note: Magic number is little-endian. */
70 	mbrmagicp = (uint16_t *)((char*)bp->b_data + MBR_MAGIC_OFFSET);
71 	if (*mbrmagicp != MBR_MAGIC)
72 		return (NO_MBR_SIGNATURE);
73 
74 	/* XXX how do we check veracity/bounds of this? */
75 	memcpy(dp, (char*)bp->b_data + MBR_PART_OFFSET,
76 		MBR_PART_COUNT * sizeof(*dp));
77 
78 	/* look for NetBSD partition */
79 	for (i = 0; i < MBR_PART_COUNT; i++) {
80 		if (dp[i].mbrp_type == MBR_PTYPE_NETBSD) {
81 			ourdp = &dp[i];
82 			break;
83 		}
84 	}
85 
86 #ifdef COMPAT_386BSD_MBRPART
87 	/* didn't find it -- look for 386BSD partition */
88 	if (!ourdp) {
89 		for (i = 0; i < MBR_PART_COUNT; i++) {
90 			if (dp[i].mbrp_type == MBR_PTYPE_386BSD) {
91 				printf("WARNING: old BSD partition ID!\n");
92 				ourdp = &dp[i];
93  				/*
94 				 * If more than one matches, take last,
95 				 * as NetBSD install tool does.
96 				 */
97 #if 0
98 				break;
99 #endif
100 			}
101 		}
102 	}
103 #endif	/* COMPAT_386BSD_MBRPART */
104 
105 		return (ourdp);
106 }
107 
108 
109 /*
110  * Attempt to read a disk label from a device
111  * using the indicated strategy routine.
112  * The label must be partly set up before this:
113  * secpercyl, secsize and anything required for a block i/o read
114  * operation in the driver's strategy/start routines
115  * must be filled in before calling us.
116  *
117  * If dos partition table requested, attempt to load it and
118  * find disklabel inside a DOS partition. Also, if bad block
119  * table needed, attempt to extract it as well. Return buffer
120  * for use in signalling errors if requested.
121  *
122  * Returns null on success and an error string on failure.
123  */
124 const char *
readdisklabel(dev_t dev,void (* strat)(struct buf *),struct disklabel * lp,struct cpu_disklabel * osdep)125 readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
126     struct cpu_disklabel *osdep)
127 {
128 	struct mbr_partition *dp;
129 	struct partition *pp;
130 	struct dkbad *bdp;
131 	struct buf *bp;
132 	struct disklabel *dlp;
133 	const char *msg = NULL;
134 	int dospartoff, cyl, i, *ip;
135 
136 	/* minimal requirements for archtypal disk label */
137 	if (lp->d_secsize == 0)
138 		lp->d_secsize = DEV_BSIZE;
139 	if (lp->d_secperunit == 0)
140 		lp->d_secperunit = 0x1fffffff;
141 #if 0
142 	if (lp->d_ncylinders == 16383) {
143 		printf("disklabel: Disk > 8G ... readjusting chs %d/%d/%d to ",
144 			lp->d_ncylinders, lp->d_ntracks, lp->d_nsectors);
145 		lp->d_ncylinders = lp->d_secperunit /  lp->d_ntracks / lp->d_nsectors;
146 		printf("%d/%d/%d\n",
147 			lp->d_ncylinders, lp->d_ntracks, lp->d_nsectors);
148 	}
149 #endif
150 	lp->d_npartitions = RAW_PART + 1;
151 	for (i = 0; i < RAW_PART; i++) {
152 		lp->d_partitions[i].p_size = 0;
153 		lp->d_partitions[i].p_offset = 0;
154 	}
155 	if (lp->d_partitions[i].p_size == 0)
156 		lp->d_partitions[i].p_size = 0x1fffffff;
157 	lp->d_partitions[i].p_offset = 0;
158 
159 	/* get a buffer and initialize it */
160 	bp = geteblk((int)lp->d_secsize);
161 	bp->b_dev = dev;
162 
163 	/* do dos partitions in the process of getting disklabel? */
164 	dospartoff = 0;
165 	cyl = LABELSECTOR / lp->d_secpercyl;
166 	if (!osdep)
167 		goto nombrpart;
168 	dp = osdep->mbrparts;
169 
170 	/* read master boot record */
171 	bp->b_blkno = MBR_BBSECTOR;
172 	bp->b_bcount = lp->d_secsize;
173 	bp->b_flags |= B_READ;
174 	bp->b_cylinder = MBR_BBSECTOR / lp->d_secpercyl;
175 	(*strat)(bp);
176 
177 	/* if successful, wander through dos partition table */
178 	if (biowait(bp)) {
179 		msg = "dos partition I/O error";
180 		goto done;
181 	} else {
182 		struct mbr_partition *ourdp = NULL;
183 
184 		ourdp = mbr_findslice(dp, bp);
185 		if (ourdp ==  NO_MBR_SIGNATURE)
186 			goto nombrpart;
187 
188 		for (i = 0; i < MBR_PART_COUNT; i++, dp++) {
189 			/* Install in partition e, f, g, or h. */
190 			pp = &lp->d_partitions[RAW_PART + 1 + i];
191 			pp->p_offset = dp->mbrp_start;
192 			pp->p_size = dp->mbrp_size;
193 			for (ip = fat_types; *ip != -1; ip++) {
194 				if (dp->mbrp_type == *ip)
195 					pp->p_fstype = FS_MSDOS;
196 			}
197 			if (dp->mbrp_type == MBR_PTYPE_LNXEXT2)
198 				pp->p_fstype = FS_EX2FS;
199 
200 			if (dp->mbrp_type == MBR_PTYPE_NTFS)
201 				pp->p_fstype = FS_NTFS;
202 
203 			/* is this ours? */
204 			if (dp == ourdp) {
205 				/* need sector address for SCSI/IDE,
206 				 cylinder for ESDI/ST506/RLL */
207 				dospartoff = dp->mbrp_start;
208 				cyl = MBR_PCYL(dp->mbrp_scyl, dp->mbrp_ssect);
209 
210 				/* update disklabel with details */
211 				lp->d_partitions[2].p_size =
212 				    dp->mbrp_size;
213 				lp->d_partitions[2].p_offset =
214 				    dp->mbrp_start;
215 #if 0
216 				if (lp->d_ntracks != dp->mbrp_ehd + 1 ||
217 				    lp->d_nsectors != DPSECT(dp->mbrp_esect)) {
218 					printf("disklabel: BIOS sees chs %d/%d/%d as ",
219 						lp->d_ncylinders, lp->d_ntracks,
220 						lp->d_nsectors);
221 					lp->d_ntracks = dp->mbrp_ehd + 1;
222 					lp->d_nsectors = DPSECT(dp->mbrp_esect);
223 					lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
224 					lp->d_ncylinders = lp->d_secperunit / lp->d_secpercyl;
225 					if (! lp->d_ncylinders)
226 						lp->d_ncylinders = 1;
227 					printf("%d/%d/%d\n",
228 						lp->d_ncylinders, lp->d_ntracks,
229 						lp->d_nsectors);
230 				    }
231 #endif
232 			}
233 		}
234 		lp->d_npartitions = RAW_PART + 1 + i;
235 	}
236 
237 nombrpart:
238 	/* next, dig out disk label */
239 	bp->b_blkno = dospartoff + LABELSECTOR;
240 	bp->b_cylinder = cyl;
241 	bp->b_bcount = lp->d_secsize;
242 	bp->b_oflags &= ~(BO_DONE);
243 	bp->b_flags |= B_READ;
244 	(*strat)(bp);
245 
246 	/* if successful, locate disk label within block and validate */
247 	if (biowait(bp)) {
248 		msg = "disk label I/O error";
249 		goto done;
250 	}
251 	for (dlp = (struct disklabel *)bp->b_data;
252 	    dlp <= (struct disklabel *)((char*)bp->b_data +
253 		lp->d_secsize - sizeof(*dlp));
254 	    dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
255 		if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
256 			if (msg == NULL)
257 				msg = "no disk label";
258 		} else if (dlp->d_npartitions > MAXPARTITIONS ||
259 			   dkcksum(dlp) != 0)
260 			msg = "disk label corrupted";
261 		else {
262 			*lp = *dlp;
263 			msg = NULL;
264 			break;
265 		}
266 	}
267 
268 	if (msg)
269 		goto done;
270 
271 	/* obtain bad sector table if requested and present */
272 	if (osdep && (lp->d_flags & D_BADSECT)) {
273 		struct dkbad *db;
274 
275 		bdp = &osdep->bad;
276 		i = 0;
277 		do {
278 			/* read a bad sector table */
279 			bp->b_oflags &= ~(BO_DONE);
280 			bp->b_flags |= B_READ;
281 			bp->b_blkno = lp->d_secperunit - lp->d_nsectors + i;
282 			if (lp->d_secsize > DEV_BSIZE)
283 				bp->b_blkno *= lp->d_secsize / DEV_BSIZE;
284 			else
285 				bp->b_blkno /= DEV_BSIZE / lp->d_secsize;
286 			bp->b_bcount = lp->d_secsize;
287 			bp->b_cylinder = lp->d_ncylinders - 1;
288 			(*strat)(bp);
289 
290 			/* if successful, validate, otherwise try another */
291 			if (biowait(bp)) {
292 				msg = "bad sector table I/O error";
293 			} else {
294 				db = (struct dkbad *)(bp->b_data);
295 #define DKBAD_MAGIC 0x4321
296 				if (db->bt_mbz == 0
297 					&& db->bt_flag == DKBAD_MAGIC) {
298 					msg = NULL;
299 					*bdp = *db;
300 					break;
301 				} else
302 					msg = "bad sector table corrupted";
303 			}
304 		} while (bp->b_error != 0 && (i += 2) < 10 &&
305 			i < lp->d_nsectors);
306 	}
307 
308 done:
309 	brelse(bp, 0);
310 	return (msg);
311 }
312 
313 /*
314  * Write disk label back to device after modification.
315  */
316 int
writedisklabel(dev_t dev,void (* strat)(struct buf *),struct disklabel * lp,struct cpu_disklabel * osdep)317 writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
318     struct cpu_disklabel *osdep)
319 {
320 	struct mbr_partition *dp;
321 	struct buf *bp;
322 	struct disklabel *dlp;
323 	int error, dospartoff, cyl;
324 
325 	/* get a buffer and initialize it */
326 	bp = geteblk((int)lp->d_secsize);
327 	bp->b_dev = dev;
328 
329 	/* do dos partitions in the process of getting disklabel? */
330 	dospartoff = 0;
331 	cyl = LABELSECTOR / lp->d_secpercyl;
332 	if (!osdep)
333 		goto nombrpart;
334 	dp = osdep->mbrparts;
335 
336 	/* read master boot record */
337 	bp->b_blkno = MBR_BBSECTOR;
338 	bp->b_bcount = lp->d_secsize;
339 	bp->b_flags |= B_READ;
340 	bp->b_cylinder = MBR_BBSECTOR / lp->d_secpercyl;
341 	(*strat)(bp);
342 
343 	if ((error = biowait(bp)) == 0) {
344 		struct mbr_partition *ourdp = NULL;
345 
346 		ourdp = mbr_findslice(dp, bp);
347 		if (ourdp ==  NO_MBR_SIGNATURE)
348 			goto nombrpart;
349 
350 		if (ourdp) {
351 			/* need sector address for SCSI/IDE,
352 			 cylinder for ESDI/ST506/RLL */
353 			dospartoff = ourdp->mbrp_start;
354 			cyl = MBR_PCYL(ourdp->mbrp_scyl, ourdp->mbrp_ssect);
355 		}
356 	}
357 
358 nombrpart:
359 #ifdef maybe
360 	/* disklabel in appropriate location? */
361 	if (lp->d_partitions[2].p_offset != 0
362 		&& lp->d_partitions[2].p_offset != dospartoff) {
363 		error = EXDEV;
364 		goto done;
365 	}
366 #endif
367 
368 	/* next, dig out disk label */
369 	bp->b_blkno = dospartoff + LABELSECTOR;
370 	bp->b_cylinder = cyl;
371 	bp->b_bcount = lp->d_secsize;
372 	bp->b_oflags &= ~(BO_DONE);
373 	bp->b_flags |= B_READ;
374 	(*strat)(bp);
375 
376 	/* if successful, locate disk label within block and validate */
377 	if ((error = biowait(bp)) != 0)
378 		goto done;
379 	for (dlp = (struct disklabel *)bp->b_data;
380 	    dlp <= (struct disklabel *)((char *)bp->b_data +
381 		lp->d_secsize - sizeof(*dlp));
382 	    dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
383 		if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
384 		    dkcksum(dlp) == 0) {
385 			*dlp = *lp;
386 			bp->b_oflags &= ~(BO_DONE);
387 			bp->b_flags &= ~(B_READ);
388 			bp->b_flags |= B_WRITE;
389 			(*strat)(bp);
390 			error = biowait(bp);
391 			goto done;
392 		}
393 	}
394 	error = ESRCH;
395 
396 done:
397 	brelse(bp, 0);
398 	return (error);
399 }
400