xref: /freebsd/sys/geom/part/g_part_apm.c (revision bb15ca603fa442c72dde3f3cb8b46db6970e3950)
1 /*-
2  * Copyright (c) 2006-2008 Marcel Moolenaar
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include <sys/param.h>
31 #include <sys/apm.h>
32 #include <sys/bio.h>
33 #include <sys/diskmbr.h>
34 #include <sys/endian.h>
35 #include <sys/kernel.h>
36 #include <sys/kobj.h>
37 #include <sys/limits.h>
38 #include <sys/lock.h>
39 #include <sys/malloc.h>
40 #include <sys/mutex.h>
41 #include <sys/queue.h>
42 #include <sys/sbuf.h>
43 #include <sys/systm.h>
44 #include <sys/sysctl.h>
45 #include <geom/geom.h>
46 #include <geom/part/g_part.h>
47 
48 #include "g_part_if.h"
49 
50 FEATURE(geom_part_apm, "GEOM partitioning class for Apple-style partitions");
51 
52 struct g_part_apm_table {
53 	struct g_part_table	base;
54 	struct apm_ddr		ddr;
55 	struct apm_ent		self;
56 	int			tivo_series1;
57 };
58 
59 struct g_part_apm_entry {
60 	struct g_part_entry	base;
61 	struct apm_ent		ent;
62 };
63 
64 static int g_part_apm_add(struct g_part_table *, struct g_part_entry *,
65     struct g_part_parms *);
66 static int g_part_apm_create(struct g_part_table *, struct g_part_parms *);
67 static int g_part_apm_destroy(struct g_part_table *, struct g_part_parms *);
68 static void g_part_apm_dumpconf(struct g_part_table *, struct g_part_entry *,
69     struct sbuf *, const char *);
70 static int g_part_apm_dumpto(struct g_part_table *, struct g_part_entry *);
71 static int g_part_apm_modify(struct g_part_table *, struct g_part_entry *,
72     struct g_part_parms *);
73 static const char *g_part_apm_name(struct g_part_table *, struct g_part_entry *,
74     char *, size_t);
75 static int g_part_apm_probe(struct g_part_table *, struct g_consumer *);
76 static int g_part_apm_read(struct g_part_table *, struct g_consumer *);
77 static const char *g_part_apm_type(struct g_part_table *, struct g_part_entry *,
78     char *, size_t);
79 static int g_part_apm_write(struct g_part_table *, struct g_consumer *);
80 static int g_part_apm_resize(struct g_part_table *, struct g_part_entry *,
81     struct g_part_parms *);
82 
83 static kobj_method_t g_part_apm_methods[] = {
84 	KOBJMETHOD(g_part_add,		g_part_apm_add),
85 	KOBJMETHOD(g_part_create,	g_part_apm_create),
86 	KOBJMETHOD(g_part_destroy,	g_part_apm_destroy),
87 	KOBJMETHOD(g_part_dumpconf,	g_part_apm_dumpconf),
88 	KOBJMETHOD(g_part_dumpto,	g_part_apm_dumpto),
89 	KOBJMETHOD(g_part_modify,	g_part_apm_modify),
90 	KOBJMETHOD(g_part_resize,	g_part_apm_resize),
91 	KOBJMETHOD(g_part_name,		g_part_apm_name),
92 	KOBJMETHOD(g_part_probe,	g_part_apm_probe),
93 	KOBJMETHOD(g_part_read,		g_part_apm_read),
94 	KOBJMETHOD(g_part_type,		g_part_apm_type),
95 	KOBJMETHOD(g_part_write,	g_part_apm_write),
96 	{ 0, 0 }
97 };
98 
99 static struct g_part_scheme g_part_apm_scheme = {
100 	"APM",
101 	g_part_apm_methods,
102 	sizeof(struct g_part_apm_table),
103 	.gps_entrysz = sizeof(struct g_part_apm_entry),
104 	.gps_minent = 16,
105 	.gps_maxent = INT_MAX,
106 };
107 G_PART_SCHEME_DECLARE(g_part_apm);
108 
109 static void
110 swab(char *buf, size_t bufsz)
111 {
112 	int i;
113 	char ch;
114 
115 	for (i = 0; i < bufsz; i += 2) {
116 		ch = buf[i];
117 		buf[i] = buf[i + 1];
118 		buf[i + 1] = ch;
119 	}
120 }
121 
122 static int
123 apm_parse_type(const char *type, char *buf, size_t bufsz)
124 {
125 	const char *alias;
126 
127 	if (type[0] == '!') {
128 		type++;
129 		if (strlen(type) > bufsz)
130 			return (EINVAL);
131 		if (!strcmp(type, APM_ENT_TYPE_SELF) ||
132 		    !strcmp(type, APM_ENT_TYPE_UNUSED))
133 			return (EINVAL);
134 		strncpy(buf, type, bufsz);
135 		return (0);
136 	}
137 	alias = g_part_alias_name(G_PART_ALIAS_APPLE_BOOT);
138 	if (!strcasecmp(type, alias)) {
139 		strcpy(buf, APM_ENT_TYPE_APPLE_BOOT);
140 		return (0);
141 	}
142 	alias = g_part_alias_name(G_PART_ALIAS_APPLE_HFS);
143 	if (!strcasecmp(type, alias)) {
144 		strcpy(buf, APM_ENT_TYPE_APPLE_HFS);
145 		return (0);
146 	}
147 	alias = g_part_alias_name(G_PART_ALIAS_APPLE_UFS);
148 	if (!strcasecmp(type, alias)) {
149 		strcpy(buf, APM_ENT_TYPE_APPLE_UFS);
150 		return (0);
151 	}
152 	alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_BOOT);
153 	if (!strcasecmp(type, alias)) {
154 		strcpy(buf, APM_ENT_TYPE_APPLE_BOOT);
155 		return (0);
156 	}
157 	alias = g_part_alias_name(G_PART_ALIAS_FREEBSD);
158 	if (!strcasecmp(type, alias)) {
159 		strcpy(buf, APM_ENT_TYPE_FREEBSD);
160 		return (0);
161 	}
162 	alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_SWAP);
163 	if (!strcasecmp(type, alias)) {
164 		strcpy(buf, APM_ENT_TYPE_FREEBSD_SWAP);
165 		return (0);
166 	}
167 	alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_UFS);
168 	if (!strcasecmp(type, alias)) {
169 		strcpy(buf, APM_ENT_TYPE_FREEBSD_UFS);
170 		return (0);
171 	}
172 	alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_VINUM);
173 	if (!strcasecmp(type, alias)) {
174 		strcpy(buf, APM_ENT_TYPE_FREEBSD_VINUM);
175 		return (0);
176 	}
177 	alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_ZFS);
178 	if (!strcasecmp(type, alias)) {
179 		strcpy(buf, APM_ENT_TYPE_FREEBSD_ZFS);
180 		return (0);
181 	}
182 	return (EINVAL);
183 }
184 
185 static int
186 apm_read_ent(struct g_consumer *cp, uint32_t blk, struct apm_ent *ent,
187     int tivo_series1)
188 {
189 	struct g_provider *pp;
190 	char *buf;
191 	int error;
192 
193 	pp = cp->provider;
194 	buf = g_read_data(cp, pp->sectorsize * blk, pp->sectorsize, &error);
195 	if (buf == NULL)
196 		return (error);
197 	if (tivo_series1)
198 		swab(buf, pp->sectorsize);
199 	ent->ent_sig = be16dec(buf);
200 	ent->ent_pmblkcnt = be32dec(buf + 4);
201 	ent->ent_start = be32dec(buf + 8);
202 	ent->ent_size = be32dec(buf + 12);
203 	bcopy(buf + 16, ent->ent_name, sizeof(ent->ent_name));
204 	bcopy(buf + 48, ent->ent_type, sizeof(ent->ent_type));
205 	g_free(buf);
206 	return (0);
207 }
208 
209 static int
210 g_part_apm_add(struct g_part_table *basetable, struct g_part_entry *baseentry,
211     struct g_part_parms *gpp)
212 {
213 	struct g_part_apm_entry *entry;
214 	struct g_part_apm_table *table;
215 	int error;
216 
217 	entry = (struct g_part_apm_entry *)baseentry;
218 	table = (struct g_part_apm_table *)basetable;
219 	entry->ent.ent_sig = APM_ENT_SIG;
220 	entry->ent.ent_pmblkcnt = table->self.ent_pmblkcnt;
221 	entry->ent.ent_start = gpp->gpp_start;
222 	entry->ent.ent_size = gpp->gpp_size;
223 	if (baseentry->gpe_deleted) {
224 		bzero(entry->ent.ent_type, sizeof(entry->ent.ent_type));
225 		bzero(entry->ent.ent_name, sizeof(entry->ent.ent_name));
226 	}
227 	error = apm_parse_type(gpp->gpp_type, entry->ent.ent_type,
228 	    sizeof(entry->ent.ent_type));
229 	if (error)
230 		return (error);
231 	if (gpp->gpp_parms & G_PART_PARM_LABEL) {
232 		if (strlen(gpp->gpp_label) > sizeof(entry->ent.ent_name))
233 			return (EINVAL);
234 		strncpy(entry->ent.ent_name, gpp->gpp_label,
235 		    sizeof(entry->ent.ent_name));
236 	}
237 	if (baseentry->gpe_index >= table->self.ent_pmblkcnt)
238 		table->self.ent_pmblkcnt = baseentry->gpe_index + 1;
239 	KASSERT(table->self.ent_size >= table->self.ent_pmblkcnt,
240 	    ("%s", __func__));
241 	KASSERT(table->self.ent_size > baseentry->gpe_index,
242 	    ("%s", __func__));
243 	return (0);
244 }
245 
246 static int
247 g_part_apm_create(struct g_part_table *basetable, struct g_part_parms *gpp)
248 {
249 	struct g_provider *pp;
250 	struct g_part_apm_table *table;
251 	uint32_t last;
252 
253 	/* We don't nest, which means that our depth should be 0. */
254 	if (basetable->gpt_depth != 0)
255 		return (ENXIO);
256 
257 	table = (struct g_part_apm_table *)basetable;
258 	pp = gpp->gpp_provider;
259 	if (pp->sectorsize != 512 ||
260 	    pp->mediasize < (2 + 2 * basetable->gpt_entries) * pp->sectorsize)
261 		return (ENOSPC);
262 
263 	/* APM uses 32-bit LBAs. */
264 	last = MIN(pp->mediasize / pp->sectorsize, UINT32_MAX) - 1;
265 
266 	basetable->gpt_first = 2 + basetable->gpt_entries;
267 	basetable->gpt_last = last;
268 
269 	table->ddr.ddr_sig = APM_DDR_SIG;
270 	table->ddr.ddr_blksize = pp->sectorsize;
271 	table->ddr.ddr_blkcount = last + 1;
272 
273 	table->self.ent_sig = APM_ENT_SIG;
274 	table->self.ent_pmblkcnt = basetable->gpt_entries + 1;
275 	table->self.ent_start = 1;
276 	table->self.ent_size = table->self.ent_pmblkcnt;
277 	strcpy(table->self.ent_name, "Apple");
278 	strcpy(table->self.ent_type, APM_ENT_TYPE_SELF);
279 	return (0);
280 }
281 
282 static int
283 g_part_apm_destroy(struct g_part_table *basetable, struct g_part_parms *gpp)
284 {
285 
286 	/* Wipe the first 2 sectors to clear the partitioning. */
287 	basetable->gpt_smhead |= 3;
288 	return (0);
289 }
290 
291 static void
292 g_part_apm_dumpconf(struct g_part_table *table, struct g_part_entry *baseentry,
293     struct sbuf *sb, const char *indent)
294 {
295 	union {
296 		char name[APM_ENT_NAMELEN + 1];
297 		char type[APM_ENT_TYPELEN + 1];
298 	} u;
299 	struct g_part_apm_entry *entry;
300 
301 	entry = (struct g_part_apm_entry *)baseentry;
302 	if (indent == NULL) {
303 		/* conftxt: libdisk compatibility */
304 		sbuf_printf(sb, " xs APPLE xt %s", entry->ent.ent_type);
305 	} else if (entry != NULL) {
306 		/* confxml: partition entry information */
307 		strncpy(u.name, entry->ent.ent_name, APM_ENT_NAMELEN);
308 		u.name[APM_ENT_NAMELEN] = '\0';
309 		sbuf_printf(sb, "%s<label>%s</label>\n", indent, u.name);
310 		strncpy(u.type, entry->ent.ent_type, APM_ENT_TYPELEN);
311 		u.type[APM_ENT_TYPELEN] = '\0';
312 		sbuf_printf(sb, "%s<rawtype>%s</rawtype>\n", indent, u.type);
313 	} else {
314 		/* confxml: scheme information */
315 	}
316 }
317 
318 static int
319 g_part_apm_dumpto(struct g_part_table *table, struct g_part_entry *baseentry)
320 {
321 	struct g_part_apm_entry *entry;
322 
323 	entry = (struct g_part_apm_entry *)baseentry;
324 	return ((!strcmp(entry->ent.ent_type, APM_ENT_TYPE_FREEBSD_SWAP))
325 	    ? 1 : 0);
326 }
327 
328 static int
329 g_part_apm_modify(struct g_part_table *basetable,
330     struct g_part_entry *baseentry, struct g_part_parms *gpp)
331 {
332 	struct g_part_apm_entry *entry;
333 	int error;
334 
335 	entry = (struct g_part_apm_entry *)baseentry;
336 	if (gpp->gpp_parms & G_PART_PARM_LABEL) {
337 		if (strlen(gpp->gpp_label) > sizeof(entry->ent.ent_name))
338 			return (EINVAL);
339 	}
340 	if (gpp->gpp_parms & G_PART_PARM_TYPE) {
341 		error = apm_parse_type(gpp->gpp_type, entry->ent.ent_type,
342 		    sizeof(entry->ent.ent_type));
343 		if (error)
344 			return (error);
345 	}
346 	if (gpp->gpp_parms & G_PART_PARM_LABEL) {
347 		strncpy(entry->ent.ent_name, gpp->gpp_label,
348 		    sizeof(entry->ent.ent_name));
349 	}
350 	return (0);
351 }
352 
353 static int
354 g_part_apm_resize(struct g_part_table *basetable,
355     struct g_part_entry *baseentry, struct g_part_parms *gpp)
356 {
357 	struct g_part_apm_entry *entry;
358 
359 	entry = (struct g_part_apm_entry *)baseentry;
360 	baseentry->gpe_end = baseentry->gpe_start + gpp->gpp_size - 1;
361 	entry->ent.ent_size = gpp->gpp_size;
362 
363 	return (0);
364 }
365 
366 static const char *
367 g_part_apm_name(struct g_part_table *table, struct g_part_entry *baseentry,
368     char *buf, size_t bufsz)
369 {
370 
371 	snprintf(buf, bufsz, "s%d", baseentry->gpe_index + 1);
372 	return (buf);
373 }
374 
375 static int
376 g_part_apm_probe(struct g_part_table *basetable, struct g_consumer *cp)
377 {
378 	struct g_provider *pp;
379 	struct g_part_apm_table *table;
380 	char *buf;
381 	int error;
382 
383 	/* We don't nest, which means that our depth should be 0. */
384 	if (basetable->gpt_depth != 0)
385 		return (ENXIO);
386 
387 	table = (struct g_part_apm_table *)basetable;
388 	table->tivo_series1 = 0;
389 	pp = cp->provider;
390 
391 	/* Sanity-check the provider. */
392 	if (pp->mediasize < 4 * pp->sectorsize)
393 		return (ENOSPC);
394 
395 	/* Check that there's a Driver Descriptor Record (DDR). */
396 	buf = g_read_data(cp, 0L, pp->sectorsize, &error);
397 	if (buf == NULL)
398 		return (error);
399 	if (be16dec(buf) == APM_DDR_SIG) {
400 		/* Normal Apple DDR */
401 		table->ddr.ddr_sig = be16dec(buf);
402 		table->ddr.ddr_blksize = be16dec(buf + 2);
403 		table->ddr.ddr_blkcount = be32dec(buf + 4);
404 		g_free(buf);
405 		if (table->ddr.ddr_blksize != pp->sectorsize)
406 			return (ENXIO);
407 		if (table->ddr.ddr_blkcount > pp->mediasize / pp->sectorsize)
408 			return (ENXIO);
409 	} else {
410 		/*
411 		 * Check for Tivo drives, which have no DDR and a different
412 		 * signature.  Those whose first two bytes are 14 92 are
413 		 * Series 2 drives, and aren't supported.  Those that start
414 		 * with 92 14 are series 1 drives and are supported.
415 		 */
416 		if (be16dec(buf) != 0x9214) {
417 			/* If this is 0x1492 it could be a series 2 drive */
418 			g_free(buf);
419 			return (ENXIO);
420 		}
421 		table->ddr.ddr_sig = APM_DDR_SIG;		/* XXX */
422 		table->ddr.ddr_blksize = pp->sectorsize;	/* XXX */
423 		table->ddr.ddr_blkcount =
424 		    MIN(pp->mediasize / pp->sectorsize, UINT32_MAX);
425 		table->tivo_series1 = 1;
426 		g_free(buf);
427 	}
428 
429 	/* Check that there's a Partition Map. */
430 	error = apm_read_ent(cp, 1, &table->self, table->tivo_series1);
431 	if (error)
432 		return (error);
433 	if (table->self.ent_sig != APM_ENT_SIG)
434 		return (ENXIO);
435 	if (strcmp(table->self.ent_type, APM_ENT_TYPE_SELF))
436 		return (ENXIO);
437 	if (table->self.ent_pmblkcnt >= table->ddr.ddr_blkcount)
438 		return (ENXIO);
439 	return (G_PART_PROBE_PRI_NORM);
440 }
441 
442 static int
443 g_part_apm_read(struct g_part_table *basetable, struct g_consumer *cp)
444 {
445 	struct apm_ent ent;
446 	struct g_part_apm_entry *entry;
447 	struct g_part_apm_table *table;
448 	int error, index;
449 
450 	table = (struct g_part_apm_table *)basetable;
451 
452 	basetable->gpt_first = table->self.ent_size + 1;
453 	basetable->gpt_last = table->ddr.ddr_blkcount - 1;
454 	basetable->gpt_entries = table->self.ent_size - 1;
455 
456 	for (index = table->self.ent_pmblkcnt - 1; index > 0; index--) {
457 		error = apm_read_ent(cp, index + 1, &ent, table->tivo_series1);
458 		if (error)
459 			continue;
460 		if (!strcmp(ent.ent_type, APM_ENT_TYPE_UNUSED))
461 			continue;
462 		entry = (struct g_part_apm_entry *)g_part_new_entry(basetable,
463 		    index, ent.ent_start, ent.ent_start + ent.ent_size - 1);
464 		entry->ent = ent;
465 	}
466 
467 	return (0);
468 }
469 
470 static const char *
471 g_part_apm_type(struct g_part_table *basetable, struct g_part_entry *baseentry,
472     char *buf, size_t bufsz)
473 {
474 	struct g_part_apm_entry *entry;
475 	const char *type;
476 	size_t len;
477 
478 	entry = (struct g_part_apm_entry *)baseentry;
479 	type = entry->ent.ent_type;
480 	if (!strcmp(type, APM_ENT_TYPE_APPLE_BOOT))
481 		return (g_part_alias_name(G_PART_ALIAS_APPLE_BOOT));
482 	if (!strcmp(type, APM_ENT_TYPE_APPLE_HFS))
483 		return (g_part_alias_name(G_PART_ALIAS_APPLE_HFS));
484 	if (!strcmp(type, APM_ENT_TYPE_APPLE_UFS))
485 		return (g_part_alias_name(G_PART_ALIAS_APPLE_UFS));
486 	if (!strcmp(type, APM_ENT_TYPE_FREEBSD))
487 		return (g_part_alias_name(G_PART_ALIAS_FREEBSD));
488 	if (!strcmp(type, APM_ENT_TYPE_FREEBSD_SWAP))
489 		return (g_part_alias_name(G_PART_ALIAS_FREEBSD_SWAP));
490 	if (!strcmp(type, APM_ENT_TYPE_FREEBSD_UFS))
491 		return (g_part_alias_name(G_PART_ALIAS_FREEBSD_UFS));
492 	if (!strcmp(type, APM_ENT_TYPE_FREEBSD_VINUM))
493 		return (g_part_alias_name(G_PART_ALIAS_FREEBSD_VINUM));
494 	if (!strcmp(type, APM_ENT_TYPE_FREEBSD_ZFS))
495 		return (g_part_alias_name(G_PART_ALIAS_FREEBSD_ZFS));
496 	buf[0] = '!';
497 	len = MIN(sizeof(entry->ent.ent_type), bufsz - 2);
498 	bcopy(type, buf + 1, len);
499 	buf[len + 1] = '\0';
500 	return (buf);
501 }
502 
503 static int
504 g_part_apm_write(struct g_part_table *basetable, struct g_consumer *cp)
505 {
506 	struct g_provider *pp;
507 	struct g_part_entry *baseentry;
508 	struct g_part_apm_entry *entry;
509 	struct g_part_apm_table *table;
510 	char *buf, *ptr;
511 	uint32_t index;
512 	int error;
513 	size_t tblsz;
514 
515 	pp = cp->provider;
516 	table = (struct g_part_apm_table *)basetable;
517 	/*
518 	 * Tivo Series 1 disk partitions are currently read-only.
519 	 */
520 	if (table->tivo_series1)
521 		return (EOPNOTSUPP);
522 
523 	/* Write the DDR only when we're newly created. */
524 	if (basetable->gpt_created) {
525 		buf = g_malloc(pp->sectorsize, M_WAITOK | M_ZERO);
526 		be16enc(buf, table->ddr.ddr_sig);
527 		be16enc(buf + 2, table->ddr.ddr_blksize);
528 		be32enc(buf + 4, table->ddr.ddr_blkcount);
529 		error = g_write_data(cp, 0, buf, pp->sectorsize);
530 		g_free(buf);
531 		if (error)
532 			return (error);
533 	}
534 
535 	/* Allocate the buffer for all entries */
536 	tblsz = table->self.ent_pmblkcnt;
537 	buf = g_malloc(tblsz * pp->sectorsize, M_WAITOK | M_ZERO);
538 
539 	/* Fill the self entry */
540 	be16enc(buf, APM_ENT_SIG);
541 	be32enc(buf + 4, table->self.ent_pmblkcnt);
542 	be32enc(buf + 8, table->self.ent_start);
543 	be32enc(buf + 12, table->self.ent_size);
544 	bcopy(table->self.ent_name, buf + 16, sizeof(table->self.ent_name));
545 	bcopy(table->self.ent_type, buf + 48, sizeof(table->self.ent_type));
546 
547 	baseentry = LIST_FIRST(&basetable->gpt_entry);
548 	for (index = 1; index < tblsz; index++) {
549 		entry = (baseentry != NULL && index == baseentry->gpe_index)
550 		    ? (struct g_part_apm_entry *)baseentry : NULL;
551 		ptr = buf + index * pp->sectorsize;
552 		be16enc(ptr, APM_ENT_SIG);
553 		be32enc(ptr + 4, table->self.ent_pmblkcnt);
554 		if (entry != NULL && !baseentry->gpe_deleted) {
555 			be32enc(ptr + 8, entry->ent.ent_start);
556 			be32enc(ptr + 12, entry->ent.ent_size);
557 			bcopy(entry->ent.ent_name, ptr + 16,
558 			    sizeof(entry->ent.ent_name));
559 			bcopy(entry->ent.ent_type, ptr + 48,
560 			    sizeof(entry->ent.ent_type));
561 		} else {
562 			strcpy(ptr + 48, APM_ENT_TYPE_UNUSED);
563 		}
564 		if (entry != NULL)
565 			baseentry = LIST_NEXT(baseentry, gpe_entry);
566 	}
567 
568 	for (index = 0; index < tblsz; index += MAXPHYS / pp->sectorsize) {
569 		error = g_write_data(cp, (1 + index) * pp->sectorsize,
570 		    buf + index * pp->sectorsize,
571 		    (tblsz - index > MAXPHYS / pp->sectorsize) ? MAXPHYS:
572 		    (tblsz - index) * pp->sectorsize);
573 		if (error) {
574 			g_free(buf);
575 			return (error);
576 		}
577 	}
578 	g_free(buf);
579 	return (0);
580 }
581