← Back to branch summary

~ubuntu-branches/ubuntu/trusty/util-linux/trusty-proposed

« back to all changes in this revision

Viewing changes to shlibs/blkid/src/partitions/mac.c

  • Committer: Package Import Robot
  • Author(s): LaMont Jones
  • Date: 2011-11-03 15:38:23 UTC
  • mto: (4.5.5 sid) (1.6.4)
  • mto: This revision was merged to the branch mainline in revision 85.
  • Revision ID: package-import@ubuntu.com-20111103153823-10sx16jprzxlhkqf
Import upstream version 2.20.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
shlibs/blkid/src/partitions/mac.c
1
 
/*
2
 
 * mac partitions parsing code
3
 
 *
4
 
 * Copyright (C) 2009 Karel Zak <kzak@redhat.com>
5
 
 *
6
 
 * This file may be redistributed under the terms of the
7
 
 * GNU Lesser General Public License.
8
 
 *
9
 
 */
10
 
#include <stdio.h>
11
 
#include <string.h>
12
 
#include <stdlib.h>
13
 
#include <stdint.h>
14
 
 
15
 
#include "partitions.h"
16
 
 
17
 
#define MAC_PARTITION_MAGIC             0x504d
18
 
#define MAC_PARTITION_MAGIC_OLD         0x5453
19
 
 
20
 
/*
21
 
 * Mac partition entry
22
 
 * http://developer.apple.com/legacy/mac/library/documentation/mac/Devices/Devices-126.html
23
 
 */
24
 
struct mac_partition {
25
 
        uint16_t        signature;      /* expected to be MAC_PARTITION_MAGIC */
26
 
        uint16_t        reserved;       /* reserved */
27
 
        uint32_t        map_count;      /* # blocks in partition map */
28
 
        uint32_t        start_block;    /* absolute starting block # of partition */
29
 
        uint32_t        block_count;    /* number of blocks in partition */
30
 
        char            name[32];       /* partition name */
31
 
        char            type[32];       /* string type description */
32
 
        uint32_t        data_start;     /* rel block # of first data block */
33
 
        uint32_t        data_count;     /* number of data blocks */
34
 
        uint32_t        status;         /* partition status bits */
35
 
        uint32_t        boot_start;     /* first logical block of boot code */
36
 
        uint32_t        boot_size;      /* size of boot code, in bytes */
37
 
        uint32_t        boot_load;      /* boot code load address */
38
 
        uint32_t        boot_load2;     /* reserved */
39
 
        uint32_t        boot_entry;     /* boot code entry point */
40
 
        uint32_t        boot_entry2;    /* reserved */
41
 
        uint32_t        boot_cksum;     /* boot code checksum */
42
 
        char            processor[16];  /* identifies ISA of boot */
43
 
 
44
 
        /* there is more stuff after this that we don't need */
45
 
} __attribute__((packed));
46
 
 
47
 
/*
48
 
 * Driver descriptor structure, in block 0
49
 
 * http://developer.apple.com/legacy/mac/library/documentation/mac/Devices/Devices-121.html
50
 
 */
51
 
struct mac_driver_desc {
52
 
        uint16_t        signature;      /* expected to be MAC_DRIVER_MAGIC */
53
 
        uint16_t        block_size;     /* block size of the device */
54
 
        uint32_t        block_count;    /* number of blocks on the device */
55
 
 
56
 
        /* there is more stuff after this that we don't need */
57
 
} __attribute__((packed));
58
 
 
59
 
static inline unsigned char *get_mac_block(
60
 
                                        blkid_probe pr,
61
 
                                        struct mac_driver_desc *md,
62
 
                                        uint32_t num)
63
 
{
64
 
        return blkid_probe_get_buffer(pr,
65
 
                        (blkid_loff_t) num * md->block_size, num);
66
 
}
67
 
 
68
 
static inline int has_part_signature(struct mac_partition *p)
69
 
{
70
 
        return  be16_to_cpu(p->signature) == MAC_PARTITION_MAGIC ||
71
 
                be16_to_cpu(p->signature) == MAC_PARTITION_MAGIC_OLD;
72
 
}
73
 
 
74
 
