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

FreeBSD/Linux Kernel Cross Reference
sys/geom/part/g_part_vtoc8.c
