1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Copyright (C) 2010 Andrew Nayenko <resver@gmail.com>
*
* This file may be redistributed under the terms of the
* GNU Lesser General Public License.
*/
#include "superblocks.h"
struct exfat_super_block {
uint8_t jump[3];
uint8_t oem_name[8];
uint8_t __unused1[53];
uint64_t block_start;
uint64_t block_count;
uint32_t fat_block_start;
uint32_t fat_block_count;
uint32_t cluster_block_start;
uint32_t cluster_count;
uint32_t rootdir_cluster;
uint8_t volume_serial[4];
struct {
uint8_t vermin;
uint8_t vermaj;
} version;
uint16_t volume_state;
uint8_t block_bits;
uint8_t bpc_bits;
uint8_t fat_count;
uint8_t drive_no;
uint8_t allocated_percent;
} __attribute__((__packed__));
struct exfat_entry_label {
uint8_t type;
uint8_t length;
uint8_t name[22];
uint8_t reserved[8];
} __attribute__((__packed__));
#define BLOCK_SIZE(sb) (1u << (sb)->block_bits)
#define CLUSTER_SIZE(sb) (BLOCK_SIZE(sb) << (sb)->bpc_bits)
#define EXFAT_FIRST_DATA_CLUSTER 2
#define EXFAT_LAST_DATA_CLUSTER 0xffffff6
#define EXFAT_ENTRY_SIZE 32
#define EXFAT_ENTRY_EOD 0x00
#define EXFAT_ENTRY_LABEL 0x83
static uint64_t block_to_offset(const struct exfat_super_block *sb,
uint64_t block)
{
return block << sb->block_bits;
}
static uint64_t cluster_to_block(const struct exfat_super_block *sb,
uint32_t cluster)
{
return le32_to_cpu(sb->cluster_block_start) +
((uint64_t) (cluster - EXFAT_FIRST_DATA_CLUSTER)
<< sb->bpc_bits);
}
static uint64_t cluster_to_offset(const struct exfat_super_block *sb,
uint32_t cluster)
{
return block_to_offset(sb, cluster_to_block(sb, cluster));
}
static uint32_t next_cluster(blkid_probe pr,
const struct exfat_super_block *sb, uint32_t cluster)
{
uint32_t *next;
uint64_t fat_offset;
fat_offset = block_to_offset(sb, le32_to_cpu(sb->fat_block_start))
+ (uint64_t) cluster * sizeof(cluster);
next = (uint32_t *) blkid_probe_get_buffer(pr, fat_offset,
sizeof(uint32_t));
if (!next)
return 0;
return le32_to_cpu(*next);
}
static struct exfat_entry_label *find_label(blkid_probe pr,
const struct exfat_super_block *sb)
{
uint32_t cluster = le32_to_cpu(sb->rootdir_cluster);
uint64_t offset = cluster_to_offset(sb, cluster);
uint8_t *entry;
const size_t max_iter = 10000;
size_t i = 0;
for (; i < max_iter; i++) {
entry = (uint8_t *) blkid_probe_get_buffer(pr, offset,
EXFAT_ENTRY_SIZE);
if (!entry)
return NULL;
if (entry[0] == EXFAT_ENTRY_EOD)
return NULL;
if (entry[0] == EXFAT_ENTRY_LABEL)
return (struct exfat_entry_label *) entry;
offset += EXFAT_ENTRY_SIZE;
if (offset % CLUSTER_SIZE(sb) == 0) {
cluster = next_cluster(pr, sb, cluster);
if (cluster < EXFAT_FIRST_DATA_CLUSTER)
return NULL;
if (cluster > EXFAT_LAST_DATA_CLUSTER)
return NULL;
offset = cluster_to_offset(sb, cluster);
}
}
return NULL;
}
static int probe_exfat(blkid_probe pr, const struct blkid_idmag *mag)
{
struct exfat_super_block *sb;
struct exfat_entry_label *label;
sb = blkid_probe_get_sb(pr, mag, struct exfat_super_block);
if (!sb || !CLUSTER_SIZE(sb))
return errno ? -errno : BLKID_PROBE_NONE;
label = find_label(pr, sb);
if (label)
blkid_probe_set_utf8label(pr, label->name,
min((size_t) label->length * 2, sizeof(label->name)),
UL_ENCODE_UTF16LE);
else if (errno)
return -errno;
blkid_probe_sprintf_uuid(pr, sb->volume_serial, 4,
"%02hhX%02hhX-%02hhX%02hhX",
sb->volume_serial[3], sb->volume_serial[2],
sb->volume_serial[1], sb->volume_serial[0]);
blkid_probe_sprintf_version(pr, "%u.%u",
sb->version.vermaj, sb->version.vermin);
blkid_probe_set_block_size(pr, BLOCK_SIZE(sb));
return BLKID_PROBE_OK;
}
const struct blkid_idinfo exfat_idinfo =
{
.name = "exfat",
.usage = BLKID_USAGE_FILESYSTEM,
.probefunc = probe_exfat,
.magics =
{
{ .magic = "EXFAT ", .len = 8, .sboff = 3 },
{ NULL }
}
};
|
