1 /* $OpenBSD: mke2fs.c,v 1.18 2019/07/01 07:17:26 kevlo Exp $ */
2 /* $NetBSD: mke2fs.c,v 1.13 2009/10/19 18:41:08 bouyer Exp $ */
3
4 /*-
5 * Copyright (c) 2007 Izumi Tsutsui. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 /*
29 * Copyright (c) 1980, 1989, 1993
30 * The Regents of the University of California. All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. Neither the name of the University nor the names of its contributors
41 * may be used to endorse or promote products derived from this software
42 * without specific prior written permission.
43 *
44 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54 * SUCH DAMAGE.
55 */
56
57 /*
58 * Copyright (c) 1997 Manuel Bouyer.
59 *
60 * Redistribution and use in source and binary forms, with or without
61 * modification, are permitted provided that the following conditions
62 * are met:
63 * 1. Redistributions of source code must retain the above copyright
64 * notice, this list of conditions and the following disclaimer.
65 * 2. Redistributions in binary form must reproduce the above copyright
66 * notice, this list of conditions and the following disclaimer in the
67 * documentation and/or other materials provided with the distribution.
68 *
69 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
70 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
71 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
72 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
73 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
74 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
75 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
76 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
77 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
78 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
79 */
80
81 /*
82 * mke2fs.c: "re-invent (dumb but non-GPLed) wheel as a fun project"
83 *
84 * In spite of this name, there is no piece of code
85 * derived from GPLed e2fsprogs written for Linux.
86 * I referred them only to see how each structure
87 * member should be initialized.
88 *
89 * Reference:
90 * - All NetBSD sources under src/sys/ufs/ext2fs and src/sbin/fsck_ext2fs
91 * - Ext2fs Home Page
92 * http://e2fsprogs.sourceforge.net/ext2.html
93 * - Design and Implementation of the Second Extended Filesystem
94 * http://e2fsprogs.sourceforge.net/ext2intro.html
95 * - Linux Documentation "The Second Extended Filesystem"
96 * src/linux/Documentation/filesystems/ext2.txt
97 * in the Linux kernel distribution
98 */
99
100 #include <sys/param.h> /* MAXBSIZE powerof2 roundup setbit isset MIN */
101 #include <sys/types.h>
102 #include <sys/mman.h>
103 #include <sys/time.h>
104 #include <ufs/ext2fs/ext2fs_dinode.h>
105 #include <ufs/ext2fs/ext2fs_dir.h>
106 #include <ufs/ext2fs/ext2fs.h>
107 #include <sys/ioctl.h>
108
109 #include <err.h>
110 #include <errno.h>
111 #include <inttypes.h>
112 #include <string.h>
113 #include <unistd.h>
114 #include <stdint.h>
115 #include <stdlib.h>
116 #include <stddef.h>
117 #include <stdio.h>
118
119 #include "extern.h"
120
121 static void initcg(uint);
122 static void zap_old_sblock(daddr32_t);
123 static uint cgoverhead(uint);
124 static int fsinit(const struct timeval *);
125 static int makedir(struct ext2fs_direct *, int);
126 static void copy_dir(struct ext2fs_direct *, struct ext2fs_direct *);
127 static void init_resizeino(const struct timeval *);
128 static uint32_t alloc(uint32_t, uint16_t);
129 static void iput(struct ext2fs_dinode *, ino_t);
130 static void rdfs(daddr32_t, int, void *);
131 static void wtfs(daddr32_t, int, void *);
132 static int ilog2(uint);
133 static int skpc(int, size_t, uint8_t *);
134 static void uuid_get(struct m_ext2fs *);
135
136 /* XXX: some of these macro should be into <ufs/ext2fs/ext2fs.h>? */
137 #define EXT2_DEF_MAX_MNT_COUNT 20
138 #define EXT2_DEF_FSCKINTV (180 * 24 * 60 * 60) /* 180 days */
139 #define EXT2_RESERVED_INODES (EXT2_FIRSTINO - 1)
140 #define EXT2_UMASK 0755
141
142 #define EXT2_INO_INDEX(ino) ((ino) - 1) /* no inode zero */
143
144 #define EXT2_LOSTFOUNDSIZE 16384
145 #define EXT2_LOSTFOUNDINO EXT2_FIRSTINO /* XXX: not quite */
146 #define EXT2_LOSTFOUNDUMASK 0700
147
148 #define EXT2_RESIZEINOUMASK 0600
149
150 #define NBLOCK_SUPERBLOCK 1
151 #define NBLOCK_BLOCK_BITMAP 1
152 #define NBLOCK_INODE_BITMAP 1
153
154 #define cgbase(fs, c) \
155 ((fs)->e2fs.e2fs_first_dblock + (fs)->e2fs.e2fs_bpg * (c))
156
157 #define rounddown(x,y) (((x)/(y))*(y))
158
159 /*
160 * ext2fs super block and group descriptor structures
161 *
162 * We don't have to use or setup whole in-memory m_ext2fs structure,
163 * but prepare it to use several macro defined in kernel headers.
164 */
165 union {
166 struct m_ext2fs m_ext2fs;
167 char pad[SBSIZE];
168 } ext2fsun;
169 #define sblock ext2fsun.m_ext2fs
170 #define gd ext2fsun.m_ext2fs.e2fs_gd
171
172 static uint8_t *iobuf; /* for superblock and group descriptors */
173 static int iobufsize;
174
175 static uint8_t buf[MAXBSIZE]; /* for initcg() and makedir() ops */
176
177 static int fd;
178
179 extern int max_cols;
180
181 void
mke2fs(const char * fsys,int f)182 mke2fs(const char *fsys, int f)
183 {
184 struct timeval tv;
185 int64_t minfssize;
186 uint bcount, fbcount, ficount;
187 uint blocks_gd, blocks_per_cg, inodes_per_cg, iblocks_per_cg;
188 uint minblocks_per_cg, blocks_lastcg;
189 uint ncg, cylno, sboff;
190 int i, len, col, delta, fld_width;
191
192 gettimeofday(&tv, NULL);
193 fd = f;
194
195 /*
196 * collect and verify the block and fragment sizes
197 */
198 if (!powerof2(bsize)) {
199 errx(EXIT_FAILURE,
200 "block size must be a power of 2, not %u\n",
201 bsize);
202 }
203 if (!powerof2(fsize)) {
204 errx(EXIT_FAILURE,
205 "fragment size must be a power of 2, not %u\n",
206 fsize);
207 }
208 if (fsize < sectorsize) {
209 errx(EXIT_FAILURE,
210 "fragment size %u is too small, minimum is %u\n",
211 fsize, sectorsize);
212 }
213 if (bsize < MINBSIZE) {
214 errx(EXIT_FAILURE,
215 "block size %u is too small, minimum is %u\n",
216 bsize, MINBSIZE);
217 }
218 if (bsize > EXT2_MAXBSIZE) {
219 errx(EXIT_FAILURE,
220 "block size %u is too large, maximum is %u\n",
221 bsize, MAXBSIZE);
222 }
223 if (bsize != fsize) {
224 /*
225 * There is no fragment support on current ext2fs (yet?),
226 * but some kernel code refers fsize or fpg as bsize or bpg
227 * and Linux seems to set the same values to them.
228 */
229 errx(EXIT_FAILURE,
230 "block size (%u) can't be different from "
231 "fragment size (%u)\n",
232 bsize, fsize);
233 }
234
235 /* variable inodesize is REV1 feature */
236 if (Oflag == 0 && inodesize != EXT2_REV0_DINODE_SIZE) {
237 errx(EXIT_FAILURE, "GOOD_OLD_REV file system format"
238 " doesn't support %d byte inode\n", inodesize);
239 }
240
241 sblock.e2fs.e2fs_log_bsize = ilog2(bsize) - LOG_MINBSIZE;
242 sblock.e2fs.e2fs_log_fsize = ilog2(fsize) - LOG_MINFSIZE;
243
244 sblock.e2fs_bsize = bsize;
245 sblock.e2fs_fsize = fsize;
246 sblock.e2fs_bshift = sblock.e2fs.e2fs_log_bsize + LOG_MINBSIZE;
247 sblock.e2fs_qbmask = sblock.e2fs_bsize - 1;
248 sblock.e2fs_bmask = ~sblock.e2fs_qbmask;
249 sblock.e2fs_fsbtodb = ilog2(sblock.e2fs_bsize) - ilog2(sectorsize);
250 sblock.e2fs_ipb = sblock.e2fs_bsize / inodesize;
251
252 /*
253 * Ext2fs preserves BBSIZE (1024 bytes) space at the top for
254 * bootloader (though it is not enough at all for our bootloader).
255 * If bsize == BBSIZE we have to preserve one block.
256 * If bsize > BBSIZE, the first block already contains BBSIZE space
257 * before superblock because superblock is allocated at SBOFF and
258 * bsize is a power of two (i.e. 2048 bytes or more).
259 */
260 sblock.e2fs.e2fs_first_dblock = (sblock.e2fs_bsize > BBSIZE) ? 0 : 1;
261 minfssize = fsbtodb(&sblock,
262 sblock.e2fs.e2fs_first_dblock +
263 NBLOCK_SUPERBLOCK +
264 1 /* at least one group descriptor */ +
265 NBLOCK_BLOCK_BITMAP +
266 NBLOCK_INODE_BITMAP +
267 1 /* at least one inode table block */ +
268 1 /* at least one data block for rootdir */ +
269 1 /* at least one data block for data */
270 ); /* XXX and more? */
271
272 if (fssize < minfssize)
273 errx(EXIT_FAILURE, "Filesystem size %" PRId64
274 " < minimum size of %" PRId64 "\n", fssize, minfssize);
275
276 bcount = dbtofsb(&sblock, fssize);
277
278 /*
279 * While many people claim that ext2fs is a (bad) clone of ufs/ffs,
280 * it isn't actual ffs so maybe we should call it "block group"
281 * as their native name rather than ffs derived "cylinder group."
282 * But we'll use the latter here since other kernel sources use it.
283 * (I also agree "cylinder" based allocation is obsolete though)
284 */
285
286 /* maybe "simple is the best" */
287 blocks_per_cg = sblock.e2fs_bsize * NBBY;
288
289 ncg = howmany(bcount - sblock.e2fs.e2fs_first_dblock, blocks_per_cg);
290 blocks_gd = howmany(sizeof(struct ext2_gd) * ncg, bsize);
291
292 /* check range of inode number */
293 if (num_inodes < EXT2_FIRSTINO)
294 num_inodes = EXT2_FIRSTINO; /* needs reserved inodes + 1 */
295 if (num_inodes > UINT16_MAX * ncg)
296 num_inodes = UINT16_MAX * ncg; /* ext2bgd_nifree is uint16_t */
297
298 inodes_per_cg = num_inodes / ncg;
299 iblocks_per_cg = howmany(inodesize * inodes_per_cg, bsize);
300
301 /* Check that the last cylinder group has enough space for inodes */
302 minblocks_per_cg =
303 NBLOCK_BLOCK_BITMAP +
304 NBLOCK_INODE_BITMAP +
305 iblocks_per_cg +
306 1; /* at least one data block */
307 if (Oflag == 0 || cg_has_sb(ncg - 1) != 0)
308 minblocks_per_cg += NBLOCK_SUPERBLOCK + blocks_gd;
309
310 blocks_lastcg = bcount - sblock.e2fs.e2fs_first_dblock -
311 blocks_per_cg * (ncg - 1);
312 if (blocks_lastcg < minblocks_per_cg) {
313 /*
314 * Since we make all the cylinder groups the same size, the
315 * last will only be small if there are more than one
316 * cylinder groups. If the last one is too small to store
317 * filesystem data, just kill it.
318 *
319 * XXX: Does fsck_ext2fs(8) properly handle this case?
320 */
321 bcount -= blocks_lastcg;
322 ncg--;
323 blocks_lastcg = blocks_per_cg;
324 blocks_gd = howmany(sizeof(struct ext2_gd) * ncg, bsize);
325 inodes_per_cg = num_inodes / ncg;
326 }
327 /* roundup inodes_per_cg to make it use whole inode table blocks */
328 inodes_per_cg = roundup(inodes_per_cg, sblock.e2fs_ipb);
329 num_inodes = inodes_per_cg * ncg;
330 iblocks_per_cg = inodes_per_cg / sblock.e2fs_ipb;
331
332 /* XXX: probably we should check these adjusted values again */
333
334 sblock.e2fs.e2fs_bcount = bcount;
335 sblock.e2fs.e2fs_icount = num_inodes;
336
337 sblock.e2fs_ncg = ncg;
338 sblock.e2fs_ngdb = blocks_gd;
339 sblock.e2fs_itpg = iblocks_per_cg;
340
341 sblock.e2fs.e2fs_rbcount = sblock.e2fs.e2fs_bcount * minfree / 100;
342 /* e2fs_fbcount will be accounted later */
343 /* e2fs_ficount will be accounted later */
344
345 sblock.e2fs.e2fs_bpg = blocks_per_cg;
346 sblock.e2fs.e2fs_fpg = blocks_per_cg;
347
348 sblock.e2fs.e2fs_ipg = inodes_per_cg;
349
350 sblock.e2fs.e2fs_mtime = 0;
351 sblock.e2fs.e2fs_wtime = (u_int32_t)tv.tv_sec;
352 sblock.e2fs.e2fs_mnt_count = 0;
353 /* XXX: should add some entropy to avoid checking all fs at once? */
354 sblock.e2fs.e2fs_max_mnt_count = EXT2_DEF_MAX_MNT_COUNT;
355
356 sblock.e2fs.e2fs_magic = E2FS_MAGIC;
357 sblock.e2fs.e2fs_state = E2FS_ISCLEAN;
358 sblock.e2fs.e2fs_beh = E2FS_BEH_DEFAULT;
359 sblock.e2fs.e2fs_minrev = 0;
360 sblock.e2fs.e2fs_lastfsck = (u_int32_t)tv.tv_sec;
361 sblock.e2fs.e2fs_fsckintv = EXT2_DEF_FSCKINTV;
362
363 /*
364 * Maybe we can use E2FS_OS_FREEBSD here and it would be more proper,
365 * but the purpose of this newfs_ext2fs(8) command is to provide
366 * a filesystem which can be recognized by firmware on some
367 * Linux based appliances that can load bootstrap files only from
368 * (their native) ext2fs, and anyway we will (and should) try to
369 * act like them as much as possible.
370 *
371 * Anyway, I hope that all newer such boxes will keep their support
372 * for the "GOOD_OLD_REV" ext2fs.
373 */
374 sblock.e2fs.e2fs_creator = E2FS_OS_LINUX;
375
376 if (Oflag == 0) {
377 sblock.e2fs.e2fs_rev = E2FS_REV0;
378 sblock.e2fs.e2fs_features_compat = 0;
379 sblock.e2fs.e2fs_features_incompat = 0;
380 sblock.e2fs.e2fs_features_rocompat = 0;
381 } else {
382 sblock.e2fs.e2fs_rev = E2FS_REV1;
383 /*
384 * e2fsprogs say "REV1" is "dynamic" so
385 * it isn't quite a version and maybe it means
386 * "extended from REV0 so check compat features."
387 *
388 * XXX: We don't have any native tool to activate
389 * the EXT2F_COMPAT_RESIZE feature and
390 * fsck_ext2fs(8) might not fix structures for it.
391 */
392 sblock.e2fs.e2fs_features_compat = EXT2F_COMPAT_RESIZE;
393 sblock.e2fs.e2fs_features_incompat = EXT2F_INCOMPAT_FTYPE;
394 sblock.e2fs.e2fs_features_rocompat =
395 EXT2F_ROCOMPAT_SPARSE_SUPER | EXT2F_ROCOMPAT_LARGE_FILE;
396 }
397
398 sblock.e2fs.e2fs_ruid = geteuid();
399 sblock.e2fs.e2fs_rgid = getegid();
400
401 sblock.e2fs.e2fs_first_ino = EXT2_FIRSTINO;
402 sblock.e2fs.e2fs_inode_size = inodesize;
403
404 /* e2fs_block_group_nr is set on writing superblock to each group */
405
406 uuid_get(&sblock);
407 if (volname != NULL) {
408 if (strlen(volname) > sizeof(sblock.e2fs.e2fs_vname))
409 errx(EXIT_FAILURE, "Volume name is too long");
410 strlcpy(sblock.e2fs.e2fs_vname, volname,
411 sizeof(sblock.e2fs.e2fs_vname));
412 }
413
414 sblock.e2fs.e2fs_fsmnt[0] = '\0';
415 sblock.e2fs_fsmnt[0] = '\0';
416
417 sblock.e2fs.e2fs_algo = 0; /* XXX unsupported? */
418 sblock.e2fs.e2fs_prealloc = 0; /* XXX unsupported? */
419 sblock.e2fs.e2fs_dir_prealloc = 0; /* XXX unsupported? */
420
421 /* calculate blocks for reserved group descriptors for resize */
422 sblock.e2fs.e2fs_reserved_ngdb = 0;
423 if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
424 (sblock.e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE) != 0) {
425 uint64_t target_blocks;
426 uint target_ncg, target_ngdb, reserved_ngdb;
427
428 /* reserve descriptors for size as 1024 times as current */
429 target_blocks =
430 (sblock.e2fs.e2fs_bcount - sblock.e2fs.e2fs_first_dblock)
431 * 1024ULL;
432 /* number of blocks must be in uint32_t */
433 if (target_blocks > UINT32_MAX)
434 target_blocks = UINT32_MAX;
435 target_ncg = howmany(target_blocks, sblock.e2fs.e2fs_bpg);
436 target_ngdb = howmany(sizeof(struct ext2_gd) * target_ncg,
437 sblock.e2fs_bsize);
438 /*
439 * Reserved group descriptor blocks are preserved as
440 * the second level double indirect reference blocks in
441 * the EXT2_RESIZEINO inode, so the maximum number of
442 * the blocks is NINDIR(fs).
443 * (see also descriptions in init_resizeino() function)
444 *
445 * We check a number including current e2fs_ngdb here
446 * because they will be moved into reserved gdb on
447 * possible future size shrink, though e2fsprogs don't
448 * seem to care about it.
449 */
450 if (target_ngdb > NINDIR(&sblock))
451 target_ngdb = NINDIR(&sblock);
452
453 reserved_ngdb = target_ngdb - sblock.e2fs_ngdb;
454
455 /* make sure reserved_ngdb fits in the last cg */
456 if (reserved_ngdb >= blocks_lastcg - cgoverhead(ncg - 1))
457 reserved_ngdb = blocks_lastcg - cgoverhead(ncg - 1);
458 if (reserved_ngdb == 0) {
459 /* if no space for reserved gdb, disable the feature */
460 sblock.e2fs.e2fs_features_compat &=
461 ~EXT2F_COMPAT_RESIZE;
462 }
463 sblock.e2fs.e2fs_reserved_ngdb = reserved_ngdb;
464 }
465
466 /*
467 * Initialize group descriptors
468 */
469 gd = calloc(sblock.e2fs_ngdb, bsize);
470 if (gd == NULL)
471 errx(EXIT_FAILURE, "Can't allocate descriptors buffer");
472
473 fbcount = 0;
474 ficount = 0;
475 for (cylno = 0; cylno < ncg; cylno++) {
476 uint boffset;
477
478 boffset = cgbase(&sblock, cylno);
479 if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||
480 (sblock.e2fs.e2fs_features_rocompat &
481 EXT2F_ROCOMPAT_SPARSE_SUPER) == 0 ||
482 cg_has_sb(cylno)) {
483 boffset += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;
484 if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
485 (sblock.e2fs.e2fs_features_compat &
486 EXT2F_COMPAT_RESIZE) != 0)
487 boffset += sblock.e2fs.e2fs_reserved_ngdb;
488 }
489 gd[cylno].ext2bgd_b_bitmap = boffset;
490 boffset += NBLOCK_BLOCK_BITMAP;
491 gd[cylno].ext2bgd_i_bitmap = boffset;
492 boffset += NBLOCK_INODE_BITMAP;
493 gd[cylno].ext2bgd_i_tables = boffset;
494 if (cylno == (ncg - 1))
495 gd[cylno].ext2bgd_nbfree =
496 blocks_lastcg - cgoverhead(cylno);
497 else
498 gd[cylno].ext2bgd_nbfree =
499 sblock.e2fs.e2fs_bpg - cgoverhead(cylno);
500 fbcount += gd[cylno].ext2bgd_nbfree;
501 gd[cylno].ext2bgd_nifree = sblock.e2fs.e2fs_ipg;
502 if (cylno == 0) {
503 /* take reserved inodes off nifree */
504 gd[cylno].ext2bgd_nifree -= EXT2_RESERVED_INODES;
505 }
506 ficount += gd[cylno].ext2bgd_nifree;
507 gd[cylno].ext2bgd_ndirs = 0;
508 }
509 sblock.e2fs.e2fs_fbcount = fbcount;
510 sblock.e2fs.e2fs_ficount = ficount;
511
512 /*
513 * Dump out summary information about file system.
514 */
515 if (verbosity > 0) {
516 printf("%s: %u.%1uMB (%" PRId64 " sectors) "
517 "block size %u, fragment size %u\n",
518 fsys,
519 (uint)(((uint64_t)bcount * bsize) / (1024 * 1024)),
520 (uint)((uint64_t)bcount * bsize -
521 rounddown((uint64_t)bcount * bsize, 1024 * 1024))
522 / 1024 / 100,
523 fssize, bsize, fsize);
524 printf("\tusing %u block groups of %u.0MB, %u blks, "
525 "%u inodes.\n",
526 ncg, bsize * sblock.e2fs.e2fs_bpg / (1024 * 1024),
527 sblock.e2fs.e2fs_bpg, sblock.e2fs.e2fs_ipg);
528 }
529
530 /*
531 * allocate space for superblock and group descriptors
532 */
533 iobufsize = (NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb) * sblock.e2fs_bsize;
534 iobuf = mmap(0, iobufsize, PROT_READ|PROT_WRITE,
535 MAP_ANON|MAP_PRIVATE, -1, 0);
536 if (iobuf == MAP_FAILED)
537 errx(EXIT_FAILURE, "Cannot allocate I/O buffer\n");
538
539 /*
540 * We now start writing to the filesystem
541 */
542
543 if (!Nflag) {
544 static const uint pbsize[] = { 1024, 2048, 4096, 0 };
545 uint pblock, epblock;
546 /*
547 * Validate the given file system size.
548 * Verify that its last block can actually be accessed.
549 * Convert to file system fragment sized units.
550 */
551 if (fssize <= 0)
552 errx(EXIT_FAILURE, "Preposterous size %" PRId64 "\n",
553 fssize);
554 wtfs(fssize - 1, sectorsize, iobuf);
555
556 /*
557 * Ensure there is nothing that looks like a filesystem
558 * superblock anywhere other than where ours will be.
559 * If fsck_ext2fs finds the wrong one all hell breaks loose!
560 *
561 * XXX: needs to check how fsck_ext2fs programs even
562 * on other OSes determine alternate superblocks
563 */
564 for (i = 0; pbsize[i] != 0; i++) {
565 epblock = (uint64_t)bcount * bsize / pbsize[i];
566 for (pblock = ((pbsize[i] == SBSIZE) ? 1 : 0);
567 pblock < epblock;
568 pblock += pbsize[i] * NBBY /* bpg */)
569 zap_old_sblock((daddr32_t)pblock *
570 pbsize[i] / sectorsize);
571 }
572 }
573
574 if (verbosity >= 3)
575 printf("super-block backups (for fsck_ext2fs -b #) at:\n");
576 /* If we are printing more than one line of numbers, line up columns */
577 fld_width = verbosity < 4 ? 1 : snprintf(NULL, 0, "%" PRIu64,
578 (uint64_t)cgbase(&sblock, ncg - 1));
579 if (Nflag && verbosity == 3)
580 /* Leave space to add " ..." after one row of numbers */
581 max_cols -= 4;
582 #define BASE 0x10000 /* For some fixed-point maths */
583 col = 0;
584 delta = verbosity > 2 ? 0 : max_cols * BASE / ncg;
585 for (cylno = 0; cylno < ncg; cylno++) {
586 fflush(stdout);
587 initcg(cylno);
588 if (verbosity < 2)
589 continue;
590 /* the first one is a master, not backup */
591 if (cylno == 0)
592 continue;
593 /* skip if this cylinder doesn't have a backup */
594 if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
595 (sblock.e2fs.e2fs_features_rocompat &
596 EXT2F_ROCOMPAT_SPARSE_SUPER) != 0 &&
597 cg_has_sb(cylno) == 0)
598 continue;
599
600 if (delta > 0) {
601 if (Nflag)
602 /* No point doing dots for -N */
603 break;
604 /* Print dots scaled to end near RH margin */
605 for (col += delta; col > BASE; col -= BASE)
606 printf(".");
607 continue;
608 }
609 /* Print superblock numbers */
610 len = printf("%s%*" PRIu64 ",", (col ? " " : ""), fld_width,
611 (uint64_t)cgbase(&sblock, cylno));
612 col += len;
613 if (col + len < max_cols)
614 /* Next number fits */
615 continue;
616 /* Next number won't fit, need a newline */
617 if (verbosity <= 3) {
618 /* Print dots for subsequent cylinder groups */
619 delta = sblock.e2fs_ncg - cylno - 1;
620 if (delta != 0) {
621 if (Nflag) {
622 printf(" ...");
623 break;
624 }
625 delta = max_cols * BASE / delta;
626 }
627 }
628 col = 0;
629 printf("\n");
630 }
631 #undef BASE
632 if (col > 0)
633 printf("\n");
634 if (Nflag)
635 return;
636
637 /*
638 * Now construct the initial file system,
639 */
640 if (fsinit(&tv) == 0)
641 errx(EXIT_FAILURE, "Error making filesystem");
642 /*
643 * Write out the superblock and group descriptors
644 */
645 sblock.e2fs.e2fs_block_group_nr = 0;
646 sboff = 0;
647 if (cgbase(&sblock, 0) == 0) {
648 /*
649 * If the first block contains the boot block sectors,
650 * (i.e. in case of sblock.e2fs.e2fs_bsize > BBSIZE)
651 * we have to preserve data in it.
652 */
653 sboff = SBOFF;
654 }
655 e2fs_sbsave(&sblock.e2fs, (struct ext2fs *)(iobuf + sboff));
656 e2fs_cgsave(gd, (struct ext2_gd *)(iobuf + sblock.e2fs_bsize),
657 sizeof(struct ext2_gd) * sblock.e2fs_ncg);
658 wtfs(fsbtodb(&sblock, cgbase(&sblock, 0)) + sboff / sectorsize,
659 iobufsize - sboff, iobuf + sboff);
660
661 munmap(iobuf, iobufsize);
662 }
663
664 /*
665 * Initialize a cylinder (block) group.
666 */
667 void
initcg(uint cylno)668 initcg(uint cylno)
669 {
670 uint nblcg, i, j, sboff;
671 struct ext2fs_dinode *dp;
672
673 /*
674 * Make a copy of the superblock and group descriptors.
675 */
676 if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||
677 (sblock.e2fs.e2fs_features_rocompat &
678 EXT2F_ROCOMPAT_SPARSE_SUPER) == 0 ||
679 cg_has_sb(cylno)) {
680 sblock.e2fs.e2fs_block_group_nr = cylno;
681 sboff = 0;
682 if (cgbase(&sblock, cylno) == 0) {
683 /* preserve data in bootblock in cg0 */
684 sboff = SBOFF;
685 }
686 e2fs_sbsave(&sblock.e2fs, (struct ext2fs *)(iobuf + sboff));
687 e2fs_cgsave(gd, (struct ext2_gd *)(iobuf +
688 sblock.e2fs_bsize * NBLOCK_SUPERBLOCK),
689 sizeof(struct ext2_gd) * sblock.e2fs_ncg);
690 /* write superblock and group descriptor backups */
691 wtfs(fsbtodb(&sblock, cgbase(&sblock, cylno)) +
692 sboff / sectorsize, iobufsize - sboff, iobuf + sboff);
693 }
694
695 /*
696 * Initialize block bitmap.
697 */
698 memset(buf, 0, sblock.e2fs_bsize);
699 if (cylno == (sblock.e2fs_ncg - 1)) {
700 /* The last group could have less blocks than e2fs_bpg. */
701 nblcg = sblock.e2fs.e2fs_bcount -
702 cgbase(&sblock, sblock.e2fs_ncg - 1);
703 for (i = nblcg; i < roundup(nblcg, NBBY); i++)
704 setbit(buf, i);
705 memset(&buf[i / NBBY], ~0U, sblock.e2fs.e2fs_bpg - i);
706 }
707 /* set overhead (superblock, group descriptor etc.) blocks used */
708 for (i = 0; i < cgoverhead(cylno) / NBBY; i++)
709 buf[i] = ~0;
710 i = i * NBBY;
711 for (; i < cgoverhead(cylno); i++)
712 setbit(buf, i);
713 wtfs(fsbtodb(&sblock, gd[cylno].ext2bgd_b_bitmap), sblock.e2fs_bsize,
714 buf);
715
716 /*
717 * Initialize inode bitmap.
718 *
719 * Assume e2fs_ipg is a multiple of NBBY since
720 * it's a multiple of e2fs_ipb (as we did above).
721 * Note even (possibly smaller) the last group has the same e2fs_ipg.
722 */
723 i = sblock.e2fs.e2fs_ipg / NBBY;
724 memset(buf, 0, i);
725 memset(buf + i, ~0U, sblock.e2fs_bsize - i);
726 if (cylno == 0) {
727 /* mark reserved inodes */
728 for (i = 1; i < EXT2_FIRSTINO; i++)
729 setbit(buf, EXT2_INO_INDEX(i));
730 }
731 wtfs(fsbtodb(&sblock, gd[cylno].ext2bgd_i_bitmap), sblock.e2fs_bsize,
732 buf);
733
734 /*
735 * Initialize inode tables.
736 *
737 * Just initialize generation numbers for NFS security.
738 * XXX: sys/ufs/ext2fs/ext2fs_alloc.c:ext2fs_valloc() seems
739 * to override these generated numbers.
740 */
741 memset(buf, 0, sblock.e2fs_bsize);
742 for (i = 0; i < sblock.e2fs_itpg; i++) {
743 for (j = 0; j < sblock.e2fs_ipb; j++) {
744 dp = (struct ext2fs_dinode *)(buf + inodesize * j);
745 /* If there is some bias in arc4random(), keep it. */
746 dp->e2di_gen = htole32(arc4random());
747 }
748 wtfs(fsbtodb(&sblock, gd[cylno].ext2bgd_i_tables + i),
749 sblock.e2fs_bsize, buf);
750 }
751 }
752
753 /*
754 * Zap possible lingering old superblock data
755 */
756 static void
zap_old_sblock(daddr32_t sec)757 zap_old_sblock(daddr32_t sec)
758 {
759 static daddr32_t cg0_data;
760 uint32_t oldfs[SBSIZE / sizeof(uint32_t)];
761 static const struct fsm {
762 uint32_t offset;
763 uint32_t magic;
764 uint32_t mask;
765 } fs_magics[] = {
766 {offsetof(struct ext2fs, e2fs_magic) / 4, E2FS_MAGIC, 0xffff},
767 {offsetof(struct ext2fs, e2fs_magic) / 4,
768 E2FS_MAGIC << 16, 0xffff0000},
769 {14, 0xef530000, 0xffff0000}, /* EXT2FS (big) */
770 {0x55c / 4, 0x00011954, ~0U}, /* FS_UFS1_MAGIC */
771 {0x55c / 4, 0x19540119, ~0U}, /* FS_UFS2_MAGIC */
772 {0, 0x70162, ~0U}, /* LFS_MAGIC */
773 {.offset = ~0U},
774 };
775 const struct fsm *fsm;
776
777 if (Nflag)
778 return;
779
780 /* don't override data before superblock */
781 if (sec < SBOFF / sectorsize)
782 return;
783
784 if (cg0_data == 0) {
785 cg0_data =
786 ((daddr32_t)sblock.e2fs.e2fs_first_dblock + cgoverhead(0)) *
787 sblock.e2fs_bsize / sectorsize;
788 }
789
790 /* Ignore anything that is beyond our filesystem */
791 if (sec >= fssize)
792 return;
793 /* Zero anything inside our filesystem... */
794 if (sec >= sblock.e2fs.e2fs_first_dblock * bsize / sectorsize) {
795 /* ...unless we will write that area anyway */
796 if (sec >= cg0_data)
797 /* assume iobuf is zero'ed here */
798 wtfs(sec, roundup(SBSIZE, sectorsize), iobuf);
799 return;
800 }
801
802 /*
803 * The sector might contain boot code, so we must validate it
804 *
805 * XXX: ext2fs won't preserve data after SBOFF,
806 * but first_dblock could have a different value.
807 */
808 rdfs(sec, sizeof(oldfs), &oldfs);
809 for (fsm = fs_magics;; fsm++) {
810 uint32_t v;
811 if (fsm->mask == 0)
812 return;
813 v = oldfs[fsm->offset];
814 if ((v & fsm->mask) == fsm->magic ||
815 (swap32(v) & fsm->mask) == fsm->magic)
816 break;
817 }
818
819 /* Just zap the magic number */
820 oldfs[fsm->offset] = 0;
821 wtfs(sec, sizeof(oldfs), &oldfs);
822 }
823
824 /*
825 * uint cgoverhead(uint c)
826 *
827 * Return a number of reserved blocks on the specified group.
828 * XXX: should be shared with src/sbin/fsck_ext2fs/setup.c
829 */
830 uint
cgoverhead(uint c)831 cgoverhead(uint c)
832 {
833 uint overh;
834
835 overh = NBLOCK_BLOCK_BITMAP + NBLOCK_INODE_BITMAP + sblock.e2fs_itpg;
836
837 if (sblock.e2fs.e2fs_rev == E2FS_REV0 ||
838 (sblock.e2fs.e2fs_features_rocompat &
839 EXT2F_ROCOMPAT_SPARSE_SUPER) == 0 ||
840 cg_has_sb(c) != 0) {
841 overh += NBLOCK_SUPERBLOCK + sblock.e2fs_ngdb;
842
843 if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
844 (sblock.e2fs.e2fs_features_compat &
845 EXT2F_COMPAT_RESIZE) != 0)
846 overh += sblock.e2fs.e2fs_reserved_ngdb;
847 }
848
849 return overh;
850 }
851
852 /*
853 * Initialize the file system
854 */
855
856 #define LOSTDIR /* e2fsck complains if there is no lost+found */
857
858 #define PREDEFDIR 2
859
860 #ifdef LOSTDIR
861 #define PREDEFROOTDIR (PREDEFDIR + 1)
862 #else
863 #define PREDEFROOTDIR PREDEFDIR
864 #endif
865
866 struct ext2fs_direct root_dir[] = {
867 { EXT2_ROOTINO, 0, 1, 0, "." },
868 { EXT2_ROOTINO, 0, 2, 0, ".." },
869 #ifdef LOSTDIR
870 { EXT2_LOSTFOUNDINO, 0, 10, 0, "lost+found" },
871 #endif
872 };
873
874 #ifdef LOSTDIR
875 struct ext2fs_direct lost_found_dir[] = {
876 { EXT2_LOSTFOUNDINO, 0, 1, 0, "." },
877 { EXT2_ROOTINO, 0, 2, 0, ".." },
878 };
879 struct ext2fs_direct pad_dir = { 0, sizeof(struct ext2fs_direct), 0, 0, "" };
880 #endif
881
882 int
fsinit(const struct timeval * tv)883 fsinit(const struct timeval *tv)
884 {
885 struct ext2fs_dinode node;
886 #ifdef LOSTDIR
887 uint i, nblks_lostfound, blk;
888 #endif
889
890 /*
891 * Initialize the inode for the resizefs feature
892 */
893 if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
894 (sblock.e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE) != 0)
895 init_resizeino(tv);
896
897 /*
898 * Initialize the node
899 */
900
901 #ifdef LOSTDIR
902 /*
903 * Create the lost+found directory
904 */
905 if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
906 sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE) {
907 lost_found_dir[0].e2d_type = EXT2_FT_DIR;
908 lost_found_dir[1].e2d_type = EXT2_FT_DIR;
909 }
910 (void)makedir(lost_found_dir, nitems(lost_found_dir));
911
912 /* prepare a bit large directory for preserved files */
913 nblks_lostfound = EXT2_LOSTFOUNDSIZE / sblock.e2fs_bsize;
914 /* ...but only with direct blocks */
915 if (nblks_lostfound > NDADDR)
916 nblks_lostfound = NDADDR;
917
918 memset(&node, 0, sizeof(node));
919 node.e2di_mode = EXT2_IFDIR | EXT2_LOSTFOUNDUMASK;
920 node.e2di_uid_low = geteuid();
921 node.e2di_size = sblock.e2fs_bsize * nblks_lostfound;
922 node.e2di_atime = (u_int32_t)tv->tv_sec;
923 node.e2di_ctime = (u_int32_t)tv->tv_sec;
924 node.e2di_mtime = (u_int32_t)tv->tv_sec;
925 node.e2di_gid_low = getegid();
926 node.e2di_nlink = PREDEFDIR;
927 /* e2di_nblock is a number of disk blocks, not ext2fs blocks */
928 node.e2di_nblock = fsbtodb(&sblock, nblks_lostfound);
929 node.e2di_blocks[0] = alloc(sblock.e2fs_bsize, node.e2di_mode);
930 if (node.e2di_blocks[0] == 0) {
931 printf("%s: can't allocate block for lost+found\n", __func__);
932 return 0;
933 }
934 for (i = 1; i < nblks_lostfound; i++) {
935 blk = alloc(sblock.e2fs_bsize, 0);
936 if (blk == 0) {
937 printf("%s: can't allocate blocks for lost+found\n",
938 __func__);
939 return 0;
940 }
941 node.e2di_blocks[i] = blk;
942 }
943 wtfs(fsbtodb(&sblock, node.e2di_blocks[0]), sblock.e2fs_bsize, buf);
944 pad_dir.e2d_reclen = sblock.e2fs_bsize;
945 for (i = 1; i < nblks_lostfound; i++) {
946 memset(buf, 0, sblock.e2fs_bsize);
947 copy_dir(&pad_dir, (struct ext2fs_direct *)buf);
948 wtfs(fsbtodb(&sblock, node.e2di_blocks[i]), sblock.e2fs_bsize,
949 buf);
950 }
951 iput(&node, EXT2_LOSTFOUNDINO);
952 #endif
953 /*
954 * create the root directory
955 */
956 memset(&node, 0, sizeof(node));
957 if (sblock.e2fs.e2fs_rev > E2FS_REV0 &&
958 sblock.e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE) {
959 root_dir[0].e2d_type = EXT2_FT_DIR;
960 root_dir[1].e2d_type = EXT2_FT_DIR;
961 #ifdef LOSTDIR
962 root_dir[2].e2d_type = EXT2_FT_DIR;
963 #endif
964 }
965 node.e2di_mode = EXT2_IFDIR | EXT2_UMASK;
966 node.e2di_uid_low = geteuid();
967 node.e2di_size = makedir(root_dir, nitems(root_dir));
968 node.e2di_atime = (u_int32_t)tv->tv_sec;
969 node.e2di_ctime = (u_int32_t)tv->tv_sec;
970 node.e2di_mtime = (u_int32_t)tv->tv_sec;
971 node.e2di_gid_low = getegid();
972 node.e2di_nlink = PREDEFROOTDIR;
973 /* e2di_nblock is a number of disk block, not ext2fs block */
974 node.e2di_nblock = fsbtodb(&sblock, 1);
975 node.e2di_blocks[0] = alloc(node.e2di_size, node.e2di_mode);
976 if (node.e2di_blocks[0] == 0) {
977 printf("%s: can't allocate block for root dir\n", __func__);
978 return 0;
979 }
980 wtfs(fsbtodb(&sblock, node.e2di_blocks[0]), sblock.e2fs_bsize, buf);
981 iput(&node, EXT2_ROOTINO);
982 return 1;
983 }
984
985 /*
986 * Construct a set of directory entries in "buf".
987 * return size of directory.
988 */
989 int
makedir(struct ext2fs_direct * protodir,int entries)990 makedir(struct ext2fs_direct *protodir, int entries)
991 {
992 uint8_t *cp;
993 uint i, spcleft;
994 uint dirblksiz;
995
996 dirblksiz = sblock.e2fs_bsize;
997 memset(buf, 0, dirblksiz);
998 spcleft = dirblksiz;
999 for (cp = buf, i = 0; i < entries - 1; i++) {
1000 protodir[i].e2d_reclen = EXT2FS_DIRSIZ(protodir[i].e2d_namlen);
1001 copy_dir(&protodir[i], (struct ext2fs_direct *)cp);
1002 cp += protodir[i].e2d_reclen;
1003 spcleft -= protodir[i].e2d_reclen;
1004 }
1005 protodir[i].e2d_reclen = spcleft;
1006 copy_dir(&protodir[i], (struct ext2fs_direct *)cp);
1007 return dirblksiz;
1008 }
1009
1010 /*
1011 * Copy a direntry to a buffer, in fs byte order
1012 */
1013 static void
copy_dir(struct ext2fs_direct * dir,struct ext2fs_direct * dbuf)1014 copy_dir(struct ext2fs_direct *dir, struct ext2fs_direct *dbuf)
1015 {
1016
1017 memcpy(dbuf, dir, EXT2FS_DIRSIZ(dir->e2d_namlen));
1018 dbuf->e2d_ino = htole32(dir->e2d_ino);
1019 dbuf->e2d_reclen = htole16(dir->e2d_reclen);
1020 }
1021
1022 /*
1023 * void init_resizeino(const struct timeval *tv);
1024 *
1025 * Initialize the EXT2_RESEIZE_INO inode to preserve
1026 * reserved group descriptor blocks for future growth of this ext2fs.
1027 */
1028 void
init_resizeino(const struct timeval * tv)1029 init_resizeino(const struct timeval *tv)
1030 {
1031 struct ext2fs_dinode node;
1032 uint64_t isize;
1033 uint32_t *dindir_block, *reserved_gdb;
1034 uint nblock, i, cylno, n;
1035
1036 memset(&node, 0, sizeof(node));
1037
1038 /*
1039 * Note this function only prepares required structures for
1040 * future resize. It's a quite different work to implement
1041 * a utility like resize_ext2fs(8) which handles actual
1042 * resize ops even on offline.
1043 *
1044 * Anyway, I'm not sure if there is any documentation about
1045 * this resize ext2fs feature and related data structures,
1046 * and I've written this function based on things what I see
1047 * on some existing implementation and real file system data
1048 * created by existing tools. To be honest, they are not
1049 * so easy to read, so I will try to implement it here without
1050 * any dumb optimization for people who would eventually
1051 * work on "yet another wheel" like resize_ext2fs(8).
1052 */
1053
1054 /*
1055 * I'm not sure what type is appropriate for this inode.
1056 * The release notes of e2fsprogs says they changed e2fsck to allow
1057 * IFREG for RESIZEINO since a certain resize tool used it. Hmm.
1058 */
1059 node.e2di_mode = EXT2_IFREG | EXT2_RESIZEINOUMASK;
1060 node.e2di_uid_low = geteuid();
1061 node.e2di_atime = (u_int32_t)tv->tv_sec;
1062 node.e2di_ctime = (u_int32_t)tv->tv_sec;
1063 node.e2di_mtime = (u_int32_t)tv->tv_sec;
1064 node.e2di_gid_low = getegid();
1065 node.e2di_nlink = 1;
1066
1067 /*
1068 * To preserve the reserved group descriptor blocks,
1069 * EXT2_RESIZEINO uses only double indirect reference
1070 * blocks in its inode entries.
1071 *
1072 * All entries for direct, single indirect and triple
1073 * indirect references are left zero'ed. Maybe it's safe
1074 * because no write operation will happen with this inode.
1075 *
1076 * We have to allocate a block for the first level double
1077 * indirect reference block. Indexes of inode entries in
1078 * this first level dindirect block are corresponding to
1079 * indexes of group descriptors including both used (e2fs_ngdb)
1080 * and reserved (e2fs_reserved_ngdb) group descriptor blocks.
1081 *
1082 * Inode entries of indexes for used (e2fs_ngdb) descriptors are
1083 * left zero'ed. Entries for reserved (e2fs_reserved_ngdb) ones
1084 * have block numbers of actual reserved group descriptors
1085 * allocated at block group zero. This means e2fs_reserved_ngdb
1086 * blocks are reserved as the second level dindirect reference
1087 * blocks, and they actually contain block numbers of indirect
1088 * references. It may be safe since they don't have to keep any
1089 * data yet.
1090 *
1091 * Each these second dindirect blocks (i.e. reserved group
1092 * descriptor blocks in the first block group) should have
1093 * block numbers of its backups in all other block groups.
1094 * I.e. reserved_ngdb[0] block in block group 0 contains block
1095 * numbers of resreved_ngdb[0] from group 1 through (e2fs_ncg - 1).
1096 * The number of backups can be determined by the
1097 * EXT2_ROCOMPAT_SPARSESUPER feature and cg_has_sb() macro
1098 * as done in the above initcg() function.
1099 */
1100
1101 /* set e2di_size which occupies whole blocks through DINDIR blocks */
1102 isize = (uint64_t)sblock.e2fs_bsize * NDADDR +
1103 (uint64_t)sblock.e2fs_bsize * NINDIR(&sblock) +
1104 (uint64_t)sblock.e2fs_bsize * NINDIR(&sblock) * NINDIR(&sblock);
1105 if (isize > UINT32_MAX &&
1106 (sblock.e2fs.e2fs_features_rocompat &
1107 EXT2F_ROCOMPAT_LARGE_FILE) == 0) {
1108 /* XXX should enable it here and update all backups? */
1109 errx(EXIT_FAILURE, "%s: large_file rocompat feature is "
1110 "required to enable resize feature for this filesystem\n",
1111 __func__);
1112 }
1113 /* upper 32bit is stored into e2di_size_hi on REV1 feature */
1114 node.e2di_size = isize & UINT32_MAX;
1115 node.e2di_size_hi = isize >> 32;
1116
1117 #define SINGLE 0 /* index of single indirect block */
1118 #define DOUBLE 1 /* index of double indirect block */
1119 #define TRIPLE 2 /* index of triple indirect block */
1120
1121 /* zero out entries for direct references */
1122 for (i = 0; i < NDADDR; i++)
1123 node.e2di_blocks[i] = 0;
1124 /* also zero out entries for single and triple indirect references */
1125 node.e2di_blocks[NDADDR + SINGLE] = 0;
1126 node.e2di_blocks[NDADDR + TRIPLE] = 0;
1127
1128 /* allocate a block for the first level double indirect reference */
1129 node.e2di_blocks[NDADDR + DOUBLE] =
1130 alloc(sblock.e2fs_bsize, node.e2di_mode);
1131 if (node.e2di_blocks[NDADDR + DOUBLE] == 0)
1132 errx(EXIT_FAILURE, "%s: Can't allocate a dindirect block",
1133 __func__);
1134
1135 /* account this first block */
1136 nblock = fsbtodb(&sblock, 1);
1137
1138 /* allocate buffer to set data in the dindirect block */
1139 dindir_block = malloc(sblock.e2fs_bsize);
1140 if (dindir_block == NULL)
1141 errx(EXIT_FAILURE,
1142 "%s: Can't allocate buffer for a dindirect block",
1143 __func__);
1144
1145 /* allocate buffer to set data in the group descriptor blocks */
1146 reserved_gdb = malloc(sblock.e2fs_bsize);
1147 if (reserved_gdb == NULL)
1148 errx(EXIT_FAILURE,
1149 "%s: Can't allocate buffer for group descriptor blocks",
1150 __func__);
1151
1152 /*
1153 * Setup block entries in the first level dindirect blocks
1154 */
1155 for (i = 0; i < sblock.e2fs_ngdb; i++) {
1156 /* no need to handle used group descriptor blocks */
1157 dindir_block[i] = 0;
1158 }
1159 for (; i < sblock.e2fs_ngdb + sblock.e2fs.e2fs_reserved_ngdb; i++) {
1160 /*
1161 * point reserved group descriptor block in the first
1162 * (i.e. master) block group
1163 *
1164 * XXX: e2fsprogs seem to use "(i % NINDIR(&sblock))" here
1165 * to store maximum NINDIR(&sblock) reserved gdbs.
1166 * I'm not sure what will be done on future filesystem
1167 * shrink in that case on their way.
1168 */
1169 if (i >= NINDIR(&sblock))
1170 errx(EXIT_FAILURE, "%s: too many reserved "
1171 "group descriptors (%u) for resize inode",
1172 __func__, sblock.e2fs.e2fs_reserved_ngdb);
1173 dindir_block[i] =
1174 htole32(cgbase(&sblock, 0) + NBLOCK_SUPERBLOCK + i);
1175
1176 /*
1177 * Setup block entries in the second dindirect blocks
1178 * (which are primary reserved group descriptor blocks)
1179 * to point their backups.
1180 */
1181 for (n = 0, cylno = 1; cylno < sblock.e2fs_ncg; cylno++) {
1182 /* skip block groups without backup */
1183 if ((sblock.e2fs.e2fs_features_rocompat &
1184 EXT2F_ROCOMPAT_SPARSE_SUPER) != 0 &&
1185 cg_has_sb(cylno) == 0)
1186 continue;
1187
1188 if (n >= NINDIR(&sblock))
1189 errx(EXIT_FAILURE, "%s: too many block groups "
1190 "for the resize feature", __func__);
1191 /*
1192 * These blocks are already reserved in
1193 * initcg() so no need to use alloc() here.
1194 */
1195 reserved_gdb[n++] = htole32(cgbase(&sblock, cylno) +
1196 NBLOCK_SUPERBLOCK + i);
1197 nblock += fsbtodb(&sblock, 1);
1198 }
1199 for (; n < NINDIR(&sblock); n++)
1200 reserved_gdb[n] = 0;
1201
1202 /* write group descriptor block as the second dindirect refs */
1203 wtfs(fsbtodb(&sblock, letoh32(dindir_block[i])),
1204 sblock.e2fs_bsize, reserved_gdb);
1205 nblock += fsbtodb(&sblock, 1);
1206 }
1207 for (; i < NINDIR(&sblock); i++) {
1208 /* leave trailing entries unallocated */
1209 dindir_block[i] = 0;
1210 }
1211 free(reserved_gdb);
1212
1213 /* finally write the first level dindirect block */
1214 wtfs(fsbtodb(&sblock, node.e2di_blocks[NDADDR + DOUBLE]),
1215 sblock.e2fs_bsize, dindir_block);
1216 free(dindir_block);
1217
1218 node.e2di_nblock = nblock;
1219 iput(&node, EXT2_RESIZEINO);
1220 }
1221
1222 /*
1223 * uint32_t alloc(uint32_t size, uint16_t mode)
1224 *
1225 * Allocate a block (from cylinder group 0)
1226 * Reference: src/sys/ufs/ext2fs/ext2fs_alloc.c:ext2fs_alloccg()
1227 */
1228 uint32_t
alloc(uint32_t size,uint16_t mode)1229 alloc(uint32_t size, uint16_t mode)
1230 {
1231 uint32_t loc, bno;
1232 uint8_t *bbp;
1233 uint len, map, i;
1234
1235 if (gd[0].ext2bgd_nbfree == 0)
1236 return 0;
1237
1238 if (size > sblock.e2fs_bsize)
1239 return 0;
1240
1241 bbp = malloc(sblock.e2fs_bsize);
1242 if (bbp == NULL)
1243 return 0;
1244 rdfs(fsbtodb(&sblock, gd[0].ext2bgd_b_bitmap), sblock.e2fs_bsize, bbp);
1245
1246 /* XXX: kernel uses e2fs_fpg here */
1247 len = sblock.e2fs.e2fs_bpg / NBBY;
1248
1249 #if 0 /* no need block allocation for root or lost+found dir */
1250 for (loc = 0; loc < len; loc++) {
1251 if (bbp[loc] == 0) {
1252 bno = loc * NBBY;
1253 goto gotit;
1254 }
1255 }
1256 #endif
1257
1258 loc = skpc(~0U, len, bbp);
1259 if (loc == 0) {
1260 free(bbp);
1261 return 0;
1262 }
1263 loc = len - loc;
1264 map = bbp[loc];
1265 bno = loc * NBBY;
1266 for (i = 0; i < NBBY; i++, bno++) {
1267 if ((map & (1 << i)) == 0)
1268 goto gotit;
1269 }
1270 free(bbp);
1271 return 0;
1272
1273 gotit:
1274 if (isset(bbp, bno))
1275 errx(EXIT_FAILURE, "%s: inconsistent bitmap\n", __func__);
1276
1277 setbit(bbp, bno);
1278 wtfs(fsbtodb(&sblock, gd[0].ext2bgd_b_bitmap), sblock.e2fs_bsize, bbp);
1279 free(bbp);
1280 /* XXX: modified group descriptors won't be written into backups */
1281 gd[0].ext2bgd_nbfree--;
1282 if ((mode & EXT2_IFDIR) != 0)
1283 gd[0].ext2bgd_ndirs++;
1284 sblock.e2fs.e2fs_fbcount--;
1285
1286 return sblock.e2fs.e2fs_first_dblock + bno;
1287 }
1288
1289 /*
1290 * void iput(struct ext2fs_dinode *ip, ino_t ino)
1291 *
1292 * Put an inode entry into the corresponding table.
1293 */
1294 static void
iput(struct ext2fs_dinode * ip,ino_t ino)1295 iput(struct ext2fs_dinode *ip, ino_t ino)
1296 {
1297 daddr32_t d;
1298 uint c, i;
1299 struct ext2fs_dinode *dp;
1300 uint8_t *bp;
1301
1302 bp = malloc(sblock.e2fs_bsize);
1303 if (bp == NULL)
1304 errx(EXIT_FAILURE, "%s: can't allocate buffer for inode\n",
1305 __func__);
1306
1307 /*
1308 * Reserved inodes are allocated and accounted in initcg()
1309 * so skip checks of the bitmap and allocation for them.
1310 */
1311 if (ino >= EXT2_FIRSTINO) {
1312 c = ino_to_cg(&sblock, ino);
1313
1314 /* sanity check */
1315 if (gd[c].ext2bgd_nifree == 0)
1316 errx(EXIT_FAILURE,
1317 "%s: no free inode %" PRIu64 " in block group %u\n",
1318 __func__, (uint64_t)ino, c);
1319
1320 /* update inode bitmap */
1321 rdfs(fsbtodb(&sblock, gd[0].ext2bgd_i_bitmap),
1322 sblock.e2fs_bsize, bp);
1323
1324 /* more sanity */
1325 if (isset(bp, EXT2_INO_INDEX(ino)))
1326 errx(EXIT_FAILURE, "%s: inode %" PRIu64
1327 " already in use\n", __func__, (uint64_t)ino);
1328 setbit(bp, EXT2_INO_INDEX(ino));
1329 wtfs(fsbtodb(&sblock, gd[0].ext2bgd_i_bitmap),
1330 sblock.e2fs_bsize, bp);
1331 gd[c].ext2bgd_nifree--;
1332 sblock.e2fs.e2fs_ficount--;
1333 }
1334
1335 if (ino >= sblock.e2fs.e2fs_ipg * sblock.e2fs_ncg)
1336 errx(EXIT_FAILURE, "%s: inode value out of range (%" PRIu64
1337 ").\n", __func__, (uint64_t)ino);
1338
1339 /* update an inode entry in the table */
1340 d = fsbtodb(&sblock, ino_to_fsba(&sblock, ino));
1341 rdfs(d, sblock.e2fs_bsize, bp);
1342
1343 dp = (struct ext2fs_dinode *)(bp +
1344 inodesize * ino_to_fsbo(&sblock, ino));
1345 e2fs_isave(&sblock, ip, dp);
1346 /* e2fs_i_bswap() doesn't swap e2di_blocks addrs */
1347 if ((ip->e2di_mode & EXT2_IFMT) != EXT2_IFLNK) {
1348 for (i = 0; i < NDADDR + NIADDR; i++)
1349 dp->e2di_blocks[i] = htole32(ip->e2di_blocks[i]);
1350 }
1351 /* If there is some bias in arc4random(), keep it. */
1352 dp->e2di_gen = htole32(arc4random());
1353
1354 wtfs(d, sblock.e2fs_bsize, bp);
1355 free(bp);
1356 }
1357
1358 /*
1359 * Read a block from the file system
1360 */
1361 void
rdfs(daddr32_t bno,int size,void * bf)1362 rdfs(daddr32_t bno, int size, void *bf)
1363 {
1364 int n;
1365 off_t offset;
1366
1367 offset = bno;
1368 n = pread(fd, bf, size, offset * sectorsize);
1369 if (n != size)
1370 err(EXIT_FAILURE, "%s: read error for sector %" PRId64,
1371 __func__, (int64_t)bno);
1372 }
1373
1374 /*
1375 * Write a block to the file system
1376 */
1377 void
wtfs(daddr32_t bno,int size,void * bf)1378 wtfs(daddr32_t bno, int size, void *bf)
1379 {
1380 int n;
1381 off_t offset;
1382
1383 if (Nflag)
1384 return;
1385 offset = bno;
1386 n = pwrite(fd, bf, size, offset * sectorsize);
1387 if (n != size)
1388 err(EXIT_FAILURE, "%s: write error for sector %" PRId64,
1389 __func__, (int64_t)bno);
1390 }
1391
1392 int
ilog2(uint val)1393 ilog2(uint val)
1394 {
1395
1396 if (val == 0 || !powerof2(val))
1397 errx(EXIT_FAILURE, "%s: %u is not a power of 2\n",
1398 __func__, val);
1399
1400 return ffs(val) - 1;
1401 }
1402
1403 /*
1404 * int skpc(int mask, size_t size, uint8_t *cp)
1405 *
1406 * Locate an unsigned character of value mask inside cp[].
1407 * (from src/sys/lib/libkern/skpc.c)
1408 */
1409 int
skpc(int mask,size_t size,uint8_t * cp)1410 skpc(int mask, size_t size, uint8_t *cp)
1411 {
1412 uint8_t *end;
1413
1414 end = &cp[size];
1415 while (cp < end && *cp == (uint8_t)mask)
1416 cp++;
1417
1418 return end - cp;
1419 }
1420
1421 static void
uuid_get(struct m_ext2fs * sb)1422 uuid_get(struct m_ext2fs *sb)
1423 {
1424 unsigned char buf[sizeof(sb->e2fs.e2fs_uuid)];
1425
1426 arc4random_buf(buf, sizeof(buf));
1427 /* UUID version 4: random */
1428 buf[6] &= 0x0f;
1429 buf[6] |= 0x40;
1430 /* RFC4122 variant */
1431 buf[8] &= 0x3f;
1432 buf[8] |= 0x80;
1433 memcpy(sb->e2fs.e2fs_uuid, buf, sizeof(sb->e2fs.e2fs_uuid));
1434 }
1435