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