Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/geom/part/g_part_vtoc8.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 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: releng/8.0/sys/geom/part/g_part_vtoc8.c 188429 2009-02-10 02:43:07Z imp $"); 29 30 #include <sys/param.h> 31 #include <sys/bio.h> 32 #include <sys/endian.h> 33 #include <sys/kernel.h> 34 #include <sys/kobj.h> 35 #include <sys/limits.h> 36 #include <sys/lock.h> 37 #include <sys/malloc.h> 38 #include <sys/mutex.h> 39 #include <sys/queue.h> 40 #include <sys/sbuf.h> 41 #include <sys/systm.h> 42 #include <sys/vtoc.h> 43 #include <geom/geom.h> 44 #include <geom/part/g_part.h> 45 46 #include "g_part_if.h" 47 48 struct g_part_vtoc8_table { 49 struct g_part_table base; 50 struct vtoc8 vtoc; 51 uint32_t secpercyl; 52 }; 53 54 static int g_part_vtoc8_add(struct g_part_table *, struct g_part_entry *, 55 struct g_part_parms *); 56 static int g_part_vtoc8_create(struct g_part_table *, struct g_part_parms *); 57 static int g_part_vtoc8_destroy(struct g_part_table *, struct g_part_parms *); 58 static void g_part_vtoc8_dumpconf(struct g_part_table *, struct g_part_entry *, 59 struct sbuf *, const char *); 60 static int g_part_vtoc8_dumpto(struct g_part_table *, struct g_part_entry *); 61 static int g_part_vtoc8_modify(struct g_part_table *, struct g_part_entry *, 62 struct g_part_parms *); 63 static const char *g_part_vtoc8_name(struct g_part_table *, struct g_part_entry *, 64 char *, size_t); 65 static int g_part_vtoc8_probe(struct g_part_table *, struct g_consumer *); 66 static int g_part_vtoc8_read(struct g_part_table *, struct g_consumer *); 67 static const char *g_part_vtoc8_type(struct g_part_table *, struct g_part_entry *, 68 char *, size_t); 69 static int g_part_vtoc8_write(struct g_part_table *, struct g_consumer *); 70 71 static kobj_method_t g_part_vtoc8_methods[] = { 72 KOBJMETHOD(g_part_add, g_part_vtoc8_add), 73 KOBJMETHOD(g_part_create, g_part_vtoc8_create), 74 KOBJMETHOD(g_part_destroy, g_part_vtoc8_destroy), 75 KOBJMETHOD(g_part_dumpconf, g_part_vtoc8_dumpconf), 76 KOBJMETHOD(g_part_dumpto, g_part_vtoc8_dumpto), 77 KOBJMETHOD(g_part_modify, g_part_vtoc8_modify), 78 KOBJMETHOD(g_part_name, g_part_vtoc8_name), 79 KOBJMETHOD(g_part_probe, g_part_vtoc8_probe), 80 KOBJMETHOD(g_part_read, g_part_vtoc8_read), 81 KOBJMETHOD(g_part_type, g_part_vtoc8_type), 82 KOBJMETHOD(g_part_write, g_part_vtoc8_write), 83 { 0, 0 } 84 }; 85 86 static struct g_part_scheme g_part_vtoc8_scheme = { 87 "VTOC8", 88 g_part_vtoc8_methods, 89 sizeof(struct g_part_vtoc8_table), 90 .gps_entrysz = sizeof(struct g_part_entry), 91 .gps_minent = VTOC8_NPARTS, 92 .gps_maxent = VTOC8_NPARTS, 93 }; 94 G_PART_SCHEME_DECLARE(g_part_vtoc8); 95 96 static int 97 vtoc8_parse_type(const char *type, uint16_t *tag) 98 { 99 const char *alias; 100 char *endp; 101 long lt; 102 103 if (type[0] == '!') { 104 lt = strtol(type + 1, &endp, 0); 105 if (type[1] == '\0' || *endp != '\0' || lt <= 0 || 106 lt >= 65536) 107 return (EINVAL); 108 *tag = (uint16_t)lt; 109 return (0); 110 } 111 alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_SWAP); 112 if (!strcasecmp(type, alias)) { 113 *tag = VTOC_TAG_FREEBSD_SWAP; 114 return (0); 115 } 116 alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_UFS); 117 if (!strcasecmp(type, alias)) { 118 *tag = VTOC_TAG_FREEBSD_UFS; 119 return (0); 120 } 121 alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_VINUM); 122 if (!strcasecmp(type, alias)) { 123 *tag = VTOC_TAG_FREEBSD_VINUM; 124 return (0); 125 } 126 alias = g_part_alias_name(G_PART_ALIAS_FREEBSD_ZFS); 127 if (!strcasecmp(type, alias)) { 128 *tag = VTOC_TAG_FREEBSD_ZFS; 129 return (0); 130 } 131 return (EINVAL); 132 } 133 134 static int 135 g_part_vtoc8_add(struct g_part_table *basetable, struct g_part_entry *entry, 136 struct g_part_parms *gpp) 137 { 138 struct g_part_vtoc8_table *table; 139 int error, index; 140 uint64_t start, size; 141 uint16_t tag; 142 143 if (gpp->gpp_parms & G_PART_PARM_LABEL) 144 return (EINVAL); 145 146 error = vtoc8_parse_type(gpp->gpp_type, &tag); 147 if (error) 148 return (error); 149 150 table = (struct g_part_vtoc8_table *)basetable; 151 index = entry->gpe_index - 1; 152 153 start = gpp->gpp_start; 154 size = gpp->gpp_size; 155 if (start % table->secpercyl) { 156 size = size - table->secpercyl + (start % table->secpercyl); 157 start = start - (start % table->secpercyl) + table->secpercyl; 158 } 159 if (size % table->secpercyl) 160 size = size - (size % table->secpercyl); 161 if (size < table->secpercyl) 162 return (EINVAL); 163 164 KASSERT(entry->gpe_start <= start, (__func__)); 165 KASSERT(entry->gpe_end >= start + size - 1, (__func__)); 166 entry->gpe_start = start; 167 entry->gpe_end = start + size - 1; 168 169 be16enc(&table->vtoc.part[index].tag, tag); 170 be16enc(&table->vtoc.part[index].flag, 0); 171 be32enc(&table->vtoc.timestamp[index], 0); 172 be32enc(&table->vtoc.map[index].cyl, start / table->secpercyl); 173 be32enc(&table->vtoc.map[index].nblks, size); 174 return (0); 175 } 176 177 static int 178 g_part_vtoc8_create(struct g_part_table *basetable, struct g_part_parms *gpp) 179 { 180 struct g_consumer *cp; 181 struct g_provider *pp; 182 struct g_part_entry *entry; 183 struct g_part_vtoc8_table *table; 184 uint64_t msize; 185 uint32_t acyls, ncyls, pcyls; 186 187 pp = gpp->gpp_provider; 188 cp = LIST_FIRST(&pp->consumers); 189 190 if (pp->sectorsize < sizeof(struct vtoc8)) 191 return (ENOSPC); 192 if (pp->sectorsize > sizeof(struct vtoc8)) 193 return (ENXIO); 194 195 table = (struct g_part_vtoc8_table *)basetable; 196 197 msize = pp->mediasize / pp->sectorsize; 198 if (msize > 0xffffffffu) 199 msize = 0xffffffffu; 200 table->secpercyl = basetable->gpt_sectors * basetable->gpt_heads; 201 pcyls = msize / table->secpercyl; 202 acyls = 2; 203 ncyls = pcyls - acyls; 204 msize = ncyls * table->secpercyl; 205 206 sprintf(table->vtoc.ascii, "FreeBSD%lldM cyl %u alt %u hd %u sec %u", 207 (long long)(msize / 2048), ncyls, acyls, basetable->gpt_heads, 208 basetable->gpt_sectors); 209 be32enc(&table->vtoc.version, VTOC_VERSION); 210 be16enc(&table->vtoc.nparts, VTOC8_NPARTS); 211 be32enc(&table->vtoc.sanity, VTOC_SANITY); 212 be16enc(&table->vtoc.rpm, 3600); 213 be16enc(&table->vtoc.physcyls, pcyls); 214 be16enc(&table->vtoc.ncyls, ncyls); 215 be16enc(&table->vtoc.altcyls, acyls); 216 be16enc(&table->vtoc.nheads, basetable->gpt_heads); 217 be16enc(&table->vtoc.nsecs, basetable->gpt_sectors); 218 be16enc(&table->vtoc.magic, VTOC_MAGIC); 219 220 basetable->gpt_first = 0; 221 basetable->gpt_last = msize - 1; 222 basetable->gpt_isleaf = 1; 223 224 entry = g_part_new_entry(basetable, VTOC_RAW_PART + 1, 225 basetable->gpt_first, basetable->gpt_last); 226 entry->gpe_internal = 1; 227 be16enc(&table->vtoc.part[VTOC_RAW_PART].tag, VTOC_TAG_BACKUP); 228 be32enc(&table->vtoc.map[VTOC_RAW_PART].nblks, msize); 229 return (0); 230 } 231 232 static int 233 g_part_vtoc8_destroy(struct g_part_table *basetable, struct g_part_parms *gpp) 234 { 235 236 /* Wipe the first sector to clear the partitioning. */ 237 basetable->gpt_smhead |= 1; 238 return (0); 239 } 240 241 static void 242 g_part_vtoc8_dumpconf(struct g_part_table *basetable, 243 struct g_part_entry *entry, struct sbuf *sb, const char *indent) 244 { 245 struct g_part_vtoc8_table *table; 246 247 table = (struct g_part_vtoc8_table *)basetable; 248 if (indent == NULL) { 249 /* conftxt: libdisk compatibility */ 250 sbuf_printf(sb, " xs SUN sc %u hd %u alt %u", 251 be16dec(&table->vtoc.nsecs), be16dec(&table->vtoc.nheads), 252 be16dec(&table->vtoc.altcyls)); 253 } else if (entry != NULL) { 254 /* confxml: partition entry information */ 255 sbuf_printf(sb, "%s<rawtype>%u</rawtype>\n", indent, 256 be16dec(&table->vtoc.part[entry->gpe_index - 1].tag)); 257 } else { 258 /* confxml: scheme information */ 259 } 260 } 261 262 static int 263 g_part_vtoc8_dumpto(struct g_part_table *basetable, struct g_part_entry *entry) 264 { 265 struct g_part_vtoc8_table *table; 266 uint16_t tag; 267 268 /* 269 * Allow dumping to a swap partition or a partition that 270 * has no type. 271 */ 272 table = (struct g_part_vtoc8_table *)basetable; 273 tag = be16dec(&table->vtoc.part[entry->gpe_index - 1].tag); 274 return ((tag == 0 || tag == VTOC_TAG_FREEBSD_SWAP) ? 1 : 0); 275 } 276 277 static int 278 g_part_vtoc8_modify(struct g_part_table *basetable, 279 struct g_part_entry *entry, struct g_part_parms *gpp) 280 { 281 struct g_part_vtoc8_table *table; 282 int error; 283 uint16_t tag; 284 285 if (gpp->gpp_parms & G_PART_PARM_LABEL) 286 return (EINVAL); 287 288 table = (struct g_part_vtoc8_table *)basetable; 289 if (gpp->gpp_parms & G_PART_PARM_TYPE) { 290 error = vtoc8_parse_type(gpp->gpp_type, &tag); 291 if (error) 292 return(error); 293 294 be16enc(&table->vtoc.part[entry->gpe_index - 1].tag, tag); 295 } 296 return (0); 297 } 298 299 static const char * 300 g_part_vtoc8_name(struct g_part_table *table, struct g_part_entry *baseentry, 301 char *buf, size_t bufsz) 302 { 303 304 snprintf(buf, bufsz, "%c", 'a' + baseentry->gpe_index - 1); 305 return (buf); 306 } 307 308 static int 309 g_part_vtoc8_probe(struct g_part_table *table, struct g_consumer *cp) 310 { 311 struct g_provider *pp; 312 u_char *buf; 313 int error, ofs, res; 314 uint16_t cksum, magic; 315 316 pp = cp->provider; 317 318 /* Sanity-check the provider. */ 319 if (pp->sectorsize != sizeof(struct vtoc8)) 320 return (ENOSPC); 321 322 /* Check that there's a disklabel. */ 323 buf = g_read_data(cp, 0, pp->sectorsize, &error); 324 if (buf == NULL) 325 return (error); 326 327 res = ENXIO; /* Assume mismatch */ 328 329 /* Check the magic */ 330 magic = be16dec(buf + offsetof(struct vtoc8, magic)); 331 if (magic != VTOC_MAGIC) 332 goto out; 333 334 /* Check the sum */ 335 cksum = 0; 336 for (ofs = 0; ofs < sizeof(struct vtoc8); ofs += 2) 337 cksum ^= be16dec(buf + ofs); 338 if (cksum != 0) 339 goto out; 340 341 res = G_PART_PROBE_PRI_NORM; 342 343 out: 344 g_free(buf); 345 return (res); 346 } 347 348 static int 349 g_part_vtoc8_read(struct g_part_table *basetable, struct g_consumer *cp) 350 { 351 struct g_provider *pp; 352 struct g_part_vtoc8_table *table; 353 struct g_part_entry *entry; 354 u_char *buf; 355 off_t chs, msize; 356 uint64_t offset, size; 357 u_int cyls, heads, sectors; 358 int error, index, withtags; 359 uint16_t tag; 360 361 pp = cp->provider; 362 buf = g_read_data(cp, 0, pp->sectorsize, &error); 363 if (buf == NULL) 364 return (error); 365 366 table = (struct g_part_vtoc8_table *)basetable; 367 bcopy(buf, &table->vtoc, sizeof(table->vtoc)); 368 g_free(buf); 369 370 msize = pp->mediasize / pp->sectorsize; 371 372 sectors = be16dec(&table->vtoc.nsecs); 373 if (sectors < 1) 374 goto invalid_label; 375 if (sectors != basetable->gpt_sectors && !basetable->gpt_fixgeom) { 376 g_part_geometry_heads(msize, sectors, &chs, &heads); 377 if (chs != 0) { 378 basetable->gpt_sectors = sectors; 379 basetable->gpt_heads = heads; 380 } 381 } 382 383 heads = be16dec(&table->vtoc.nheads); 384 if (heads < 1) 385 goto invalid_label; 386 if (heads != basetable->gpt_heads && !basetable->gpt_fixgeom) 387 basetable->gpt_heads = heads; 388 /* 389 * Except for ATA disks > 32GB, Solaris uses the native geometry 390 * as reported by the target for the labels while da(4) typically 391 * uses a synthetic one so we don't complain too loudly if these 392 * geometries don't match. 393 */ 394 if (bootverbose && (sectors != basetable->gpt_sectors || 395 heads != basetable->gpt_heads)) 396 printf("GEOM: %s: geometry does not match VTOC8 label " 397 "(label: %uh,%us GEOM: %uh,%us).\n", pp->name, heads, 398 sectors, basetable->gpt_heads, basetable->gpt_sectors); 399 400 table->secpercyl = heads * sectors; 401 cyls = be16dec(&table->vtoc.ncyls); 402 chs = cyls * table->secpercyl; 403 if (chs < 1 || chs > msize) 404 goto invalid_label; 405 406 basetable->gpt_first = 0; 407 basetable->gpt_last = chs - 1; 408 basetable->gpt_isleaf = 1; 409 410 withtags = (be32dec(&table->vtoc.sanity) == VTOC_SANITY) ? 1 : 0; 411 if (!withtags) { 412 printf("GEOM: %s: adding VTOC8 information.\n", pp->name); 413 be32enc(&table->vtoc.version, VTOC_VERSION); 414 bzero(&table->vtoc.volume, VTOC_VOLUME_LEN); 415 be16enc(&table->vtoc.nparts, VTOC8_NPARTS); 416 bzero(&table->vtoc.part, sizeof(table->vtoc.part)); 417 be32enc(&table->vtoc.sanity, VTOC_SANITY); 418 } 419 420 basetable->gpt_entries = be16dec(&table->vtoc.nparts); 421 if (basetable->gpt_entries < g_part_vtoc8_scheme.gps_minent || 422 basetable->gpt_entries > g_part_vtoc8_scheme.gps_maxent) 423 goto invalid_label; 424 425 for (index = basetable->gpt_entries - 1; index >= 0; index--) { 426 offset = be32dec(&table->vtoc.map[index].cyl) * 427 table->secpercyl; 428 size = be32dec(&table->vtoc.map[index].nblks); 429 if (size == 0) 430 continue; 431 if (withtags) 432 tag = be16dec(&table->vtoc.part[index].tag); 433 else 434 tag = (index == VTOC_RAW_PART) 435 ? VTOC_TAG_BACKUP 436 : VTOC_TAG_UNASSIGNED; 437 438 if (index == VTOC_RAW_PART && tag != VTOC_TAG_BACKUP) 439 continue; 440 if (index != VTOC_RAW_PART && tag == VTOC_TAG_BACKUP) 441 continue; 442 entry = g_part_new_entry(basetable, index + 1, offset, 443 offset + size - 1); 444 if (tag == VTOC_TAG_BACKUP) 445 entry->gpe_internal = 1; 446 447 if (!withtags) 448 be16enc(&table->vtoc.part[index].tag, tag); 449 } 450 451 return (0); 452 453 invalid_label: 454 printf("GEOM: %s: invalid VTOC8 label.\n", pp->name); 455 return (EINVAL); 456 } 457 458 static const char * 459 g_part_vtoc8_type(struct g_part_table *basetable, struct g_part_entry *entry, 460 char *buf, size_t bufsz) 461 { 462 struct g_part_vtoc8_table *table; 463 uint16_t tag; 464 465 table = (struct g_part_vtoc8_table *)basetable; 466 tag = be16dec(&table->vtoc.part[entry->gpe_index - 1].tag); 467 if (tag == VTOC_TAG_FREEBSD_SWAP) 468 return (g_part_alias_name(G_PART_ALIAS_FREEBSD_SWAP)); 469 if (tag == VTOC_TAG_FREEBSD_UFS) 470 return (g_part_alias_name(G_PART_ALIAS_FREEBSD_UFS)); 471 if (tag == VTOC_TAG_FREEBSD_VINUM) 472 return (g_part_alias_name(G_PART_ALIAS_FREEBSD_VINUM)); 473 if (tag == VTOC_TAG_FREEBSD_ZFS) 474 return (g_part_alias_name(G_PART_ALIAS_FREEBSD_ZFS)); 475 snprintf(buf, bufsz, "!%d", tag); 476 return (buf); 477 } 478 479 static int 480 g_part_vtoc8_write(struct g_part_table *basetable, struct g_consumer *cp) 481 { 482 struct g_provider *pp; 483 struct g_part_entry *entry; 484 struct g_part_vtoc8_table *table; 485 uint16_t sum; 486 u_char *p; 487 int error, index, match, offset; 488 489 pp = cp->provider; 490 table = (struct g_part_vtoc8_table *)basetable; 491 entry = LIST_FIRST(&basetable->gpt_entry); 492 for (index = 0; index < basetable->gpt_entries; index++) { 493 match = (entry != NULL && index == entry->gpe_index - 1) 494 ? 1 : 0; 495 if (match) { 496 if (entry->gpe_deleted) { 497 be16enc(&table->vtoc.part[index].tag, 0); 498 be16enc(&table->vtoc.part[index].flag, 0); 499 be32enc(&table->vtoc.map[index].cyl, 0); 500 be32enc(&table->vtoc.map[index].nblks, 0); 501 } 502 entry = LIST_NEXT(entry, gpe_entry); 503 } 504 } 505 506 /* Calculate checksum. */ 507 sum = 0; 508 p = (void *)&table->vtoc; 509 for (offset = 0; offset < sizeof(table->vtoc) - 2; offset += 2) 510 sum ^= be16dec(p + offset); 511 be16enc(&table->vtoc.cksum, sum); 512 513 error = g_write_data(cp, 0, p, pp->sectorsize); 514 return (error); 515 }
Cache object: a871d444ae6867092b5dc627d449ce83
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]