2 * mkcramfs - make a cramfs file system
4 * Copyright (C) 1999-2002 Transmeta Corporation
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 * Old version would die on largish filesystems. Change to mmap the
23 * files one by one instead of all simultaneously. - aeb, 2002-11-01
26 #include <sys/types.h>
40 /* We don't use our include/crc32.h, but crc32 from zlib!
42 * The zlib implemenation performs pre/post-conditioning. The util-linux
43 * imlemenation requires post-conditioning (xor) in the applications.
51 #include "exitcodes.h"
54 #define CLOSE_EXIT_CODE MKFS_EX_ERROR
55 #include "closestream.h"
57 #define XALLOC_EXIT_CODE MKFS_EX_ERROR
60 /* The kernel only supports PAD_SIZE of 0 and 512. */
63 static int verbose
= 0;
65 static unsigned int blksize
= 0; /* settable via -b option, default page size */
66 static long total_blocks
= 0, total_nodes
= 1; /* pre-count the root node */
67 static int image_length
= 0;
68 static int cramfs_is_big_endian
= 0; /* target is big endian */
71 * If opt_holes is set, then mkcramfs can create explicit holes in the
72 * data, which saves 26 bytes per hole (which is a lot smaller a
73 * saving than for most filesystems).
75 * Note that kernels up to at least 2.3.39 don't support cramfs holes,
76 * which is why this is turned off by default.
78 static unsigned int opt_edition
= 0;
79 static int opt_errors
= 0;
80 static int opt_holes
= 0;
81 static int opt_pad
= 0;
82 static char *opt_image
= NULL
;
83 static char *opt_name
= NULL
;
85 static int warn_dev
= 0;
86 static int warn_gid
= 0;
87 static int warn_namelen
= 0;
88 static int warn_skip
= 0;
89 static int warn_size
= 0;
90 static int warn_uid
= 0;
93 #define CRAMFS_EFLAG_MD5 1
94 #define CRAMFS_EFLAG_INVALID 2
96 /* In-core version of inode / directory entry. */
100 unsigned int mode
, size
, uid
, gid
;
101 unsigned char md5sum
[MD5LENGTH
];
102 unsigned char flags
; /* CRAMFS_EFLAG_* */
106 int fd
; /* temporarily open files while mmapped */
107 struct entry
*same
; /* points to other identical file */
108 unsigned int offset
; /* pointer to compressed data in archive */
109 unsigned int dir_offset
; /* offset of directory entry in archive */
112 struct entry
*child
; /* NULL for non-directory and empty dir */
117 * Width of various bitfields in struct cramfs_inode.
118 * Used only to generate warnings.
120 #define CRAMFS_SIZE_WIDTH 24
121 #define CRAMFS_UID_WIDTH 16
122 #define CRAMFS_GID_WIDTH 8
123 #define CRAMFS_OFFSET_WIDTH 26
125 static void __attribute__((__noreturn__
)) usage(void)
128 _("usage: %s [-h] [-v] [-b blksize] [-e edition] [-N endian] [-i file] "
129 "[-n name] dirname outfile\n"
131 " -E make all warnings errors "
132 "(non-zero exit status)\n"
133 " -b blksize use this blocksize, must equal page size\n"
134 " -e edition set edition number (part of fsid)\n"
135 " -N endian set cramfs endianness (big|little|host), default host\n"
136 " -i file insert a file image into the filesystem\n"
137 " -n name set name of cramfs filesystem\n"
138 " -p pad by %d bytes for boot code\n"
139 " -s sort directory entries (old option, ignored)\n"
140 " -z make explicit holes\n"
141 " dirname root of the filesystem to be compressed\n"
142 " outfile output file\n"),
143 program_invocation_short_name
, PAD_SIZE
);
145 fputs(USAGE_SEPARATOR
, stdout
);
146 print_usage_help_options(16);
147 printf(USAGE_MAN_TAIL("mkfs.cramfs(8)"));
152 do_mmap(char *path
, unsigned int size
, unsigned int mode
){
160 start
= xmalloc(size
);
161 if (readlink(path
, start
, size
) < 0) {
162 warn(_("readlink failed: %s"), path
);
169 fd
= open(path
, O_RDONLY
);
171 warn(_("cannot open %s"), path
);
176 start
= mmap(NULL
, size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
178 if (start
== MAP_FAILED
)
179 err(MKFS_EX_ERROR
, "mmap");
187 do_munmap(char *start
, unsigned int size
, unsigned int mode
){
194 /* compute md5sums, so that we do not have to compare every pair of files */
196 mdfile(struct entry
*e
) {
200 start
= do_mmap(e
->path
, e
->size
, e
->mode
);
202 e
->flags
|= CRAMFS_EFLAG_INVALID
;
205 MD5Update(&ctx
, (unsigned char *) start
, e
->size
);
206 MD5Final(e
->md5sum
, &ctx
);
208 do_munmap(start
, e
->size
, e
->mode
);
210 e
->flags
|= CRAMFS_EFLAG_MD5
;
214 /* md5 digests are equal; files are almost certainly the same,
215 but just to be sure, do the comparison */
217 identical_file(struct entry
*e1
, struct entry
*e2
){
218 char *start1
, *start2
;
221 start1
= do_mmap(e1
->path
, e1
->size
, e1
->mode
);
224 start2
= do_mmap(e2
->path
, e2
->size
, e2
->mode
);
226 do_munmap(start1
, e1
->size
, e1
->mode
);
229 equal
= !memcmp(start1
, start2
, e1
->size
);
230 do_munmap(start1
, e1
->size
, e1
->mode
);
231 do_munmap(start2
, e2
->size
, e2
->mode
);
236 * The longest file name component to allow for in the input directory tree.
237 * Ext2fs (and many others) allow up to 255 bytes. A couple of filesystems
238 * allow longer (e.g. smbfs 1024), but there isn't much use in supporting
239 * >255-byte names in the input directory tree given that such names get
240 * truncated to 255 bytes when written to cramfs.
242 #define MAX_INPUT_NAMELEN 255
244 static int find_identical_file(struct entry
*orig
, struct entry
*new, loff_t
*fslen_ub
)
250 if (orig
->size
== new->size
&& orig
->path
) {
256 if ((orig
->flags
& CRAMFS_EFLAG_MD5
) &&
257 (new->flags
& CRAMFS_EFLAG_MD5
) &&
258 !memcmp(orig
->md5sum
, new->md5sum
, MD5LENGTH
) &&
259 identical_file(orig
, new)) {
261 *fslen_ub
-= new->size
;
265 return find_identical_file(orig
->child
, new, fslen_ub
) ||
266 find_identical_file(orig
->next
, new, fslen_ub
);
269 static void eliminate_doubles(struct entry
*root
, struct entry
*orig
, loff_t
*fslen_ub
) {
271 if (orig
->size
&& orig
->path
)
272 find_identical_file(root
,orig
, fslen_ub
);
273 eliminate_doubles(root
,orig
->child
, fslen_ub
);
274 eliminate_doubles(root
,orig
->next
, fslen_ub
);
279 * We define our own sorting function instead of using alphasort which
280 * uses strcoll and changes ordering based on locale information.
282 static int cramsort (const struct dirent
**a
, const struct dirent
**b
)
284 return strcmp((*a
)->d_name
, (*b
)->d_name
);
287 static unsigned int parse_directory(struct entry
*root_entry
, const char *name
, struct entry
**prev
, loff_t
*fslen_ub
)
289 struct dirent
**dirlist
;
290 int totalsize
= 0, dircount
, dirindex
;
291 char *path
, *endpath
;
292 size_t len
= strlen(name
);
294 /* Set up the path. */
295 /* TODO: Reuse the parent's buffer to save memcpy'ing and duplication. */
296 path
= xmalloc(len
+ 1 + MAX_INPUT_NAMELEN
+ 1);
297 memcpy(path
, name
, len
);
298 endpath
= path
+ len
;
302 /* read in the directory and sort */
303 dircount
= scandir(name
, &dirlist
, NULL
, cramsort
);
306 err(MKFS_EX_ERROR
, _("could not read directory %s"), name
);
308 /* process directory */
309 for (dirindex
= 0; dirindex
< dircount
; dirindex
++) {
310 struct dirent
*dirent
;
316 dirent
= dirlist
[dirindex
];
318 /* Ignore "." and ".." - we won't be adding them
320 if (dirent
->d_name
[0] == '.') {
321 if (dirent
->d_name
[1] == '\0')
323 if (dirent
->d_name
[1] == '.' &&
324 dirent
->d_name
[2] == '\0')
327 namelen
= strlen(dirent
->d_name
);
328 if (namelen
> MAX_INPUT_NAMELEN
) {
329 namelen
= MAX_INPUT_NAMELEN
;
333 memcpy(endpath
, dirent
->d_name
, namelen
+ 1);
335 if (lstat(path
, &st
) < 0) {
336 warn(_("stat of %s failed"), endpath
);
340 entry
= xcalloc(1, sizeof(struct entry
));
341 entry
->name
= (unsigned char *)xstrndup(dirent
->d_name
, namelen
);
342 entry
->mode
= st
.st_mode
;
343 entry
->size
= st
.st_size
;
344 entry
->uid
= st
.st_uid
;
345 if (entry
->uid
>= 1 << CRAMFS_UID_WIDTH
)
347 entry
->gid
= st
.st_gid
;
348 if (entry
->gid
>= 1 << CRAMFS_GID_WIDTH
)
349 /* TODO: We ought to replace with a default
350 gid instead of truncating; otherwise there
351 are security problems. Maybe mode should
352 be &= ~070. Same goes for uid once Linux
353 supports >16-bit uids. */
355 size
= sizeof(struct cramfs_inode
) + ((namelen
+ 3) & ~3);
357 if (S_ISDIR(st
.st_mode
)) {
358 entry
->size
= parse_directory(root_entry
, path
, &entry
->child
, fslen_ub
);
359 } else if (S_ISREG(st
.st_mode
)) {
360 entry
->path
= xstrdup(path
);
361 if (entry
->size
&& entry
->size
>= (1 << CRAMFS_SIZE_WIDTH
)) {
363 entry
->size
= (1 << CRAMFS_SIZE_WIDTH
) - 1;
365 } else if (S_ISLNK(st
.st_mode
)) {
366 entry
->path
= xstrdup(path
);
367 } else if (S_ISFIFO(st
.st_mode
) || S_ISSOCK(st
.st_mode
)) {
368 /* maybe we should skip sockets */
371 entry
->size
= st
.st_rdev
;
372 if (entry
->size
& -(1<<CRAMFS_SIZE_WIDTH
))
376 if (S_ISREG(st
.st_mode
) || S_ISLNK(st
.st_mode
)) {
377 int blocks
= ((entry
->size
- 1) / blksize
+ 1);
379 /* block pointers & data expansion allowance + data */
381 *fslen_ub
+= (4+26)*blocks
+ entry
->size
+ 3;
384 /* Link it into the list */
390 free(dirlist
); /* allocated by scandir() with malloc() */
394 /* Returns sizeof(struct cramfs_super), which includes the root inode. */
395 static unsigned int write_superblock(struct entry
*root
, char *base
, int size
)
397 struct cramfs_super
*super
= (struct cramfs_super
*) base
;
398 unsigned int offset
= sizeof(struct cramfs_super
) + image_length
;
404 super
->magic
= CRAMFS_MAGIC
;
405 super
->flags
= CRAMFS_FLAG_FSID_VERSION_2
| CRAMFS_FLAG_SORTED_DIRS
;
407 super
->flags
|= CRAMFS_FLAG_HOLES
;
408 if (image_length
> 0)
409 super
->flags
|= CRAMFS_FLAG_SHIFTED_ROOT_OFFSET
;
411 memcpy(super
->signature
, CRAMFS_SIGNATURE
, sizeof(super
->signature
));
413 super
->fsid
.crc
= crc32(0L, NULL
, 0);
414 super
->fsid
.edition
= opt_edition
;
415 super
->fsid
.blocks
= total_blocks
;
416 super
->fsid
.files
= total_nodes
;
418 memset(super
->name
, 0x00, sizeof(super
->name
));
420 strncpy((char *)super
->name
, opt_name
, sizeof(super
->name
));
422 strncpy((char *)super
->name
, "Compressed", sizeof(super
->name
));
424 super
->root
.mode
= root
->mode
;
425 super
->root
.uid
= root
->uid
;
426 super
->root
.gid
= root
->gid
;
427 super
->root
.size
= root
->size
;
428 super
->root
.offset
= offset
>> 2;
430 super_toggle_endianness(cramfs_is_big_endian
, super
);
431 inode_from_host(cramfs_is_big_endian
, &super
->root
, &super
->root
);
436 static void set_data_offset(struct entry
*entry
, char *base
, unsigned long offset
)
438 struct cramfs_inode
*inode
= (struct cramfs_inode
*) (base
+ entry
->dir_offset
);
439 inode_to_host(cramfs_is_big_endian
, inode
, inode
);
440 if (offset
>= (1 << (2 + CRAMFS_OFFSET_WIDTH
)))
441 errx(MKFS_EX_ERROR
, _("filesystem too big. Exiting."));
442 inode
->offset
= (offset
>> 2);
443 inode_from_host(cramfs_is_big_endian
, inode
, inode
);
448 * We do a width-first printout of the directory
449 * entries, using a stack to remember the directories
452 static unsigned int write_directory_structure(struct entry
*entry
, char *base
, unsigned int offset
)
454 int stack_entries
= 0;
456 struct entry
**entry_stack
;
458 entry_stack
= xmalloc(stack_size
* sizeof(struct entry
*));
461 int dir_start
= stack_entries
;
463 struct cramfs_inode
*inode
=
464 (struct cramfs_inode
*) (base
+ offset
);
465 size_t len
= strlen((const char *)entry
->name
);
467 entry
->dir_offset
= offset
;
469 inode
->mode
= entry
->mode
;
470 inode
->uid
= entry
->uid
;
471 inode
->gid
= entry
->gid
;
472 inode
->size
= entry
->size
;
474 /* Non-empty directories, regfiles and symlinks will
475 write over inode->offset later. */
477 offset
+= sizeof(struct cramfs_inode
);
478 total_nodes
++; /* another node */
479 memcpy(base
+ offset
, entry
->name
, len
);
480 /* Pad up the name to a 4-byte boundary */
482 *(base
+ offset
+ len
) = '\0';
485 inode
->namelen
= len
>> 2;
489 printf(" %s\n", entry
->name
);
491 if (stack_entries
>= stack_size
) {
493 entry_stack
= xrealloc(entry_stack
, stack_size
* sizeof(struct entry
*));
495 entry_stack
[stack_entries
] = entry
;
498 inode_from_host(cramfs_is_big_endian
, inode
, inode
);
503 * Reverse the order the stack entries pushed during
504 * this directory, for a small optimization of disk
505 * access in the created fs. This change makes things
509 struct entry
**lo
= entry_stack
+ dir_start
;
510 struct entry
**hi
= entry_stack
+ stack_entries
;
520 /* Pop a subdirectory entry from the stack, and recurse. */
524 entry
= entry_stack
[stack_entries
];
526 set_data_offset(entry
, base
, offset
);
528 printf("'%s':\n", entry
->name
);
529 entry
= entry
->child
;
535 static int is_zero(unsigned char const *begin
, unsigned len
)
538 /* Returns non-zero iff the first LEN bytes from BEGIN are
540 return (len
-- == 0 ||
548 memcmp(begin
, begin
+ 4, len
) == 0))))))));
550 /* Never create holes. */
555 * One 4-byte pointer per block and then the actual blocked
556 * output. The first block does not need an offset pointer,
557 * as it will start immediately after the pointer block;
558 * so the i'th pointer points to the end of the i'th block
559 * (i.e. the start of the (i+1)'th block or past EOF).
561 * Note that size > 0, as a zero-sized file wouldn't ever
562 * have gotten here in the first place.
565 do_compress(char *base
, unsigned int offset
, unsigned char const *name
,
566 char *path
, unsigned int size
, unsigned int mode
)
568 unsigned long original_size
, original_offset
, new_size
, blocks
, curr
;
573 /* get uncompressed data */
574 start
= do_mmap(path
, size
, mode
);
579 original_size
= size
;
580 original_offset
= offset
;
581 blocks
= (size
- 1) / blksize
+ 1;
582 curr
= offset
+ 4 * blocks
;
584 total_blocks
+= blocks
;
587 uLongf len
= 2 * blksize
;
592 if (!is_zero (p
, input
)) {
593 compress((Bytef
*)(base
+ curr
), &len
, p
, input
);
598 if (len
> blksize
*2) {
599 /* (I don't think this can happen with zlib.) */
600 printf(_("AIEEE: block \"compressed\" to > "
601 "2*blocklength (%ld)\n"),
606 *(uint32_t *) (base
+ offset
) = u32_toggle_endianness(cramfs_is_big_endian
, curr
);
610 do_munmap(start
, original_size
, mode
);
612 curr
= (curr
+ 3) & ~3;
613 new_size
= curr
- original_offset
;
614 /* TODO: Arguably, original_size in these 2 lines should be
615 st_blocks * 512. But if you say that, then perhaps
616 administrative data should also be included in both. */
617 change
= new_size
- original_size
;
619 printf(_("%6.2f%% (%+ld bytes)\t%s\n"),
620 (change
* 100) / (double) original_size
, change
, name
);
627 * Traverse the entry tree, writing data for every item that has
628 * non-null entry->path (i.e. every symlink and non-empty
632 write_data(struct entry
*entry
, char *base
, unsigned int offset
) {
635 for (e
= entry
; e
; e
= e
->next
) {
638 set_data_offset(e
, base
, e
->same
->offset
);
639 e
->offset
= e
->same
->offset
;
640 } else if (e
->size
) {
641 set_data_offset(e
, base
, offset
);
643 offset
= do_compress(base
, offset
, e
->name
,
644 e
->path
, e
->size
,e
->mode
);
647 offset
= write_data(e
->child
, base
, offset
);
652 static unsigned int write_file(char *file
, char *base
, unsigned int offset
)
657 fd
= open(file
, O_RDONLY
);
659 err(MKFS_EX_ERROR
, _("cannot open %s"), file
);
660 buf
= mmap(NULL
, image_length
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
661 memcpy(base
+ offset
, buf
, image_length
);
662 munmap(buf
, image_length
);
664 err(MKFS_EX_ERROR
, _("cannot close file %s"), file
);
665 /* Pad up the image_length to a 4-byte boundary */
666 while (image_length
& 3) {
667 *(base
+ offset
+ image_length
) = '\0';
670 return (offset
+ image_length
);
674 * Maximum size fs you can create is roughly 256MB. (The last file's
675 * data must begin within 256MB boundary but can extend beyond that.)
677 * Note that if you want it to fit in a ROM then you're limited to what the
678 * hardware and kernel can support (64MB?).
682 return (((1 << CRAMFS_OFFSET_WIDTH
) - 1) << 2) /* offset */
683 + (1 << CRAMFS_SIZE_WIDTH
) - 1 /* filesize */
684 + (1 << CRAMFS_SIZE_WIDTH
) * 4 / blksize
; /* block pointers */
690 * mkcramfs directory-name outfile
692 * where "directory-name" is simply the root of the directory
693 * tree that we want to generate a compressed filesystem out
696 int main(int argc
, char **argv
)
698 struct stat st
; /* used twice... */
699 struct entry
*root_entry
;
701 ssize_t offset
, written
;
703 /* initial guess (upper-bound) of required filesystem size */
704 loff_t fslen_ub
= sizeof(struct cramfs_super
);
705 unsigned int fslen_max
;
706 char const *dirname
, *outfile
;
707 uint32_t crc
= crc32(0L, NULL
, 0);
709 cramfs_is_big_endian
= HOST_IS_BIG_ENDIAN
; /* default is to use host order */
713 setlocale(LC_ALL
, "");
714 bindtextdomain(PACKAGE
, LOCALEDIR
);
716 atexit(close_stdout
);
719 /* first arg may be one of our standard longopts */
720 if (!strcmp(argv
[1], "--help"))
722 if (!strcmp(argv
[1], "--version")) {
723 printf(UTIL_LINUX_VERSION
);
727 strutils_set_exitcode(MKFS_EX_USAGE
);
729 /* command line options */
730 while ((c
= getopt(argc
, argv
, "hb:Ee:i:n:N:psVvz")) != EOF
) {
735 blksize
= strtou32_or_err(optarg
, _("invalid blocksize argument"));
741 opt_edition
= strtou32_or_err(optarg
, _("invalid edition number argument"));
744 if (strcmp(optarg
, "big") == 0)
745 cramfs_is_big_endian
= 1;
746 else if (strcmp(optarg
, "little") == 0)
747 cramfs_is_big_endian
= 0;
748 else if (strcmp(optarg
, "host") == 0)
751 errx(MKFS_EX_USAGE
, _("invalid endianness given;"
752 " must be 'big', 'little', or 'host'"));
756 if (lstat(opt_image
, &st
) < 0)
757 err(MKFS_EX_USAGE
, _("stat of %s failed"), opt_image
);
758 image_length
= st
.st_size
; /* may be padded later */
759 fslen_ub
+= (image_length
+ 3); /* 3 is for padding */
766 fslen_ub
+= PAD_SIZE
;
769 /* old option, ignored */
772 printf(UTIL_LINUX_VERSION
);
781 errtryhelp(MKFS_EX_USAGE
);
785 if ((argc
- optind
) != 2) {
786 warnx(_("bad usage"));
787 errtryhelp(MKFS_EX_USAGE
);
789 dirname
= argv
[optind
];
790 outfile
= argv
[optind
+ 1];
793 blksize
= getpagesize();
795 if (stat(dirname
, &st
) < 0)
796 err(MKFS_EX_USAGE
, _("stat of %s failed"), dirname
);
797 fd
= open(outfile
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0666);
799 err(MKFS_EX_USAGE
, _("cannot open %s"), outfile
);
801 root_entry
= xcalloc(1, sizeof(struct entry
));
802 root_entry
->mode
= st
.st_mode
;
803 root_entry
->uid
= st
.st_uid
;
804 root_entry
->gid
= st
.st_gid
;
806 root_entry
->size
= parse_directory(root_entry
, dirname
, &root_entry
->child
, &fslen_ub
);
808 /* find duplicate files */
809 eliminate_doubles(root_entry
,root_entry
, &fslen_ub
);
811 /* always allocate a multiple of blksize bytes because that's
812 what we're going to write later on */
813 fslen_ub
= ((fslen_ub
- 1) | (blksize
- 1)) + 1;
814 fslen_max
= maxfslen();
816 if (fslen_ub
> fslen_max
) {
817 warnx( _("warning: guestimate of required size (upper bound) "
818 "is %lldMB, but maximum image size is %uMB. "
819 "We might die prematurely."),
820 (long long)fslen_ub
>> 20,
822 fslen_ub
= fslen_max
;
825 /* TODO: Why do we use a private/anonymous mapping here
826 followed by a write below, instead of just a shared mapping
827 and a couple of ftruncate calls? Is it just to save us
828 having to deal with removing the file afterwards? If we
829 really need this huge anonymous mapping, we ought to mmap
830 in smaller chunks, so that the user doesn't need nn MB of
831 RAM free. If the reason is to be able to write to
832 un-mmappable block devices, then we could try shared mmap
833 and revert to anonymous mmap if the shared mmap fails. */
834 rom_image
= mmap(NULL
,
836 PROT_READ
| PROT_WRITE
,
837 MAP_PRIVATE
| MAP_ANONYMOUS
,
840 if (-1 == (int) (long) rom_image
)
841 err(MKFS_EX_ERROR
, _("ROM image map"));
843 /* Skip the first opt_pad bytes for boot loader code */
845 memset(rom_image
, 0x00, opt_pad
);
847 /* Skip the superblock and come back to write it later. */
848 offset
+= sizeof(struct cramfs_super
);
850 /* Insert a file image. */
853 printf(_("Including: %s\n"), opt_image
);
854 offset
= write_file(opt_image
, rom_image
, offset
);
857 offset
= write_directory_structure(root_entry
->child
, rom_image
, offset
);
859 printf(_("Directory data: %zd bytes\n"), offset
);
861 offset
= write_data(root_entry
, rom_image
, offset
);
863 /* We always write a multiple of blksize bytes, so that
865 offset
= ((offset
- 1) | (blksize
- 1)) + 1;
867 printf(_("Everything: %zd kilobytes\n"), offset
>> 10);
869 /* Write the superblock now that we can fill in all of the fields. */
870 write_superblock(root_entry
, rom_image
+opt_pad
, offset
);
872 printf(_("Super block: %zd bytes\n"),
873 sizeof(struct cramfs_super
));
875 /* Put the checksum in. */
876 crc
= crc32(crc
, (unsigned char *) (rom_image
+opt_pad
), (offset
-opt_pad
));
877 ((struct cramfs_super
*) (rom_image
+opt_pad
))->fsid
.crc
= u32_toggle_endianness(cramfs_is_big_endian
, crc
);
879 printf(_("CRC: %x\n"), crc
);
881 /* Check to make sure we allocated enough space. */
882 if (fslen_ub
< offset
)
884 _("not enough space allocated for ROM image "
885 "(%lld allocated, %zu used)"),
886 (long long) fslen_ub
, offset
);
888 written
= write(fd
, rom_image
, offset
);
889 if (offset
!= written
)
890 errx(MKFS_EX_ERROR
, _("ROM image write failed (%zd %zd)"),
892 if (close_fd(fd
) != 0)
893 err(MKFS_EX_ERROR
, _("ROM image"));
896 * (These warnings used to come at the start, but they scroll off
897 * the screen too quickly.)
900 /* Can't happen when reading from ext2fs. */
901 /* Bytes, not chars: think UTF8. */
902 warnx(_("warning: filenames truncated to %u bytes."), MAX_INPUT_NAMELEN
);
904 warnx(_("warning: files were skipped due to errors."));
906 warnx(_("warning: file sizes truncated to %luMB "
907 "(minus 1 byte)."), 1L << (CRAMFS_SIZE_WIDTH
- 20));
909 /* (not possible with current Linux versions) */
910 warnx(_("warning: uids truncated to %u bits. "
911 "(This may be a security concern.)"), CRAMFS_UID_WIDTH
);
913 warnx(_("warning: gids truncated to %u bits. "
914 "(This may be a security concern.)"), CRAMFS_GID_WIDTH
);
916 warnx(_("WARNING: device numbers truncated to %u bits. "
917 "This almost certainly means\n"
918 "that some device files will be wrong."),
919 CRAMFS_OFFSET_WIDTH
);
921 (warn_namelen
|warn_skip
|warn_size
|warn_uid
|warn_gid
|warn_dev
))