[BACK]Return to show.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sbin / gpt

Annotation of src/sbin/gpt/show.c, Revision 1.7.8.1

1.1       christos    1: /*-
                      2:  * Copyright (c) 2002 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>
1.2       christos   28: #ifdef __FBSDID
1.1       christos   29: __FBSDID("$FreeBSD: src/sbin/gpt/show.c,v 1.14 2006/06/22 22:22:32 marcel Exp $");
1.2       christos   30: #endif
                     31: #ifdef __RCSID
1.7.8.1 ! tls        32: __RCSID("$NetBSD: show.c,v 1.7 2011/08/27 17:38:16 joerg Exp $");
1.2       christos   33: #endif
1.1       christos   34:
                     35: #include <sys/types.h>
                     36:
                     37: #include <err.h>
                     38: #include <stddef.h>
                     39: #include <stdio.h>
                     40: #include <stdlib.h>
                     41: #include <string.h>
                     42: #include <unistd.h>
                     43:
                     44: #include "map.h"
                     45: #include "gpt.h"
                     46:
                     47: static int show_label = 0;
                     48: static int show_uuid = 0;
                     49:
1.3       riz        50: const char showmsg[] = "show [-lu] device ...";
                     51:
1.7       joerg      52: __dead static void
1.1       christos   53: usage_show(void)
                     54: {
                     55:
                     56:        fprintf(stderr,
1.3       riz        57:            "usage: %s %s\n", getprogname(), showmsg);
1.1       christos   58:        exit(1);
                     59: }
                     60:
                     61: static const char *
                     62: friendly(uuid_t *t)
                     63: {
                     64:        static uuid_t efi_slice = GPT_ENT_TYPE_EFI;
1.5       christos   65:        static uuid_t bios_boot = GPT_ENT_TYPE_BIOS;
1.7.8.1 ! tls        66:        static uuid_t msdata = GPT_ENT_TYPE_MS_BASIC_DATA;
1.1       christos   67:        static uuid_t freebsd = GPT_ENT_TYPE_FREEBSD;
                     68:        static uuid_t hfs = GPT_ENT_TYPE_APPLE_HFS;
1.7.8.1 ! tls        69:        static uuid_t linuxdata = GPT_ENT_TYPE_LINUX_DATA;
1.1       christos   70:        static uuid_t linuxswap = GPT_ENT_TYPE_LINUX_SWAP;
                     71:        static uuid_t msr = GPT_ENT_TYPE_MS_RESERVED;
                     72:        static uuid_t swap = GPT_ENT_TYPE_FREEBSD_SWAP;
                     73:        static uuid_t ufs = GPT_ENT_TYPE_FREEBSD_UFS;
                     74:        static uuid_t vinum = GPT_ENT_TYPE_FREEBSD_VINUM;
1.4       riz        75:        static uuid_t nb_swap = GPT_ENT_TYPE_NETBSD_SWAP;
1.6       jakllsch   76:        static uuid_t nb_ffs = GPT_ENT_TYPE_NETBSD_FFS;
1.4       riz        77:        static uuid_t nb_lfs = GPT_ENT_TYPE_NETBSD_LFS;
                     78:        static uuid_t nb_raid = GPT_ENT_TYPE_NETBSD_RAIDFRAME;
                     79:        static uuid_t nb_ccd = GPT_ENT_TYPE_NETBSD_CCD;
                     80:        static uuid_t nb_cgd = GPT_ENT_TYPE_NETBSD_CGD;
1.1       christos   81:        static char buf[80];
                     82:        char *s;
                     83:
                     84:        if (show_uuid)
                     85:                goto unfriendly;
                     86:
                     87:        if (uuid_equal(t, &efi_slice, NULL))
                     88:                return ("EFI System");
1.5       christos   89:        if (uuid_equal(t, &bios_boot, NULL))
                     90:                return ("BIOS Boot");
1.4       riz        91:        if (uuid_equal(t, &nb_swap, NULL))
                     92:                return ("NetBSD swap");
1.6       jakllsch   93:        if (uuid_equal(t, &nb_ffs, NULL))
                     94:                return ("NetBSD FFSv1/FFSv2");
1.4       riz        95:        if (uuid_equal(t, &nb_lfs, NULL))
                     96:                return ("NetBSD LFS");
                     97:        if (uuid_equal(t, &nb_raid, NULL))
                     98:                return ("NetBSD RAIDFrame component");
                     99:        if (uuid_equal(t, &nb_ccd, NULL))
                    100:                return ("NetBSD ccd component");
                    101:        if (uuid_equal(t, &nb_cgd, NULL))
                    102:                return ("NetBSD Cryptographic Disk");
1.1       christos  103:        if (uuid_equal(t, &swap, NULL))
                    104:                return ("FreeBSD swap");
                    105:        if (uuid_equal(t, &ufs, NULL))
                    106:                return ("FreeBSD UFS/UFS2");
                    107:        if (uuid_equal(t, &vinum, NULL))
                    108:                return ("FreeBSD vinum");
                    109:
                    110:        if (uuid_equal(t, &freebsd, NULL))
                    111:                return ("FreeBSD legacy");
1.7.8.1 ! tls       112:        if (uuid_equal(t, &msdata, NULL))
        !           113:                return ("Windows basic data");
1.1       christos  114:        if (uuid_equal(t, &msr, NULL))
                    115:                return ("Windows reserved");
1.7.8.1 ! tls       116:        if (uuid_equal(t, &linuxdata, NULL))
        !           117:                return ("Linux data");
        !           118:        if (uuid_equal(t, &linuxswap, NULL))
        !           119:                return ("Linux swap");
1.1       christos  120:        if (uuid_equal(t, &hfs, NULL))
                    121:                return ("Apple HFS");
                    122:
                    123: unfriendly:
                    124:        uuid_to_string(t, &s, NULL);
                    125:        strlcpy(buf, s, sizeof buf);
                    126:        free(s);
                    127:        return (buf);
                    128: }
                    129:
                    130: static void
                    131: show(int fd __unused)
                    132: {
                    133:        uuid_t type;
                    134:        off_t start;
                    135:        map_t *m, *p;
                    136:        struct mbr *mbr;
                    137:        struct gpt_ent *ent;
                    138:        unsigned int i;
                    139:
                    140:        printf("  %*s", lbawidth, "start");
                    141:        printf("  %*s", lbawidth, "size");
                    142:        printf("  index  contents\n");
                    143:
                    144:        m = map_first();
                    145:        while (m != NULL) {
                    146:                printf("  %*llu", lbawidth, (long long)m->map_start);
                    147:                printf("  %*llu", lbawidth, (long long)m->map_size);
                    148:                putchar(' ');
                    149:                putchar(' ');
                    150:                if (m->map_index > 0)
                    151:                        printf("%5d", m->map_index);
                    152:                else
                    153:                        printf("     ");
                    154:                putchar(' ');
                    155:                putchar(' ');
                    156:                switch (m->map_type) {
                    157:                case MAP_TYPE_MBR:
                    158:                        if (m->map_start != 0)
                    159:                                printf("Extended ");
                    160:                        printf("MBR");
                    161:                        break;
                    162:                case MAP_TYPE_PRI_GPT_HDR:
                    163:                        printf("Pri GPT header");
                    164:                        break;
                    165:                case MAP_TYPE_SEC_GPT_HDR:
                    166:                        printf("Sec GPT header");
                    167:                        break;
                    168:                case MAP_TYPE_PRI_GPT_TBL:
                    169:                        printf("Pri GPT table");
                    170:                        break;
                    171:                case MAP_TYPE_SEC_GPT_TBL:
                    172:                        printf("Sec GPT table");
                    173:                        break;
                    174:                case MAP_TYPE_MBR_PART:
                    175:                        p = m->map_data;
                    176:                        if (p->map_start != 0)
                    177:                                printf("Extended ");
                    178:                        printf("MBR part ");
                    179:                        mbr = p->map_data;
                    180:                        for (i = 0; i < 4; i++) {
                    181:                                start = le16toh(mbr->mbr_part[i].part_start_hi);
                    182:                                start = (start << 16) +
                    183:                                    le16toh(mbr->mbr_part[i].part_start_lo);
                    184:                                if (m->map_start == p->map_start + start)
                    185:                                        break;
                    186:                        }
                    187:                        printf("%d", mbr->mbr_part[i].part_typ);
                    188:                        break;
                    189:                case MAP_TYPE_GPT_PART:
                    190:                        printf("GPT part ");
                    191:                        ent = m->map_data;
                    192:                        if (show_label) {
                    193:                                printf("- \"%s\"",
                    194:                                    utf16_to_utf8(ent->ent_name));
                    195:                        } else {
                    196:                                le_uuid_dec(&ent->ent_type, &type);
                    197:                                printf("- %s", friendly(&type));
                    198:                        }
                    199:                        break;
                    200:                case MAP_TYPE_PMBR:
                    201:                        printf("PMBR");
                    202:                        break;
                    203:                }
                    204:                putchar('\n');
                    205:                m = m->map_next;
                    206:        }
                    207: }
                    208:
                    209: int
                    210: cmd_show(int argc, char *argv[])
                    211: {
                    212:        int ch, fd;
                    213:
                    214:        while ((ch = getopt(argc, argv, "lu")) != -1) {
                    215:                switch(ch) {
                    216:                case 'l':
                    217:                        show_label = 1;
                    218:                        break;
                    219:                case 'u':
                    220:                        show_uuid = 1;
                    221:                        break;
                    222:                default:
                    223:                        usage_show();
                    224:                }
                    225:        }
                    226:
                    227:        if (argc == optind)
                    228:                usage_show();
                    229:
                    230:        while (optind < argc) {
                    231:                fd = gpt_open(argv[optind++]);
                    232:                if (fd == -1) {
                    233:                        warn("unable to open device '%s'", device_name);
                    234:                        continue;
                    235:                }
                    236:
                    237:                show(fd);
                    238:
                    239:                gpt_close(fd);
                    240:        }
                    241:
                    242:        return (0);
                    243: }

CVSweb <webmaster@jp.NetBSD.org>