xref: /freebsd/sys/geom/part/g_part_mbr.c (revision 4f52dfbb8d6c4d446500c5b097e3806ec219fbd4)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2007, 2008 Marcel Moolenaar
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  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include <sys/param.h>
33 #include <sys/bio.h>
34 #include <sys/diskmbr.h>
35 #include <sys/endian.h>
36 #include <sys/kernel.h>
37 #include <sys/kobj.h>
38 #include <sys/limits.h>
39 #include <sys/lock.h>
40 #include <sys/malloc.h>
41 #include <sys/mutex.h>
42 #include <sys/queue.h>
43 #include <sys/sbuf.h>
44 #include <sys/systm.h>
45 #include <sys/sysctl.h>
46 #include <geom/geom.h>
47 #include <geom/geom_int.h>
48 #include <geom/part/g_part.h>
49 
50 #include "g_part_if.h"
51 
52 FEATURE(geom_part_mbr, "GEOM partitioning class for MBR support");
53 
54 SYSCTL_DECL(_kern_geom_part);
55 static SYSCTL_NODE(_kern_geom_part, OID_AUTO, mbr, CTLFLAG_RW, 0,
56     "GEOM_PART_MBR Master Boot Record");
57 
58 static u_int enforce_chs = 0;
59 SYSCTL_UINT(_kern_geom_part_mbr, OID_AUTO, enforce_chs,
60     CTLFLAG_RWTUN, &enforce_chs, 0, "Enforce alignment to CHS addressing");
61 
62 #define	MBRSIZE		512
63 
64 struct g_part_mbr_table {
65 	struct g_part_table	base;
66 	u_char		mbr[MBRSIZE];
67 };
68 
69 struct g_part_mbr_entry {
70 	struct g_part_entry	base;
71 	struct dos_partition ent;
72 };
73 
74 static int g_part_mbr_add(struct g_part_table *, struct g_part_entry *,
75     struct g_part_parms *);
76 static int g_part_mbr_bootcode(struct g_part_table *, struct g_part_parms *);
77 static int g_part_mbr_create(struct g_part_table *, struct g_part_parms *);
78 static int g_part_mbr_destroy(struct g_part_table *, struct g_part_parms *);
79 static void g_part_mbr_dumpconf(struct g_part_table *, struct g_part_entry *,
80     struct sbuf *, const char *);
81 static int g_part_mbr_dumpto(struct g_part_table *, struct g_part_entry *);
82 static int g_part_mbr_modify(struct g_part_table *, struct g_part_entry *,
83     struct g_part_parms *);
84 static const char *g_part_mbr_name(struct g_part_table *, struct g_part_entry *,
85     char *, size_t);
86 static int g_part_mbr_probe(struct g_part_table *, struct g_consumer *);
87 static int g_part_mbr_read(struct g_part_table *, struct g_consumer *);
88 static int g_part_mbr_setunset(struct g_part_table *, struct g_part_entry *,
89     const char *, unsigned int);
90 static const char *g_part_mbr_type(struct g_part_table *, struct g_part_entry *,
91     char *, size_t);
92 static int g_part_mbr_write(struct g_part_table *, struct g_consumer *);
93 static int g_part_mbr_resize(struct g_part_table *, struct g_part_entry *,
94     struct g_part_parms *);
95 
96 static kobj_method_t g_part_mbr_methods[] = {
97 	KOBJMETHOD(g_part_add,		g_part_mbr_add),
98 	KOBJMETHOD(g_part_bootcode,	g_part_mbr_bootcode),
99 	KOBJMETHOD(g_part_create,	g_part_mbr_create),
100 	KOBJMETHOD(g_part_destroy,	g_part_mbr_destroy),
101 	KOBJMETHOD(g_part_dumpconf,	g_part_mbr_dumpconf),
102 	KOBJMETHOD(g_part_dumpto,	g_part_mbr_dumpto),
103 	KOBJMETHOD(g_part_modify,	g_part_mbr_modify),
104 	KOBJMETHOD(g_part_resize,	g_part_mbr_resize),
105 	KOBJMETHOD(g_part_name,		g_part_mbr_name),
106 	KOBJMETHOD(g_part_probe,	g_part_mbr_probe),
107 	KOBJMETHOD(g_part_read,		g_part_mbr_read),
108 	KOBJMETHOD(g_part_setunset,	g_part_mbr_setunset),
109 	KOBJMETHOD(g_part_type,		g_part_mbr_type),
110 	KOBJMETHOD(g_part_write,	g_part_mbr_write),
111 	{ 0, 0 }
112 };
113 
114 static struct g_part_scheme g_part_mbr_scheme = {
115 	"MBR",
116 	g_part_mbr_methods,
117 	sizeof(struct g_part_mbr_table),
118 	.gps_entrysz = sizeof(struct g_part_mbr_entry),
119 	.gps_minent = NDOSPART,
120 	.gps_maxent = NDOSPART,
121 	.gps_bootcodesz = MBRSIZE,
122 };
123 G_PART_SCHEME_DECLARE(g_part_mbr);
124 MODULE_VERSION(geom_part_mbr, 0);
125 
126 static struct g_part_mbr_alias {
127 	u_char		typ;
128 	int		alias;
129 } mbr_alias_match[] = {
130 	{ DOSPTYP_386BSD,	G_PART_ALIAS_FREEBSD },
131 	{ DOSPTYP_EXT,		G_PART_ALIAS_EBR },
132 	{ DOSPTYP_NTFS,		G_PART_ALIAS_MS_NTFS },
133 	{ DOSPTYP_FAT16,	G_PART_ALIAS_MS_FAT16 },
134 	{ DOSPTYP_FAT32,	G_PART_ALIAS_MS_FAT32 },
135 	{ DOSPTYP_FAT32LBA,	G_PART_ALIAS_MS_FAT32LBA },
136 	{ DOSPTYP_EXTLBA,	G_PART_ALIAS_EBR },
137 	{ DOSPTYP_LDM,		G_PART_ALIAS_MS_LDM_DATA },
138 	{ DOSPTYP_LINSWP,	G_PART_ALIAS_LINUX_SWAP },
139 	{ DOSPTYP_LINUX,	G_PART_ALIAS_LINUX_DATA },
140 	{ DOSPTYP_LINLVM,	G_PART_ALIAS_LINUX_LVM },
141 	{ DOSPTYP_LINRAID,	G_PART_ALIAS_LINUX_RAID },
142 	{ DOSPTYP_PPCBOOT,	G_PART_ALIAS_PREP_BOOT },
143 	{ DOSPTYP_VMFS,		G_PART_ALIAS_VMFS },
144 	{ DOSPTYP_VMKDIAG,	G_PART_ALIAS_VMKDIAG },
145 	{ DOSPTYP_APPLE_UFS,	G_PART_ALIAS_APPLE_UFS },
146 	{ DOSPTYP_APPLE_BOOT,	G_PART_ALIAS_APPLE_BOOT },
147 	{ DOSPTYP_HFS,		G_PART_ALIAS_APPLE_HFS },
148 };
149 
150 static int
151 mbr_parse_type(const char *type, u_char *dp_typ)
152 {
153 	const char *alias;
154 	char *endp;
155 	long lt;
156 	int i;
157 
158 	if (type[0] == '!') {
159 		lt = strtol(type + 1, &endp, 0);
160 		if (type[1] == '\0' || *endp != '\0' || lt <= 0 || lt >= 256)
161 			return (EINVAL);
162 		*dp_typ = (u_char)lt;
163 		return (0);
164 	}
165 	for (i = 0; i < nitems(mbr_alias_match); i++) {
166 		alias = g_part_alias_name(mbr_alias_match[i].alias);
167 		if (strcasecmp(type, alias) == 0) {
168 			*dp_typ = mbr_alias_match[i].typ;
169 			return (0);
170 		}
171 	}
172 	return (EINVAL);
173 }
174 
175 static int
176 mbr_probe_bpb(u_char *bpb)
177 {
178 	uint16_t secsz;
179 	uint8_t clstsz;
180 
181 #define PO2(x)	((x & (x - 1)) == 0)
182 	secsz = le16dec(bpb);
183 	if (secsz < 512 || secsz > 4096 || !PO2(secsz))
184 		return (0);
185 	clstsz = bpb[2];
186 	if (clstsz < 1 || clstsz > 128 || !PO2(clstsz))
187 		return (0);
188 #undef PO2
189 
190 	return (1);
191 }
192 
193 static void
194 mbr_set_chs(struct g_part_table *table, uint32_t lba, u_char *cylp, u_char *hdp,
195     u_char *secp)
196 {
197 	uint32_t cyl, hd, sec;
198 
199 	sec = lba % table->gpt_sectors + 1;
200 	lba /= table->gpt_sectors;
201 	hd = lba % table->gpt_heads;
202 	lba /= table->gpt_heads;
203 	cyl = lba;
204 	if (cyl > 1023)
205 		sec = hd = cyl = ~0;
206 
207 	*cylp = cyl & 0xff;
208 	*hdp = hd & 0xff;
209 	*secp = (sec & 0x3f) | ((cyl >> 2) & 0xc0);
210 }
211 
212 static int
213 mbr_align(struct g_part_table *basetable, uint32_t *start, uint32_t *size)
214 {
215 	uint32_t sectors;
216 
217 	if (enforce_chs == 0)
218 		return (0);
219 	sectors = basetable->gpt_sectors;
220 	if (*size < sectors)
221 		return (EINVAL);
222 	if (start != NULL && (*start % sectors)) {
223 		*size += (*start % sectors) - sectors;
224 		*start -= (*start % sectors) - sectors;
225 	}
226 	if (*size % sectors)
227 		*size -= (*size % sectors);
228 	if (*size < sectors)
229 		return (EINVAL);
230 	return (0);
231 }
232 
233 static int
234 g_part_mbr_add(struct g_part_table *basetable, struct g_part_entry *baseentry,
235     struct g_part_parms *gpp)
236 {
237 	struct g_part_mbr_entry *entry;
238 	uint32_t start, size;
239 
240 	if (gpp->gpp_parms & G_PART_PARM_LABEL)
241 		return (EINVAL);
242 
243 	entry = (struct g_part_mbr_entry *)baseentry;
244 	start = gpp->gpp_start;
245 	size = gpp->gpp_size;
246 	if (mbr_align(basetable, &start, &size) != 0)
247 		return (EINVAL);
248 	if (baseentry->gpe_deleted)
249 		bzero(&entry->ent, sizeof(entry->ent));
250 
251 	KASSERT(baseentry->gpe_start <= start, ("%s", __func__));
252 	KASSERT(baseentry->gpe_end >= start + size - 1, ("%s", __func__));
253 	baseentry->gpe_start = start;
254 	baseentry->gpe_end = start + size - 1;
255 	entry->ent.dp_start = start;
256 	entry->ent.dp_size = size;
257 	mbr_set_chs(basetable, baseentry->gpe_start, &entry->ent.dp_scyl,
258 	    &entry->ent.dp_shd, &entry->ent.dp_ssect);
259 	mbr_set_chs(basetable, baseentry->gpe_end, &entry->ent.dp_ecyl,
260 	    &entry->ent.dp_ehd, &entry->ent.dp_esect);
261 	return (mbr_parse_type(gpp->gpp_type, &entry->ent.dp_typ));
262 }
263 
264 static int
265 g_part_mbr_bootcode(struct g_part_table *basetable, struct g_part_parms *gpp)
266 {
267 	struct g_part_mbr_table *table;
268 	uint32_t dsn;
269 
270 	if (gpp->gpp_codesize != MBRSIZE)
271 		return (ENODEV);
272 
273 	table = (struct g_part_mbr_table *)basetable;
274 	dsn = *(uint32_t *)(table->mbr + DOSDSNOFF);
275 	bcopy(gpp->gpp_codeptr, table->mbr, DOSPARTOFF);
276 	if (dsn != 0)
277 		*(uint32_t *)(table->mbr + DOSDSNOFF) = dsn;
278 	return (0);
279 }
280 
281 static int
282 g_part_mbr_create(struct g_part_table *basetable, struct g_part_parms *gpp)
283 {
284 	struct g_provider *pp;
285 	struct g_part_mbr_table *table;
286 
287 	pp = gpp->gpp_provider;
288 	if (pp->sectorsize < MBRSIZE)
289 		return (ENOSPC);
290 
291 	basetable->gpt_first = basetable->gpt_sectors;
292 	basetable->gpt_last = MIN(pp->mediasize / pp->sectorsize,
293 	    UINT32_MAX) - 1;
294 
295 	table = (struct g_part_mbr_table *)basetable;
296 	le16enc(table->mbr + DOSMAGICOFFSET, DOSMAGIC);
297 	return (0);
298 }
299 
300 static int
301 g_part_mbr_destroy(struct g_part_table *basetable, struct g_part_parms *gpp)
302 {
303 
304 	/* Wipe the first sector to clear the partitioning. */
305 	basetable->gpt_smhead |= 1;
306 	return (0);
307 }
308 
309 static void
310 g_part_mbr_dumpconf(struct g_part_table *basetable, struct g_part_entry *baseentry,
311     struct sbuf *sb, const char *indent)
312 {
313 	struct g_part_mbr_entry *entry;
314 	struct g_part_mbr_table *table;
315 	uint32_t dsn;
316 
317 	table = (struct g_part_mbr_table *)basetable;
318 	entry = (struct g_part_mbr_entry *)baseentry;
319 	if (indent == NULL) {
320 		/* conftxt: libdisk compatibility */
321 		sbuf_printf(sb, " xs MBR xt %u", entry->ent.dp_typ);
322 	} else if (entry != NULL) {
323 		/* confxml: partition entry information */
324 		sbuf_printf(sb, "%s<rawtype>%u</rawtype>\n", indent,
325 		    entry->ent.dp_typ);
326 		if (entry->ent.dp_flag & 0x80)
327 			sbuf_printf(sb, "%s<attrib>active</attrib>\n", indent);
328 		dsn = le32dec(table->mbr + DOSDSNOFF);
329 		sbuf_printf(sb, "%s<efimedia>HD(%d,MBR,%#08x,%#jx,%#jx)", indent,
330 		    entry->base.gpe_index, dsn, (intmax_t)entry->base.gpe_start,
331 		    (intmax_t)(entry->base.gpe_end - entry->base.gpe_start + 1));
332 		sbuf_printf(sb, "</efimedia>\n");
333 	} else {
334 		/* confxml: scheme information */
335 	}
336 }
337 
338 static int
339 g_part_mbr_dumpto(struct g_part_table *table, struct g_part_entry *baseentry)
340 {
341 	struct g_part_mbr_entry *entry;
342 
343 	/* Allow dumping to a FreeBSD partition or Linux swap partition only. */
344 	entry = (struct g_part_mbr_entry *)baseentry;
345 	return ((entry->ent.dp_typ == DOSPTYP_386BSD ||
346 	    entry->ent.dp_typ == DOSPTYP_LINSWP) ? 1 : 0);
347 }
348 
349 static int
350 g_part_mbr_modify(struct g_part_table *basetable,
351     struct g_part_entry *baseentry, struct g_part_parms *gpp)
352 {
353 	struct g_part_mbr_entry *entry;
354 
355 	if (gpp->gpp_parms & G_PART_PARM_LABEL)
356 		return (EINVAL);
357 
358 	entry = (struct g_part_mbr_entry *)baseentry;
359 	if (gpp->gpp_parms & G_PART_PARM_TYPE)
360 		return (mbr_parse_type(gpp->gpp_type, &entry->ent.dp_typ));
361 	return (0);
362 }
363 
364 static int
365 g_part_mbr_resize(struct g_part_table *basetable,
366     struct g_part_entry *baseentry, struct g_part_parms *gpp)
367 {
368 	struct g_part_mbr_entry *entry;
369 	struct g_provider *pp;
370 	uint32_t size;
371 
372 	if (baseentry == NULL) {
373 		pp = LIST_FIRST(&basetable->gpt_gp->consumer)->provider;
374 		basetable->gpt_last = MIN(pp->mediasize / pp->sectorsize,
375 		    UINT32_MAX) - 1;
376 		return (0);
377 	}
378 	size = gpp->gpp_size;
379 	if (mbr_align(basetable, NULL, &size) != 0)
380 		return (EINVAL);
381 	/* XXX: prevent unexpected shrinking. */
382 	pp = baseentry->gpe_pp;
383 	if ((g_debugflags & 0x10) == 0 && size < gpp->gpp_size &&
384 	    pp->mediasize / pp->sectorsize > size)
385 		return (EBUSY);
386 	entry = (struct g_part_mbr_entry *)baseentry;
387 	baseentry->gpe_end = baseentry->gpe_start + size - 1;
388 	entry->ent.dp_size = size;
389 	mbr_set_chs(basetable, baseentry->gpe_end, &entry->ent.dp_ecyl,
390 	    &entry->ent.dp_ehd, &entry->ent.dp_esect);
391 	return (0);
392 }
393 
394 static const char *
395 g_part_mbr_name(struct g_part_table *table, struct g_part_entry *baseentry,
396     char *buf, size_t bufsz)
397 {
398 
399 	snprintf(buf, bufsz, "s%d", baseentry->gpe_index);
400 	return (buf);
401 }
402 
403 static int
404 g_part_mbr_probe(struct g_part_table *table, struct g_consumer *cp)
405 {
406 	char psn[8];
407 	struct g_provider *pp;
408 	u_char *buf, *p;
409 	int error, index, res, sum;
410 	uint16_t magic;
411 
412 	pp = cp->provider;
413 
414 	/* Sanity-check the provider. */
415 	if (pp->sectorsize < MBRSIZE || pp->mediasize < pp->sectorsize)
416 		return (ENOSPC);
417 	if (pp->sectorsize > 4096)
418 		return (ENXIO);
419 
420 	/* We don't nest under an MBR (see EBR instead). */
421 	error = g_getattr("PART::scheme", cp, &psn);
422 	if (error == 0 && strcmp(psn, g_part_mbr_scheme.name) == 0)
423 		return (ELOOP);
424 
425 	/* Check that there's a MBR. */
426 	buf = g_read_data(cp, 0L, pp->sectorsize, &error);
427 	if (buf == NULL)
428 		return (error);
429 
430 	/* We goto out on mismatch. */
431 	res = ENXIO;
432 
433 	magic = le16dec(buf + DOSMAGICOFFSET);
434 	if (magic != DOSMAGIC)
435 		goto out;
436 
437 	for (index = 0; index < NDOSPART; index++) {
438 		p = buf + DOSPARTOFF + index * DOSPARTSIZE;
439 		if (p[0] != 0 && p[0] != 0x80)
440 			goto out;
441 	}
442 
443 	/*
444 	 * If the partition table does not consist of all zeroes,
445 	 * assume we have a MBR. If it's all zeroes, we could have
446 	 * a boot sector. For example, a boot sector that doesn't
447 	 * have boot code -- common on non-i386 hardware. In that
448 	 * case we check if we have a possible BPB. If so, then we
449 	 * assume we have a boot sector instead.
450 	 */
451 	sum = 0;
452 	for (index = 0; index < NDOSPART * DOSPARTSIZE; index++)
453 		sum += buf[DOSPARTOFF + index];
454 	if (sum != 0 || !mbr_probe_bpb(buf + 0x0b))
455 		res = G_PART_PROBE_PRI_NORM;
456 
457  out:
458 	g_free(buf);
459 	return (res);
460 }
461 
462 static int
463 g_part_mbr_read(struct g_part_table *basetable, struct g_consumer *cp)
464 {
465 	struct dos_partition ent;
466 	struct g_provider *pp;
467 	struct g_part_mbr_table *table;
468 	struct g_part_mbr_entry *entry;
469 	u_char *buf, *p;
470 	off_t chs, msize, first;
471 	u_int sectors, heads;
472 	int error, index;
473 
474 	pp = cp->provider;
475 	table = (struct g_part_mbr_table *)basetable;
476 	first = basetable->gpt_sectors;
477 	msize = MIN(pp->mediasize / pp->sectorsize, UINT32_MAX);
478 
479 	buf = g_read_data(cp, 0L, pp->sectorsize, &error);
480 	if (buf == NULL)
481 		return (error);
482 
483 	bcopy(buf, table->mbr, sizeof(table->mbr));
484 	for (index = NDOSPART - 1; index >= 0; index--) {
485 		p = buf + DOSPARTOFF + index * DOSPARTSIZE;
486 		ent.dp_flag = p[0];
487 		ent.dp_shd = p[1];
488 		ent.dp_ssect = p[2];
489 		ent.dp_scyl = p[3];
490 		ent.dp_typ = p[4];
491 		ent.dp_ehd = p[5];
492 		ent.dp_esect = p[6];
493 		ent.dp_ecyl = p[7];
494 		ent.dp_start = le32dec(p + 8);
495 		ent.dp_size = le32dec(p + 12);
496 		if (ent.dp_typ == 0 || ent.dp_typ == DOSPTYP_PMBR)
497 			continue;
498 		if (ent.dp_start == 0 || ent.dp_size == 0)
499 			continue;
500 		sectors = ent.dp_esect & 0x3f;
501 		if (sectors > basetable->gpt_sectors &&
502 		    !basetable->gpt_fixgeom) {
503 			g_part_geometry_heads(msize, sectors, &chs, &heads);
504 			if (chs != 0) {
505 				basetable->gpt_sectors = sectors;
506 				basetable->gpt_heads = heads;
507 			}
508 		}
509 		if (ent.dp_start < first)
510 			first = ent.dp_start;
511 		entry = (struct g_part_mbr_entry *)g_part_new_entry(basetable,
512 		    index + 1, ent.dp_start, ent.dp_start + ent.dp_size - 1);
513 		entry->ent = ent;
514 	}
515 
516 	basetable->gpt_entries = NDOSPART;
517 	basetable->gpt_first = basetable->gpt_sectors;
518 	basetable->gpt_last = msize - 1;
519 
520 	if (first < basetable->gpt_first)
521 		basetable->gpt_first = 1;
522 
523 	g_free(buf);
524 	return (0);
525 }
526 
527 static int
528 g_part_mbr_setunset(struct g_part_table *table, struct g_part_entry *baseentry,
529     const char *attrib, unsigned int set)
530 {
531 	struct g_part_entry *iter;
532 	struct g_part_mbr_entry *entry;
533 	int changed;
534 
535 	if (baseentry == NULL)
536 		return (ENODEV);
537 	if (strcasecmp(attrib, "active") != 0)
538 		return (EINVAL);
539 
540 	/* Only one entry can have the active attribute. */
541 	LIST_FOREACH(iter, &table->gpt_entry, gpe_entry) {
542 		if (iter->gpe_deleted)
543 			continue;
544 		changed = 0;
545 		entry = (struct g_part_mbr_entry *)iter;
546 		if (iter == baseentry) {
547 			if (set && (entry->ent.dp_flag & 0x80) == 0) {
548 				entry->ent.dp_flag |= 0x80;
549 				changed = 1;
550 			} else if (!set && (entry->ent.dp_flag & 0x80)) {
551 				entry->ent.dp_flag &= ~0x80;
552 				changed = 1;
553 			}
554 		} else {
555 			if (set && (entry->ent.dp_flag & 0x80)) {
556 				entry->ent.dp_flag &= ~0x80;
557 				changed = 1;
558 			}
559 		}
560 		if (changed && !iter->gpe_created)
561 			iter->gpe_modified = 1;
562 	}
563 	return (0);
564 }
565 
566 static const char *
567 g_part_mbr_type(struct g_part_table *basetable, struct g_part_entry *baseentry,
568     char *buf, size_t bufsz)
569 {
570 	struct g_part_mbr_entry *entry;
571 	int i;
572 
573 	entry = (struct g_part_mbr_entry *)baseentry;
574 	for (i = 0; i < nitems(mbr_alias_match); i++) {
575 		if (mbr_alias_match[i].typ == entry->ent.dp_typ)
576 			return (g_part_alias_name(mbr_alias_match[i].alias));
577 	}
578 	snprintf(buf, bufsz, "!%d", entry->ent.dp_typ);
579 	return (buf);
580 }
581 
582 static int
583 g_part_mbr_write(struct g_part_table *basetable, struct g_consumer *cp)
584 {
585 	struct g_part_entry *baseentry;
586 	struct g_part_mbr_entry *entry;
587 	struct g_part_mbr_table *table;
588 	u_char *p;
589 	int error, index;
590 
591 	table = (struct g_part_mbr_table *)basetable;
592 	baseentry = LIST_FIRST(&basetable->gpt_entry);
593 	for (index = 1; index <= basetable->gpt_entries; index++) {
594 		p = table->mbr + DOSPARTOFF + (index - 1) * DOSPARTSIZE;
595 		entry = (baseentry != NULL && index == baseentry->gpe_index)
596 		    ? (struct g_part_mbr_entry *)baseentry : NULL;
597 		if (entry != NULL && !baseentry->gpe_deleted) {
598 			p[0] = entry->ent.dp_flag;
599 			p[1] = entry->ent.dp_shd;
600 			p[2] = entry->ent.dp_ssect;
601 			p[3] = entry->ent.dp_scyl;
602 			p[4] = entry->ent.dp_typ;
603 			p[5] = entry->ent.dp_ehd;
604 			p[6] = entry->ent.dp_esect;
605 			p[7] = entry->ent.dp_ecyl;
606 			le32enc(p + 8, entry->ent.dp_start);
607 			le32enc(p + 12, entry->ent.dp_size);
608 		} else
609 			bzero(p, DOSPARTSIZE);
610 
611 		if (entry != NULL)
612 			baseentry = LIST_NEXT(baseentry, gpe_entry);
613 	}
614 
615 	error = g_write_data(cp, 0, table->mbr, cp->provider->sectorsize);
616 	return (error);
617 }
618