static int probe_mac_pt(blkid_probe pr, const struct blkid_idmag *mag)
75
 
{
76
 
        struct mac_driver_desc *md;
77
 
        struct mac_partition *p;
78
 
        blkid_parttable tab = NULL;
79
 
        blkid_partlist ls;
80
 
        int i;
81
 
        uint16_t ssf;   /* sector size fragment */
82
 
        uint32_t nblks;
83
 
 
84
 
 
85
 
        /* The driver descriptor record is always located at physical block 0,
86
 
         * the first block on the disk.
87
 
         */
88
 
        md = (struct mac_driver_desc *) blkid_probe_get_sector(pr, 0);
89
 
        if (!md)
90
 
                goto nothing;
91
 
 
92
 
 
93
 
        /* The partition map always begins at physical block 1,
94
 
         * the second block on the disk.
95
 
         */
96
 
        p = (struct mac_partition *) get_mac_block(pr, md, 1);
97
 
        if (!p)
98
 
                goto nothing;
99
 
 
100
 
        /* check the first partition signature */
101
 
        if (!has_part_signature(p))
102
 
                goto nothing;
103
 
 
104
 
        if (blkid_partitions_need_typeonly(pr))
105
 
                /* caller does not ask for details about partitions */
106
 
                return 0;
107
 
 
108
 
        ls = blkid_probe_get_partlist(pr);
109
 
        if (!ls)
110
 
                goto err;
111
 
 
112
 
        tab = blkid_partlist_new_parttable(ls, "mac", 0);
113
 
        if (!tab)
114
 
                goto err;
115
 
 
116
 
        ssf = md->block_size / 512;
117
 
        nblks = be32_to_cpu(p->map_count);
118
 
 
119
 
        for (i = 1; i <= nblks; ++i) {
120
 
                blkid_partition par;
121
 
                uint32_t start;
122
 
                uint32_t size;
123
 
 
124
 
                p = (struct mac_partition *) get_mac_block(pr, md, i);
125
 
                if (!p)
126
 
                        goto nothing;
127
 
                if (!has_part_signature(p))
128
 
                        goto nothing;
129
 
 
130
 
                if (be32_to_cpu(p->map_count) != nblks) {
131
 
                        DBG(DEBUG_LOWPROBE, printf(
132
 
                                "mac: inconsisten map_count in partition map, "
133
 
                                "entry[0]: %d, entry[%d]: %d\n",
134
 
                                nblks, i - 1,
135
 
                                be32_to_cpu(p->map_count)));
136
 
                }
137
 
 
138
 
                /*
139
 
                 * note that libparted ignores some mac partitions according to
140
 
                 * the partition name (e.g. "Apple_Free" or "Apple_Void"). We
141
 
                 * follows Linux kernel and all partitions are visible
142
 
                 */
143
 
 
144
 
                start = be32_to_cpu(p->start_block) * ssf;
145
 
                size = be32_to_cpu(p->block_count) * ssf;
146
 
 
147
 
                par = blkid_partlist_add_partition(ls, tab, start, size);
148
 
                if (!par)
149
 
                        goto err;
150
 
 
151
 
                blkid_partition_set_name(par, (unsigned char *) p->name,
152
 
                                                sizeof(p->name));
153
 
 
154
 
                blkid_partition_set_type_string(par, (unsigned char *) p->type,
155
 
                                                sizeof(p->type));
156
 
        }
157
 
 
158
 
        return 0;
159
 
 
160
 
nothing:
161
 
        return 1;
162
 
err:
163
 
        return -1;
164
 
}
165
 
 
166
 
/*
167
 
 * Mac disk always begin with "Driver Descriptor Record"
168
 
 * (struct mac_driver_desc) and magic 0x4552.
169
 
 */
170
 
const struct blkid_idinfo mac_pt_idinfo =
171
 
{
172
 
        .name           = "mac",
173
 
        .probefunc      = probe_mac_pt,
174
 
        .magics         =
175
 
        {
176
 
                /* big-endian magic string */
177
 
                { .magic = "\x45\x52", .len = 2 },
178
 
                { NULL }
179
 
        }
180
 
};
181