1bd6ab23f6d904c317ba854469b5198909df6b70
[sven/exfatprogs.git] / dump / dump.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *   Copyright (C) 2021 Namjae Jeon <linkinjeon@kernel.org>
4  */
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <unistd.h>
10 #include <getopt.h>
11 #include <errno.h>
12 #include <locale.h>
13 #include <inttypes.h>
14
15 #include "exfat_ondisk.h"
16 #include "libexfat.h"
17
18 #define EXFAT_MIN_SECT_SIZE_BITS                9
19 #define EXFAT_MAX_SECT_SIZE_BITS                12
20 #define BITS_PER_BYTE                           8
21 #define BITS_PER_BYTE_MASK                      0x7
22
23 static const unsigned char used_bit[] = {
24         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3,/*  0 ~  19*/
25         2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4,/* 20 ~  39*/
26         2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5,/* 40 ~  59*/
27         4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,/* 60 ~  79*/
28         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4,/* 80 ~  99*/
29         3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,/*100 ~ 119*/
30         4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,/*120 ~ 139*/
31         3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,/*140 ~ 159*/
32         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5,/*160 ~ 179*/
33         4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5,/*180 ~ 199*/
34         3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6,/*200 ~ 219*/
35         5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,/*220 ~ 239*/
36         4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8             /*240 ~ 255*/
37 };
38
39 static void usage(void)
40 {
41         fprintf(stderr, "Usage: dump.exfat\n");
42         fprintf(stderr, "\t-V | --version                        Show version\n");
43         fprintf(stderr, "\t-h | --help                           Show help\n");
44
45         exit(EXIT_FAILURE);
46 }
47
48 static struct option opts[] = {
49         {"version",             no_argument,            NULL,   'V' },
50         {"help",                no_argument,            NULL,   'h' },
51         {"?",                   no_argument,            NULL,   '?' },
52         {NULL,                  0,                      NULL,    0  }
53 };
54
55 static unsigned int exfat_count_used_clusters(unsigned char *bitmap,
56                 unsigned long long bitmap_len)
57 {
58         unsigned int count = 0;
59         unsigned long long i;
60
61         for (i = 0; i < bitmap_len; i++)
62                 count += used_bit[bitmap[i]];
63
64         return count;
65 }
66
67 int exfat_show_ondisk_all_info(struct exfat_blk_dev *bd)
68 {
69         struct pbr *ppbr;
70         struct bsx64 *pbsx;
71         struct exfat_dentry *ed;
72         unsigned int root_clu_off, bitmap_clu_off, bitmap_clu;
73         unsigned int total_clus, used_clus, clu_offset, root_clu;
74         unsigned long long bitmap_len;
75         int ret;
76         unsigned char *bitmap;
77         char *volume_label;
78
79         ppbr = malloc(bd->sector_size);
80         if (!ppbr) {
81                 exfat_err("Cannot allocate pbr: out of memory\n");
82                 return -1;
83         }
84
85         /* read main boot sector */
86         ret = exfat_read_sector(bd, (char *)ppbr, BOOT_SEC_IDX);
87         if (ret < 0) {
88                 exfat_err("main boot sector read failed\n");
89                 ret = -1;
90                 goto free_ppbr;
91         }
92
93         pbsx = &ppbr->bsx;
94
95         if (pbsx->sect_size_bits < EXFAT_MIN_SECT_SIZE_BITS ||
96             pbsx->sect_size_bits > EXFAT_MAX_SECT_SIZE_BITS) {
97                 exfat_err("bogus sector size bits : %u\n",
98                                 pbsx->sect_size_bits);
99                 return -EINVAL;
100         }
101
102         if (pbsx->sect_per_clus_bits > 25 - pbsx->sect_size_bits) {
103                 exfat_err("bogus sectors bits per cluster : %u\n",
104                                 pbsx->sect_per_clus_bits);
105                 return -EINVAL;
106         }
107
108         if (bd->sector_size != 1 << pbsx->sect_size_bits) {
109                 exfat_err("bogus sectors size : %u(sector size bits : %u)\n",
110                                 bd->sector_size, pbsx->sect_size_bits);
111
112         }
113
114         clu_offset = le32_to_cpu(pbsx->clu_offset);
115         total_clus = le32_to_cpu(pbsx->clu_count);
116         root_clu = le32_to_cpu(pbsx->root_cluster);
117
118         exfat_info("-------------- Dump Boot sector region --------------\n");
119         exfat_info("Volume Length(sectors): \t\t%" PRIu64 "\n",
120                         le64_to_cpu(pbsx->vol_length));
121         exfat_info("FAT Offset(sector offset): \t\t%u\n",
122                         le32_to_cpu(pbsx->fat_offset));
123         exfat_info("FAT Length(sectors): \t\t\t%u\n",
124                         le32_to_cpu(pbsx->fat_length));
125         exfat_info("Cluster Heap Offset (sector offset): \t%u\n", clu_offset);
126         exfat_info("Cluster Count: \t\t\t\t%u\n", total_clus);
127         exfat_info("Root Cluster (cluster offset): \t\t%u\n", root_clu);
128         exfat_info("Volume Serial: \t\t\t\t0x%x\n", le32_to_cpu(pbsx->vol_serial));
129         exfat_info("Sector Size Bits: \t\t\t%u\n", pbsx->sect_size_bits);
130         exfat_info("Sector per Cluster bits: \t\t%u\n\n", pbsx->sect_per_clus_bits);
131
132         bd->cluster_size =
133                 1 << (pbsx->sect_per_clus_bits + pbsx->sect_size_bits);
134         root_clu_off = exfat_clus_to_blk_dev_off(bd, clu_offset, root_clu);
135
136         ed = malloc(sizeof(struct exfat_dentry)*3);
137         if (!ed) {
138                 exfat_err("failed to allocate memory\n");
139                 ret = -ENOMEM;
140                 goto free_ppbr;
141         }
142
143         ret = exfat_read(bd->dev_fd, ed, sizeof(struct exfat_dentry)*3,
144                         root_clu_off);
145         if (ret < 0) {
146                 exfat_err("bitmap entry read failed: %d\n", errno);
147                 ret = -EIO;
148                 goto free_entry;
149         }
150
151         volume_label = exfat_conv_volume_serial(&ed[0]);
152         if (!volume_label) {
153                 ret = -EINVAL;
154                 goto free_entry;
155         }
156
157         bitmap_clu = le32_to_cpu(ed[1].bitmap_start_clu);
158         bitmap_clu_off = exfat_clus_to_blk_dev_off(bd, clu_offset,
159                         bitmap_clu);
160         bitmap_len = le64_to_cpu(ed[1].bitmap_size);
161
162         exfat_info("----------------- Dump Root entries -----------------\n");
163         exfat_info("Volume entry type: \t\t\t0x%x\n", ed[0].type);
164         exfat_info("Volume label: \t\t\t\t%s\n", volume_label);
165         exfat_info("Volume label character count: \t\t%u\n", ed[0].vol_char_cnt);
166
167         exfat_info("Bitmap entry type: \t\t\t0x%x\n", ed[1].type);
168         exfat_info("Bitmap start cluster: \t\t\t%x\n", bitmap_clu);
169         exfat_info("Bitmap size: \t\t\t\t%llu\n", bitmap_len);
170
171         exfat_info("Upcase table entry type: \t\t0x%x\n", ed[2].type);
172         exfat_info("Upcase table start cluster: \t\t%x\n",
173                         le32_to_cpu(ed[2].upcase_start_clu));
174         exfat_info("Upcase table size: \t\t\t%" PRIu64 "\n\n",
175                         le64_to_cpu(ed[2].upcase_size));
176
177         bitmap = malloc(bitmap_len);
178         if (!bitmap) {
179                 exfat_err("bitmap allocation failed\n");
180                 goto free_volume_label;
181         }
182
183         ret = exfat_read(bd->dev_fd, bitmap, bitmap_len, bitmap_clu_off);
184         if (ret < 0) {
185                 exfat_err("bitmap entry read failed: %d\n", errno);
186                 ret = -EIO;
187                 free(bitmap);
188                 goto free_volume_label;
189         }
190
191         total_clus = le32_to_cpu(pbsx->clu_count);
192         used_clus = exfat_count_used_clusters(bitmap, bitmap_len);
193
194         exfat_info("---------------- Show the statistics ----------------\n");
195         exfat_info("Cluster size:  \t\t\t\t%u\n", bd->cluster_size);
196         exfat_info("Total Clusters: \t\t\t%u\n", total_clus);
197         exfat_info("Free Clusters: \t\t\t\t%u\n", total_clus-used_clus);
198
199         free(bitmap);
200
201 free_volume_label:
202         free(volume_label);
203 free_entry:
204         free(ed);
205 free_ppbr:
206         free(ppbr);
207         return ret;
208 }
209
210 int main(int argc, char *argv[])
211 {
212         int c;
213         int ret = EXIT_FAILURE;
214         struct exfat_blk_dev bd;
215         struct exfat_user_input ui;
216         bool version_only = false;
217
218         init_user_input(&ui);
219
220         if (!setlocale(LC_CTYPE, ""))
221                 exfat_err("failed to init locale/codeset\n");
222
223         opterr = 0;
224         while ((c = getopt_long(argc, argv, "iVh", opts, NULL)) != EOF)
225                 switch (c) {
226                 case 'V':
227                         version_only = true;
228                         break;
229                 case '?':
230                 case 'h':
231                 default:
232                         usage();
233         }
234
235         show_version();
236         if (version_only)
237                 exit(EXIT_FAILURE);
238
239         if (argc < 2)
240                 usage();
241
242         memset(ui.dev_name, 0, sizeof(ui.dev_name));
243         snprintf(ui.dev_name, sizeof(ui.dev_name), "%s", argv[1]);
244
245         ret = exfat_get_blk_dev_info(&ui, &bd);
246         if (ret < 0)
247                 goto out;
248
249         ret = exfat_show_ondisk_all_info(&bd);
250         close(bd.dev_fd);
251
252 out:
253         return ret;
254 }