source: mainline/uspace/app/mkfat/mkfat.c@ 375ab5e

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 375ab5e was 375ab5e, checked in by Jakub Jermar <jakub@…>, 14 years ago

Merge from lp:~romanenko-oleg/helenos/fat.
  • Property mode set to 100644
File size: 10.1 KB
Line 
1/*
2 * Copyright (c) 2010 Jiri Svoboda
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 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - 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 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup fs
30 * @{
31 */
32
33/**
34 * @file mkfat.c
35 * @brief Tool for creating new FAT file systems.
36 *
37 * Currently we can create 12/16/32-bit FAT.
38 */
39
40#include <stdio.h>
41#include <stdlib.h>
42#include <libblock.h>
43#include <mem.h>
44#include <loc.h>
45#include <byteorder.h>
46#include <sys/types.h>
47#include <sys/typefmt.h>
48#include <inttypes.h>
49#include <errno.h>
50#include "fat.h"
51
52#define NAME "mkfat"
53
54/** Divide and round up. */
55#define div_round_up(a, b) (((a) + (b) - 1) / (b))
56
57/** Default file-system parameters */
58enum {
59 default_sector_size = 512,
60 default_sectors_per_cluster = 4,
61 default_fat_count = 2,
62 default_reserved_clusters = 2,
63 default_media_descriptor = 0xF8 /**< fixed disk */
64};
65
66/** Configurable file-system parameters */
67typedef struct fat_cfg {
68 int fat_type; /* FAT12 = 12, FAT16 = 16, FAT32 = 32 */
69 size_t sector_size;
70 uint32_t total_sectors;
71 uint16_t root_ent_max;
72 uint32_t addt_res_sectors;
73 uint8_t sectors_per_cluster;
74
75 uint16_t reserved_sectors;
76 uint32_t rootdir_sectors;
77 uint32_t fat_sectors;
78 uint32_t total_clusters;
79 uint8_t fat_count;
80} fat_cfg_t;
81
82static void syntax_print(void);
83
84static int fat_params_compute(struct fat_cfg *cfg);
85static int fat_blocks_write(struct fat_cfg const *cfg, service_id_t service_id);
86static void fat_bootsec_create(struct fat_cfg const *cfg, struct fat_bs *bs);
87
88int main(int argc, char **argv)
89{
90 struct fat_cfg cfg;
91
92 int rc;
93 char *dev_path;
94 service_id_t service_id;
95 char *endptr;
96 aoff64_t dev_nblocks;
97
98 cfg.sector_size = default_sector_size;
99 cfg.sectors_per_cluster = default_sectors_per_cluster;
100 cfg.fat_count = default_fat_count;
101 cfg.total_sectors = 0;
102 cfg.addt_res_sectors = 0;
103 cfg.root_ent_max = 128;
104 cfg.fat_type = FAT16;
105
106 if (argc < 2) {
107 printf(NAME ": Error, argument missing.\n");
108 syntax_print();
109 return 1;
110 }
111
112 --argc; ++argv;
113 if (str_cmp(*argv, "--size") == 0) {
114 --argc; ++argv;
115 if (*argv == NULL) {
116 printf(NAME ": Error, argument missing.\n");
117 syntax_print();
118 return 1;
119 }
120
121 cfg.total_sectors = strtol(*argv, &endptr, 10);
122 if (*endptr != '\0') {
123 printf(NAME ": Error, invalid argument.\n");
124 syntax_print();
125 return 1;
126 }
127
128 --argc; ++argv;
129 }
130
131 if (str_cmp(*argv, "--type") == 0) {
132 --argc; ++argv;
133 if (*argv == NULL) {
134 printf(NAME ": Error, argument missing.\n");
135 syntax_print();
136 return 1;
137 }
138
139 cfg.fat_type = strtol(*argv, &endptr, 10);
140 if (*endptr != '\0') {
141 printf(NAME ": Error, invalid argument.\n");
142 syntax_print();
143 return 1;
144 }
145
146 --argc; ++argv;
147 }
148
149 if (argc != 1) {
150 printf(NAME ": Error, unexpected argument.\n");
151 syntax_print();
152 return 1;
153 }
154
155 dev_path = *argv;
156 printf("Device: %s\n", dev_path);
157
158 rc = loc_service_get_id(dev_path, &service_id, 0);
159 if (rc != EOK) {
160 printf(NAME ": Error resolving device `%s'.\n", dev_path);
161 return 2;
162 }
163
164 rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
165 if (rc != EOK) {
166 printf(NAME ": Error initializing libblock.\n");
167 return 2;
168 }
169
170 rc = block_get_bsize(service_id, &cfg.sector_size);
171 if (rc != EOK) {
172 printf(NAME ": Error determining device block size.\n");
173 return 2;
174 }
175
176 rc = block_get_nblocks(service_id, &dev_nblocks);
177 if (rc != EOK) {
178 printf(NAME ": Warning, failed to obtain block device size.\n");
179 } else {
180 printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
181 dev_nblocks);
182 cfg.total_sectors = dev_nblocks;
183 }
184
185 if (cfg.fat_type == FAT12 && cfg.sector_size != 512) {
186 printf(NAME ": Error. Device block size is not 512 bytes for FAT12 file system.\n");
187 return 2;
188 }
189
190 if (cfg.total_sectors == 0) {
191 printf(NAME ": Error. You must specify filesystem size.\n");
192 return 1;
193 }
194
195 printf(NAME ": Creating FAT%d filesystem on device %s.\n", cfg.fat_type, dev_path);
196
197 rc = fat_params_compute(&cfg);
198 if (rc != EOK) {
199 printf(NAME ": Invalid file-system parameters.\n");
200 return 2;
201 }
202
203 rc = fat_blocks_write(&cfg, service_id);
204 if (rc != EOK) {
205 printf(NAME ": Error writing device.\n");
206 return 2;
207 }
208
209 block_fini(service_id);
210 printf("Success.\n");
211
212 return 0;
213}
214
215static void syntax_print(void)
216{
217 printf("syntax: mkfat32 [--size <sectors>] [--type 12|16|32] <device_name>\n");
218}
219
220/** Derive sizes of different filesystem structures.
221 *
222 * This function concentrates all the different computations of FAT
223 * file system params.
224 */
225static int fat_params_compute(struct fat_cfg *cfg)
226{
227 uint32_t fat_bytes;
228 uint32_t non_data_sectors_lb;
229
230 /*
231 * Make a conservative guess on the FAT size needed for the file
232 * system. The optimum could be potentially smaller since we
233 * do not subtract size of the FAT itself when computing the
234 * size of the data region.
235 */
236
237 if (cfg->fat_type == FAT12)
238 cfg->sectors_per_cluster = 1;
239
240 cfg->reserved_sectors = 1 + cfg->addt_res_sectors;
241 if (cfg->fat_type != FAT32) {
242 cfg->rootdir_sectors = div_round_up(cfg->root_ent_max * DIRENT_SIZE,
243 cfg->sector_size);
244 }
245 else
246 cfg->rootdir_sectors = 0;
247 non_data_sectors_lb = cfg->reserved_sectors + cfg->rootdir_sectors;
248
249 cfg->total_clusters = div_round_up(cfg->total_sectors - non_data_sectors_lb,
250 cfg->sectors_per_cluster);
251
252 if ((cfg->fat_type == FAT12 && cfg->total_clusters > FAT12_CLST_MAX) ||
253 (cfg->fat_type == FAT16 && (cfg->total_clusters <= FAT12_CLST_MAX ||
254 cfg->total_clusters > FAT16_CLST_MAX)) ||
255 (cfg->fat_type == FAT32 && cfg->total_clusters <= FAT16_CLST_MAX))
256 return ENOSPC;
257
258 fat_bytes = (cfg->total_clusters + 2) * FAT_SIZE(cfg->fat_type);
259 cfg->fat_sectors = div_round_up(fat_bytes, cfg->sector_size);
260
261 return EOK;
262}
263
264/** Create file system with the given parameters. */
265static int fat_blocks_write(struct fat_cfg const *cfg, service_id_t service_id)
266{
267 aoff64_t addr;
268 uint8_t *buffer;
269 int i;
270 uint32_t j;
271 int rc;
272 struct fat_bs bs;
273
274 fat_bootsec_create(cfg, &bs);
275
276 rc = block_write_direct(service_id, BS_BLOCK, 1, &bs);
277 if (rc != EOK)
278 return EIO;
279
280 addr = BS_BLOCK + 1;
281
282 buffer = calloc(cfg->sector_size, 1);
283 if (buffer == NULL)
284 return ENOMEM;
285 memset(buffer, 0, cfg->sector_size);
286
287 /* Reserved sectors */
288 for (i = 0; i < cfg->reserved_sectors - 1; ++i) {
289 rc = block_write_direct(service_id, addr, 1, buffer);
290 if (rc != EOK)
291 return EIO;
292
293 ++addr;
294 }
295
296 /* File allocation tables */
297 for (i = 0; i < cfg->fat_count; ++i) {
298 printf("Writing allocation table %d.\n", i + 1);
299
300 for (j = 0; j < cfg->fat_sectors; ++j) {
301 memset(buffer, 0, cfg->sector_size);
302 if (j == 0) {
303 buffer[0] = default_media_descriptor;
304 buffer[1] = 0xFF;
305 buffer[2] = 0xFF;
306 if (cfg->fat_type == FAT16) {
307 buffer[3] = 0xFF;
308 } else if (cfg->fat_type == FAT32) {
309 buffer[3] = 0x0F;
310 buffer[4] = 0xFF;
311 buffer[5] = 0xFF;
312 buffer[6] = 0xFF;
313 buffer[7] = 0x0F;
314 buffer[8] = 0xF8;
315 buffer[9] = 0xFF;
316 buffer[10] = 0xFF;
317 buffer[11] = 0x0F;
318 }
319 }
320
321 rc = block_write_direct(service_id, addr, 1, buffer);
322 if (rc != EOK)
323 return EIO;
324
325 ++addr;
326 }
327 }
328
329 /* Root directory */
330 printf("Writing root directory.\n");
331 memset(buffer, 0, cfg->sector_size);
332 if (cfg->fat_type != FAT32) {
333 size_t idx;
334 for (idx = 0; idx < cfg->rootdir_sectors; ++idx) {
335 rc = block_write_direct(service_id, addr, 1, buffer);
336 if (rc != EOK)
337 return EIO;
338
339 ++addr;
340 }
341 } else {
342 for (i=0; i<cfg->sectors_per_cluster; i++) {
343 rc = block_write_direct(service_id, addr, 1, buffer);
344 if (rc != EOK)
345 return EIO;
346
347 ++addr;
348 }
349 }
350
351 free(buffer);
352
353 return EOK;
354}
355
356/** Construct boot sector with the given parameters. */
357static void fat_bootsec_create(struct fat_cfg const *cfg, struct fat_bs *bs)
358{
359 memset(bs, 0, sizeof(*bs));
360
361 bs->ji[0] = 0xEB;
362 bs->ji[1] = 0x3C;
363 bs->ji[2] = 0x90;
364
365 memcpy(bs->oem_name, "HELENOS ", 8);
366
367 /* BIOS Parameter Block */
368 bs->bps = host2uint16_t_le(cfg->sector_size);
369 bs->spc = cfg->sectors_per_cluster;
370 bs->rscnt = host2uint16_t_le(cfg->reserved_sectors);
371 bs->fatcnt = cfg->fat_count;
372 bs->root_ent_max = host2uint16_t_le(cfg->root_ent_max);
373
374 if (cfg->total_sectors < 0x10000) {
375 bs->totsec16 = host2uint16_t_le(cfg->total_sectors);
376 bs->totsec32 = 0;
377 } else {
378 bs->totsec16 = 0;
379 bs->totsec32 = host2uint32_t_le(cfg->total_sectors);
380 }
381
382 bs->mdesc = default_media_descriptor;
383 bs->sec_per_track = host2uint16_t_le(63);
384 bs->signature = host2uint16_t_be(0x55AA);
385 bs->headcnt = host2uint16_t_le(6);
386 bs->hidden_sec = host2uint32_t_le(0);
387
388 if (cfg->fat_type == FAT32) {
389 bs->sec_per_fat = 0;
390 bs->fat32.sectors_per_fat = host2uint32_t_le(cfg->fat_sectors);
391
392 bs->fat32.pdn = 0x80;
393 bs->fat32.ebs = 0x29;
394 bs->fat32.id = host2uint32_t_be(0x12345678);
395 bs->fat32.root_cluster = 2;
396
397 memcpy(bs->fat32.label, "HELENOS_NEW", 11);
398 memcpy(bs->fat32.type, "FAT32 ", 8);
399 } else {
400 bs->sec_per_fat = host2uint16_t_le(cfg->fat_sectors);
401 bs->pdn = 0x80;
402 bs->ebs = 0x29;
403 bs->id = host2uint32_t_be(0x12345678);
404
405 memcpy(bs->label, "HELENOS_NEW", 11);
406 memcpy(bs->type, "FAT ", 8);
407 }
408}
409
410/**
411 * @}
412 */
Note: See TracBrowser for help on using the repository browser.