1881e506bSEd Maste /* $NetBSD: mkfs.c,v 1.22 2011/10/09 22:30:13 christos Exp $ */ 2d347a0daSSam Leffler 38a16b7a1SPedro F. Giffuni /*- 48a16b7a1SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 58a16b7a1SPedro F. Giffuni * 6d347a0daSSam Leffler * Copyright (c) 2002 Networks Associates Technology, Inc. 7d347a0daSSam Leffler * All rights reserved. 8d347a0daSSam Leffler * 9d347a0daSSam Leffler * This software was developed for the FreeBSD Project by Marshall 10d347a0daSSam Leffler * Kirk McKusick and Network Associates Laboratories, the Security 11d347a0daSSam Leffler * Research Division of Network Associates, Inc. under DARPA/SPAWAR 12d347a0daSSam Leffler * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS 13d347a0daSSam Leffler * research program 14d347a0daSSam Leffler * 15d347a0daSSam Leffler * Copyright (c) 1980, 1989, 1993 16d347a0daSSam Leffler * The Regents of the University of California. All rights reserved. 17d347a0daSSam Leffler * 18d347a0daSSam Leffler * Redistribution and use in source and binary forms, with or without 19d347a0daSSam Leffler * modification, are permitted provided that the following conditions 20d347a0daSSam Leffler * are met: 21d347a0daSSam Leffler * 1. Redistributions of source code must retain the above copyright 22d347a0daSSam Leffler * notice, this list of conditions and the following disclaimer. 23d347a0daSSam Leffler * 2. Redistributions in binary form must reproduce the above copyright 24d347a0daSSam Leffler * notice, this list of conditions and the following disclaimer in the 25d347a0daSSam Leffler * documentation and/or other materials provided with the distribution. 26d347a0daSSam Leffler * 3. Neither the name of the University nor the names of its contributors 27d347a0daSSam Leffler * may be used to endorse or promote products derived from this software 28d347a0daSSam Leffler * without specific prior written permission. 29d347a0daSSam Leffler * 30d347a0daSSam Leffler * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 31d347a0daSSam Leffler * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 32d347a0daSSam Leffler * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 33d347a0daSSam Leffler * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 34d347a0daSSam Leffler * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35d347a0daSSam Leffler * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 36d347a0daSSam Leffler * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 37d347a0daSSam Leffler * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 38d347a0daSSam Leffler * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 39d347a0daSSam Leffler * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 40d347a0daSSam Leffler * SUCH DAMAGE. 41d347a0daSSam Leffler */ 42d347a0daSSam Leffler 43d347a0daSSam Leffler #include <sys/param.h> 44d347a0daSSam Leffler #include <sys/time.h> 45d347a0daSSam Leffler #include <sys/resource.h> 46d347a0daSSam Leffler 47d347a0daSSam Leffler #include <stdio.h> 48d347a0daSSam Leffler #include <stdlib.h> 49d347a0daSSam Leffler #include <string.h> 50d347a0daSSam Leffler #include <unistd.h> 51d347a0daSSam Leffler #include <errno.h> 525f5598b1SEd Maste #include <util.h> 53d347a0daSSam Leffler 54d347a0daSSam Leffler #include "makefs.h" 5501a0f853SOlivier Houchard #include "ffs.h" 56d347a0daSSam Leffler 57d347a0daSSam Leffler #include <ufs/ufs/dinode.h> 58d347a0daSSam Leffler #include <ufs/ffs/fs.h> 59d347a0daSSam Leffler 60d347a0daSSam Leffler #include "ffs/ufs_bswap.h" 61d347a0daSSam Leffler #include "ffs/ufs_inode.h" 62d347a0daSSam Leffler #include "ffs/ffs_extern.h" 63d347a0daSSam Leffler #include "ffs/newfs_extern.h" 64d347a0daSSam Leffler 6501a0f853SOlivier Houchard #ifndef BBSIZE 6601a0f853SOlivier Houchard #define BBSIZE 8192 /* size of boot area, with label */ 6701a0f853SOlivier Houchard #endif 6801a0f853SOlivier Houchard 699e96f90bSEd Maste static void initcg(uint32_t, time_t, const fsinfo_t *); 70d347a0daSSam Leffler static int ilog2(int); 71d347a0daSSam Leffler 72d347a0daSSam Leffler static int count_digits(int); 73d347a0daSSam Leffler 74d347a0daSSam Leffler /* 75d347a0daSSam Leffler * make file system for cylinder-group style file systems 76d347a0daSSam Leffler */ 77d347a0daSSam Leffler #define UMASK 0755 78d347a0daSSam Leffler #define POWEROF2(num) (((num) & ((num) - 1)) == 0) 79d347a0daSSam Leffler 80*d464a769SChuck Silvers /* 81*d464a769SChuck Silvers * The definition of "struct cg" used to contain an extra field at the end 82*d464a769SChuck Silvers * to represent the variable-length data that followed the fixed structure. 83*d464a769SChuck Silvers * This had the effect of artificially limiting the number of blocks that 84*d464a769SChuck Silvers * newfs would put in a CG, since newfs thought that the fixed-size header 85*d464a769SChuck Silvers * was bigger than it really was. When we started validating that the CG 86*d464a769SChuck Silvers * header data actually fit into one fs block, the placeholder field caused 87*d464a769SChuck Silvers * a problem because it caused struct cg to be a different size depending on 88*d464a769SChuck Silvers * platform. The placeholder field was later removed, but this caused a 89*d464a769SChuck Silvers * backward compatibility problem with older binaries that still thought 90*d464a769SChuck Silvers * struct cg was larger, and a new file system could fail validation if 91*d464a769SChuck Silvers * viewed by the older binaries. To avoid this compatibility problem, we 92*d464a769SChuck Silvers * now artificially reduce the amount of space that the variable-length data 93*d464a769SChuck Silvers * can use such that new file systems will pass validation by older binaries. 94*d464a769SChuck Silvers */ 95*d464a769SChuck Silvers #define CGSIZEFUDGE 8 96*d464a769SChuck Silvers 979e96f90bSEd Maste static union { 98d347a0daSSam Leffler struct fs fs; 99d347a0daSSam Leffler char pad[SBLOCKSIZE]; 100d347a0daSSam Leffler } fsun; 101d347a0daSSam Leffler #define sblock fsun.fs 102d347a0daSSam Leffler 1039e96f90bSEd Maste static union { 104d347a0daSSam Leffler struct cg cg; 105d347a0daSSam Leffler char pad[FFS_MAXBSIZE]; 106d347a0daSSam Leffler } cgun; 107d347a0daSSam Leffler #define acg cgun.cg 108d347a0daSSam Leffler 1099e96f90bSEd Maste static char *iobuf; 1109e96f90bSEd Maste static int iobufsize; 111d347a0daSSam Leffler 1129e96f90bSEd Maste static char writebuf[FFS_MAXBSIZE]; 113d347a0daSSam Leffler 114d347a0daSSam Leffler static int Oflag; /* format as an 4.3BSD file system */ 115d347a0daSSam Leffler static int64_t fssize; /* file system size */ 116d347a0daSSam Leffler static int sectorsize; /* bytes/sector */ 117d347a0daSSam Leffler static int fsize; /* fragment size */ 118d347a0daSSam Leffler static int bsize; /* block size */ 119d347a0daSSam Leffler static int maxbsize; /* maximum clustering */ 120d347a0daSSam Leffler static int maxblkspercg; 121d347a0daSSam Leffler static int minfree; /* free space threshold */ 122d347a0daSSam Leffler static int opt; /* optimization preference (space or time) */ 123d347a0daSSam Leffler static int density; /* number of bytes per inode */ 124d347a0daSSam Leffler static int maxcontig; /* max contiguous blocks to allocate */ 125d347a0daSSam Leffler static int maxbpg; /* maximum blocks per file in a cyl group */ 12601a0f853SOlivier Houchard static int bbsize; /* boot block size */ 127d347a0daSSam Leffler static int sbsize; /* superblock size */ 128d347a0daSSam Leffler static int avgfilesize; /* expected average file size */ 129d347a0daSSam Leffler static int avgfpdir; /* expected number of files per directory */ 130d347a0daSSam Leffler 131d347a0daSSam Leffler struct fs * 1327b03d164SEd Maste ffs_mkfs(const char *fsys, const fsinfo_t *fsopts, time_t tstamp) 133d347a0daSSam Leffler { 134afb6a168SNathan Whitehorn int fragsperinode, optimalfpg, origdensity, mindensity; 135afb6a168SNathan Whitehorn int minfpg, lastminfpg; 1369e96f90bSEd Maste int32_t csfrags; 1379e96f90bSEd Maste uint32_t i, cylno; 138d347a0daSSam Leffler long long sizepb; 139afb6a168SNathan Whitehorn ino_t maxinum; 140afb6a168SNathan Whitehorn int minfragsperinode; /* minimum ratio of frags to inodes */ 141d347a0daSSam Leffler void *space; 142f7d39630SEd Maste int size; 143d347a0daSSam Leffler int nprintcols, printcolwidth; 14401a0f853SOlivier Houchard ffs_opt_t *ffs_opts = fsopts->fs_specific; 145d347a0daSSam Leffler 14601a0f853SOlivier Houchard Oflag = ffs_opts->version; 147d347a0daSSam Leffler fssize = fsopts->size / fsopts->sectorsize; 148d347a0daSSam Leffler sectorsize = fsopts->sectorsize; 14901a0f853SOlivier Houchard fsize = ffs_opts->fsize; 15001a0f853SOlivier Houchard bsize = ffs_opts->bsize; 15101a0f853SOlivier Houchard maxbsize = ffs_opts->maxbsize; 15201a0f853SOlivier Houchard maxblkspercg = ffs_opts->maxblkspercg; 15301a0f853SOlivier Houchard minfree = ffs_opts->minfree; 15401a0f853SOlivier Houchard opt = ffs_opts->optimization; 15501a0f853SOlivier Houchard density = ffs_opts->density; 15601a0f853SOlivier Houchard maxcontig = ffs_opts->maxcontig; 15701a0f853SOlivier Houchard maxbpg = ffs_opts->maxbpg; 15801a0f853SOlivier Houchard avgfilesize = ffs_opts->avgfilesize; 15901a0f853SOlivier Houchard avgfpdir = ffs_opts->avgfpdir; 16001a0f853SOlivier Houchard bbsize = BBSIZE; 161d347a0daSSam Leffler sbsize = SBLOCKSIZE; 162d347a0daSSam Leffler 163fe41c64bSAlex Richardson strlcpy((char *)sblock.fs_volname, ffs_opts->label, 164fe41c64bSAlex Richardson sizeof(sblock.fs_volname)); 165703d6e3eSNathan Whitehorn 166d347a0daSSam Leffler if (Oflag == 0) { 167d347a0daSSam Leffler sblock.fs_old_inodefmt = FS_42INODEFMT; 168d347a0daSSam Leffler sblock.fs_maxsymlinklen = 0; 169d347a0daSSam Leffler sblock.fs_old_flags = 0; 170d347a0daSSam Leffler } else { 171d347a0daSSam Leffler sblock.fs_old_inodefmt = FS_44INODEFMT; 1721dc349abSEd Maste sblock.fs_maxsymlinklen = (Oflag == 1 ? UFS1_MAXSYMLINKLEN : 1731dc349abSEd Maste UFS2_MAXSYMLINKLEN); 174d347a0daSSam Leffler sblock.fs_old_flags = FS_FLAGS_UPDATED; 175d347a0daSSam Leffler sblock.fs_flags = 0; 176d347a0daSSam Leffler } 177d347a0daSSam Leffler /* 178d347a0daSSam Leffler * Validate the given file system size. 179d347a0daSSam Leffler * Verify that its last block can actually be accessed. 180d347a0daSSam Leffler * Convert to file system fragment sized units. 181d347a0daSSam Leffler */ 182d347a0daSSam Leffler if (fssize <= 0) { 183d347a0daSSam Leffler printf("preposterous size %lld\n", (long long)fssize); 184d347a0daSSam Leffler exit(13); 185d347a0daSSam Leffler } 186d347a0daSSam Leffler ffs_wtfs(fssize - 1, sectorsize, (char *)&sblock, fsopts); 187d347a0daSSam Leffler 188d347a0daSSam Leffler /* 189d347a0daSSam Leffler * collect and verify the filesystem density info 190d347a0daSSam Leffler */ 191d347a0daSSam Leffler sblock.fs_avgfilesize = avgfilesize; 192d347a0daSSam Leffler sblock.fs_avgfpdir = avgfpdir; 193d347a0daSSam Leffler if (sblock.fs_avgfilesize <= 0) 194d347a0daSSam Leffler printf("illegal expected average file size %d\n", 195d347a0daSSam Leffler sblock.fs_avgfilesize), exit(14); 196d347a0daSSam Leffler if (sblock.fs_avgfpdir <= 0) 197d347a0daSSam Leffler printf("illegal expected number of files per directory %d\n", 198d347a0daSSam Leffler sblock.fs_avgfpdir), exit(15); 199d347a0daSSam Leffler /* 200d347a0daSSam Leffler * collect and verify the block and fragment sizes 201d347a0daSSam Leffler */ 202d347a0daSSam Leffler sblock.fs_bsize = bsize; 203d347a0daSSam Leffler sblock.fs_fsize = fsize; 204d347a0daSSam Leffler if (!POWEROF2(sblock.fs_bsize)) { 205d347a0daSSam Leffler printf("block size must be a power of 2, not %d\n", 206d347a0daSSam Leffler sblock.fs_bsize); 207d347a0daSSam Leffler exit(16); 208d347a0daSSam Leffler } 209d347a0daSSam Leffler if (!POWEROF2(sblock.fs_fsize)) { 210d347a0daSSam Leffler printf("fragment size must be a power of 2, not %d\n", 211d347a0daSSam Leffler sblock.fs_fsize); 212d347a0daSSam Leffler exit(17); 213d347a0daSSam Leffler } 214d347a0daSSam Leffler if (sblock.fs_fsize < sectorsize) { 215d347a0daSSam Leffler printf("fragment size %d is too small, minimum is %d\n", 216d347a0daSSam Leffler sblock.fs_fsize, sectorsize); 217d347a0daSSam Leffler exit(18); 218d347a0daSSam Leffler } 219d347a0daSSam Leffler if (sblock.fs_bsize < MINBSIZE) { 220d347a0daSSam Leffler printf("block size %d is too small, minimum is %d\n", 221d347a0daSSam Leffler sblock.fs_bsize, MINBSIZE); 222d347a0daSSam Leffler exit(19); 223d347a0daSSam Leffler } 224d347a0daSSam Leffler if (sblock.fs_bsize > FFS_MAXBSIZE) { 225d347a0daSSam Leffler printf("block size %d is too large, maximum is %d\n", 226d347a0daSSam Leffler sblock.fs_bsize, FFS_MAXBSIZE); 227d347a0daSSam Leffler exit(19); 228d347a0daSSam Leffler } 229d347a0daSSam Leffler if (sblock.fs_bsize < sblock.fs_fsize) { 230d347a0daSSam Leffler printf("block size (%d) cannot be smaller than fragment size (%d)\n", 231d347a0daSSam Leffler sblock.fs_bsize, sblock.fs_fsize); 232d347a0daSSam Leffler exit(20); 233d347a0daSSam Leffler } 234d347a0daSSam Leffler 235d347a0daSSam Leffler if (maxbsize < bsize || !POWEROF2(maxbsize)) { 236d347a0daSSam Leffler sblock.fs_maxbsize = sblock.fs_bsize; 237d347a0daSSam Leffler printf("Extent size set to %d\n", sblock.fs_maxbsize); 238d347a0daSSam Leffler } else if (sblock.fs_maxbsize > FS_MAXCONTIG * sblock.fs_bsize) { 239d347a0daSSam Leffler sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize; 240d347a0daSSam Leffler printf("Extent size reduced to %d\n", sblock.fs_maxbsize); 241d347a0daSSam Leffler } else { 242d347a0daSSam Leffler sblock.fs_maxbsize = maxbsize; 243d347a0daSSam Leffler } 244d347a0daSSam Leffler sblock.fs_maxcontig = maxcontig; 245d347a0daSSam Leffler if (sblock.fs_maxcontig < sblock.fs_maxbsize / sblock.fs_bsize) { 246d347a0daSSam Leffler sblock.fs_maxcontig = sblock.fs_maxbsize / sblock.fs_bsize; 247d347a0daSSam Leffler printf("Maxcontig raised to %d\n", sblock.fs_maxbsize); 248d347a0daSSam Leffler } 249d347a0daSSam Leffler 250d347a0daSSam Leffler if (sblock.fs_maxcontig > 1) 251d347a0daSSam Leffler sblock.fs_contigsumsize = MIN(sblock.fs_maxcontig,FS_MAXCONTIG); 252d347a0daSSam Leffler 253d347a0daSSam Leffler sblock.fs_bmask = ~(sblock.fs_bsize - 1); 254d347a0daSSam Leffler sblock.fs_fmask = ~(sblock.fs_fsize - 1); 255d347a0daSSam Leffler sblock.fs_qbmask = ~sblock.fs_bmask; 256d347a0daSSam Leffler sblock.fs_qfmask = ~sblock.fs_fmask; 257d347a0daSSam Leffler for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1) 258d347a0daSSam Leffler sblock.fs_bshift++; 259d347a0daSSam Leffler for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1) 260d347a0daSSam Leffler sblock.fs_fshift++; 261d347a0daSSam Leffler sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize); 262d347a0daSSam Leffler for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1) 263d347a0daSSam Leffler sblock.fs_fragshift++; 264d347a0daSSam Leffler if (sblock.fs_frag > MAXFRAG) { 265d347a0daSSam Leffler printf("fragment size %d is too small, " 266d347a0daSSam Leffler "minimum with block size %d is %d\n", 267d347a0daSSam Leffler sblock.fs_fsize, sblock.fs_bsize, 268d347a0daSSam Leffler sblock.fs_bsize / MAXFRAG); 269d347a0daSSam Leffler exit(21); 270d347a0daSSam Leffler } 271d347a0daSSam Leffler sblock.fs_fsbtodb = ilog2(sblock.fs_fsize / sectorsize); 27224484ca4SSean Bruno sblock.fs_size = sblock.fs_providersize = fssize = 27324484ca4SSean Bruno dbtofsb(&sblock, fssize); 274d347a0daSSam Leffler 275d347a0daSSam Leffler if (Oflag <= 1) { 276d347a0daSSam Leffler sblock.fs_magic = FS_UFS1_MAGIC; 277d347a0daSSam Leffler sblock.fs_sblockloc = SBLOCK_UFS1; 278646fc9ccSJohn-Mark Gurney sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs1_daddr_t); 279d347a0daSSam Leffler sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode); 2801dc349abSEd Maste sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) * 281646fc9ccSJohn-Mark Gurney sizeof (ufs1_daddr_t)); 282d347a0daSSam Leffler sblock.fs_old_inodefmt = FS_44INODEFMT; 283d347a0daSSam Leffler sblock.fs_old_cgoffset = 0; 284d347a0daSSam Leffler sblock.fs_old_cgmask = 0xffffffff; 285d347a0daSSam Leffler sblock.fs_old_size = sblock.fs_size; 286d347a0daSSam Leffler sblock.fs_old_rotdelay = 0; 287d347a0daSSam Leffler sblock.fs_old_rps = 60; 288d347a0daSSam Leffler sblock.fs_old_nspf = sblock.fs_fsize / sectorsize; 289d347a0daSSam Leffler sblock.fs_old_cpg = 1; 290d347a0daSSam Leffler sblock.fs_old_interleave = 1; 291d347a0daSSam Leffler sblock.fs_old_trackskew = 0; 292d347a0daSSam Leffler sblock.fs_old_cpc = 0; 293d347a0daSSam Leffler sblock.fs_old_postblformat = 1; 294d347a0daSSam Leffler sblock.fs_old_nrpos = 1; 295d347a0daSSam Leffler } else { 296d347a0daSSam Leffler sblock.fs_magic = FS_UFS2_MAGIC; 297d347a0daSSam Leffler sblock.fs_sblockloc = SBLOCK_UFS2; 298646fc9ccSJohn-Mark Gurney sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs2_daddr_t); 299d347a0daSSam Leffler sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode); 3001dc349abSEd Maste sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) * 301646fc9ccSJohn-Mark Gurney sizeof (ufs2_daddr_t)); 302d91e6117SEmmanuel Vadot if (ffs_opts->softupdates == 1) 303d91e6117SEmmanuel Vadot sblock.fs_flags |= FS_DOSOFTDEP; 304d347a0daSSam Leffler } 305d347a0daSSam Leffler 306d347a0daSSam Leffler sblock.fs_sblkno = 307d347a0daSSam Leffler roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize), 308d347a0daSSam Leffler sblock.fs_frag); 309d347a0daSSam Leffler sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno + 310d347a0daSSam Leffler roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag)); 311d347a0daSSam Leffler sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag; 3121dc349abSEd Maste sblock.fs_maxfilesize = sblock.fs_bsize * UFS_NDADDR - 1; 3131dc349abSEd Maste for (sizepb = sblock.fs_bsize, i = 0; i < UFS_NIADDR; i++) { 314d347a0daSSam Leffler sizepb *= NINDIR(&sblock); 315d347a0daSSam Leffler sblock.fs_maxfilesize += sizepb; 316d347a0daSSam Leffler } 317d347a0daSSam Leffler 318d347a0daSSam Leffler /* 319d347a0daSSam Leffler * Calculate the number of blocks to put into each cylinder group. 320d347a0daSSam Leffler * 321d347a0daSSam Leffler * This algorithm selects the number of blocks per cylinder 322d347a0daSSam Leffler * group. The first goal is to have at least enough data blocks 323d347a0daSSam Leffler * in each cylinder group to meet the density requirement. Once 324d347a0daSSam Leffler * this goal is achieved we try to expand to have at least 325d347a0daSSam Leffler * 1 cylinder group. Once this goal is achieved, we pack as 326d347a0daSSam Leffler * many blocks into each cylinder group map as will fit. 327d347a0daSSam Leffler * 328d347a0daSSam Leffler * We start by calculating the smallest number of blocks that we 329d347a0daSSam Leffler * can put into each cylinder group. If this is too big, we reduce 330d347a0daSSam Leffler * the density until it fits. 331d347a0daSSam Leffler */ 332afb6a168SNathan Whitehorn maxinum = (((int64_t)(1)) << 32) - INOPB(&sblock); 333afb6a168SNathan Whitehorn minfragsperinode = 1 + fssize / maxinum; 334afb6a168SNathan Whitehorn mindensity = minfragsperinode * fsize; 335afb6a168SNathan Whitehorn if (density == 0) 336afb6a168SNathan Whitehorn density = MAX(2, minfragsperinode) * fsize; 337afb6a168SNathan Whitehorn if (density < mindensity) { 338d347a0daSSam Leffler origdensity = density; 339afb6a168SNathan Whitehorn density = mindensity; 340afb6a168SNathan Whitehorn fprintf(stderr, "density increased from %d to %d\n", 341afb6a168SNathan Whitehorn origdensity, density); 342afb6a168SNathan Whitehorn } 343afb6a168SNathan Whitehorn origdensity = density; 344afb6a168SNathan Whitehorn if (!ffs_opts->min_inodes) 345afb6a168SNathan Whitehorn density = MIN(density, MAX(2, minfragsperinode) * fsize); 346d347a0daSSam Leffler for (;;) { 347d347a0daSSam Leffler fragsperinode = MAX(numfrags(&sblock, density), 1); 348d347a0daSSam Leffler minfpg = fragsperinode * INOPB(&sblock); 349d347a0daSSam Leffler if (minfpg > sblock.fs_size) 350d347a0daSSam Leffler minfpg = sblock.fs_size; 351d347a0daSSam Leffler sblock.fs_ipg = INOPB(&sblock); 352d347a0daSSam Leffler sblock.fs_fpg = roundup(sblock.fs_iblkno + 353d347a0daSSam Leffler sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag); 354d347a0daSSam Leffler if (sblock.fs_fpg < minfpg) 355d347a0daSSam Leffler sblock.fs_fpg = minfpg; 356d347a0daSSam Leffler sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 357d347a0daSSam Leffler INOPB(&sblock)); 358d347a0daSSam Leffler sblock.fs_fpg = roundup(sblock.fs_iblkno + 359d347a0daSSam Leffler sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag); 360d347a0daSSam Leffler if (sblock.fs_fpg < minfpg) 361d347a0daSSam Leffler sblock.fs_fpg = minfpg; 362d347a0daSSam Leffler sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 363d347a0daSSam Leffler INOPB(&sblock)); 364*d464a769SChuck Silvers if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize - 365*d464a769SChuck Silvers CGSIZEFUDGE) 366d347a0daSSam Leffler break; 367d347a0daSSam Leffler density -= sblock.fs_fsize; 368d347a0daSSam Leffler } 369d347a0daSSam Leffler if (density != origdensity) 370d347a0daSSam Leffler printf("density reduced from %d to %d\n", origdensity, density); 371d347a0daSSam Leffler 372d347a0daSSam Leffler if (maxblkspercg <= 0 || maxblkspercg >= fssize) 373d347a0daSSam Leffler maxblkspercg = fssize - 1; 374d347a0daSSam Leffler /* 375d347a0daSSam Leffler * Start packing more blocks into the cylinder group until 376d347a0daSSam Leffler * it cannot grow any larger, the number of cylinder groups 377d347a0daSSam Leffler * drops below 1, or we reach the size requested. 378d347a0daSSam Leffler */ 379d347a0daSSam Leffler for ( ; sblock.fs_fpg < maxblkspercg; sblock.fs_fpg += sblock.fs_frag) { 380d347a0daSSam Leffler sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 381d347a0daSSam Leffler INOPB(&sblock)); 382d347a0daSSam Leffler if (sblock.fs_size / sblock.fs_fpg < 1) 383d347a0daSSam Leffler break; 384*d464a769SChuck Silvers if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize - 385*d464a769SChuck Silvers CGSIZEFUDGE) 386d347a0daSSam Leffler continue; 387*d464a769SChuck Silvers if (CGSIZE(&sblock) == (unsigned long)sblock.fs_bsize - 388*d464a769SChuck Silvers CGSIZEFUDGE) 389d347a0daSSam Leffler break; 390d347a0daSSam Leffler sblock.fs_fpg -= sblock.fs_frag; 391d347a0daSSam Leffler sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 392d347a0daSSam Leffler INOPB(&sblock)); 393d347a0daSSam Leffler break; 394d347a0daSSam Leffler } 395d347a0daSSam Leffler /* 396d347a0daSSam Leffler * Check to be sure that the last cylinder group has enough blocks 397d347a0daSSam Leffler * to be viable. If it is too small, reduce the number of blocks 398d347a0daSSam Leffler * per cylinder group which will have the effect of moving more 399d347a0daSSam Leffler * blocks into the last cylinder group. 400d347a0daSSam Leffler */ 401d347a0daSSam Leffler optimalfpg = sblock.fs_fpg; 402d347a0daSSam Leffler for (;;) { 403d347a0daSSam Leffler sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg); 404d347a0daSSam Leffler lastminfpg = roundup(sblock.fs_iblkno + 405d347a0daSSam Leffler sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag); 406d347a0daSSam Leffler if (sblock.fs_size < lastminfpg) { 407d347a0daSSam Leffler printf("Filesystem size %lld < minimum size of %d\n", 408d347a0daSSam Leffler (long long)sblock.fs_size, lastminfpg); 409d347a0daSSam Leffler exit(28); 410d347a0daSSam Leffler } 411d347a0daSSam Leffler if (sblock.fs_size % sblock.fs_fpg >= lastminfpg || 412d347a0daSSam Leffler sblock.fs_size % sblock.fs_fpg == 0) 413d347a0daSSam Leffler break; 414d347a0daSSam Leffler sblock.fs_fpg -= sblock.fs_frag; 415d347a0daSSam Leffler sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 416d347a0daSSam Leffler INOPB(&sblock)); 417d347a0daSSam Leffler } 418d347a0daSSam Leffler if (optimalfpg != sblock.fs_fpg) 419d347a0daSSam Leffler printf("Reduced frags per cylinder group from %d to %d %s\n", 420d347a0daSSam Leffler optimalfpg, sblock.fs_fpg, "to enlarge last cyl group"); 421d347a0daSSam Leffler sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock)); 422d347a0daSSam Leffler sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock); 423d347a0daSSam Leffler if (Oflag <= 1) { 424d347a0daSSam Leffler sblock.fs_old_spc = sblock.fs_fpg * sblock.fs_old_nspf; 425d347a0daSSam Leffler sblock.fs_old_nsect = sblock.fs_old_spc; 426d347a0daSSam Leffler sblock.fs_old_npsect = sblock.fs_old_spc; 427d347a0daSSam Leffler sblock.fs_old_ncyl = sblock.fs_ncg; 428d347a0daSSam Leffler } 429d347a0daSSam Leffler 430d347a0daSSam Leffler /* 431d347a0daSSam Leffler * fill in remaining fields of the super block 432d347a0daSSam Leffler */ 433d347a0daSSam Leffler sblock.fs_csaddr = cgdmin(&sblock, 0); 434d347a0daSSam Leffler sblock.fs_cssize = 435d347a0daSSam Leffler fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum)); 436d347a0daSSam Leffler 437d347a0daSSam Leffler /* 438d347a0daSSam Leffler * Setup memory for temporary in-core cylgroup summaries. 439d347a0daSSam Leffler * Cribbed from ffs_mountfs(). 440d347a0daSSam Leffler */ 441d347a0daSSam Leffler size = sblock.fs_cssize; 442d347a0daSSam Leffler if (sblock.fs_contigsumsize > 0) 443d347a0daSSam Leffler size += sblock.fs_ncg * sizeof(int32_t); 4445f5598b1SEd Maste space = ecalloc(1, size); 445972670e1SKirk McKusick sblock.fs_si = ecalloc(1, sizeof(struct fs_summary_info)); 446d347a0daSSam Leffler sblock.fs_csp = space; 447d347a0daSSam Leffler space = (char *)space + sblock.fs_cssize; 448d347a0daSSam Leffler if (sblock.fs_contigsumsize > 0) { 449d347a0daSSam Leffler int32_t *lp; 450d347a0daSSam Leffler 451d347a0daSSam Leffler sblock.fs_maxcluster = lp = space; 452d347a0daSSam Leffler for (i = 0; i < sblock.fs_ncg; i++) 453d347a0daSSam Leffler *lp++ = sblock.fs_contigsumsize; 454d347a0daSSam Leffler } 455d347a0daSSam Leffler 456d347a0daSSam Leffler sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs)); 457d347a0daSSam Leffler if (sblock.fs_sbsize > SBLOCKSIZE) 458d347a0daSSam Leffler sblock.fs_sbsize = SBLOCKSIZE; 459d347a0daSSam Leffler sblock.fs_minfree = minfree; 460d347a0daSSam Leffler sblock.fs_maxcontig = maxcontig; 461d347a0daSSam Leffler sblock.fs_maxbpg = maxbpg; 462d347a0daSSam Leffler sblock.fs_optim = opt; 463d347a0daSSam Leffler sblock.fs_cgrotor = 0; 464d347a0daSSam Leffler sblock.fs_pendingblocks = 0; 465d347a0daSSam Leffler sblock.fs_pendinginodes = 0; 466d347a0daSSam Leffler sblock.fs_cstotal.cs_ndir = 0; 467d347a0daSSam Leffler sblock.fs_cstotal.cs_nbfree = 0; 468d347a0daSSam Leffler sblock.fs_cstotal.cs_nifree = 0; 469d347a0daSSam Leffler sblock.fs_cstotal.cs_nffree = 0; 470d347a0daSSam Leffler sblock.fs_fmod = 0; 471d347a0daSSam Leffler sblock.fs_ronly = 0; 472d347a0daSSam Leffler sblock.fs_state = 0; 473d347a0daSSam Leffler sblock.fs_clean = FS_ISCLEAN; 474d347a0daSSam Leffler sblock.fs_ronly = 0; 4757b03d164SEd Maste sblock.fs_id[0] = tstamp; 476d347a0daSSam Leffler sblock.fs_id[1] = random(); 477d347a0daSSam Leffler sblock.fs_fsmnt[0] = '\0'; 478d347a0daSSam Leffler csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize); 479d347a0daSSam Leffler sblock.fs_dsize = sblock.fs_size - sblock.fs_sblkno - 480d347a0daSSam Leffler sblock.fs_ncg * (sblock.fs_dblkno - sblock.fs_sblkno); 481d347a0daSSam Leffler sblock.fs_cstotal.cs_nbfree = 482d347a0daSSam Leffler fragstoblks(&sblock, sblock.fs_dsize) - 483d347a0daSSam Leffler howmany(csfrags, sblock.fs_frag); 484d347a0daSSam Leffler sblock.fs_cstotal.cs_nffree = 485d347a0daSSam Leffler fragnum(&sblock, sblock.fs_size) + 486d347a0daSSam Leffler (fragnum(&sblock, csfrags) > 0 ? 487d347a0daSSam Leffler sblock.fs_frag - fragnum(&sblock, csfrags) : 0); 4881dc349abSEd Maste sblock.fs_cstotal.cs_nifree = 4891dc349abSEd Maste sblock.fs_ncg * sblock.fs_ipg - UFS_ROOTINO; 490d347a0daSSam Leffler sblock.fs_cstotal.cs_ndir = 0; 491d347a0daSSam Leffler sblock.fs_dsize -= csfrags; 4927b03d164SEd Maste sblock.fs_time = tstamp; 493d347a0daSSam Leffler if (Oflag <= 1) { 4947b03d164SEd Maste sblock.fs_old_time = tstamp; 495d347a0daSSam Leffler sblock.fs_old_dsize = sblock.fs_dsize; 496d347a0daSSam Leffler sblock.fs_old_csaddr = sblock.fs_csaddr; 497d347a0daSSam Leffler sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir; 498d347a0daSSam Leffler sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree; 499d347a0daSSam Leffler sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree; 500d347a0daSSam Leffler sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree; 501d347a0daSSam Leffler } 502d347a0daSSam Leffler /* 503d347a0daSSam Leffler * Dump out summary information about file system. 504d347a0daSSam Leffler */ 505d347a0daSSam Leffler #define B2MBFACTOR (1 / (1024.0 * 1024.0)) 506d347a0daSSam Leffler printf("%s: %.1fMB (%lld sectors) block size %d, " 507d347a0daSSam Leffler "fragment size %d\n", 508d347a0daSSam Leffler fsys, (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR, 509d347a0daSSam Leffler (long long)fsbtodb(&sblock, sblock.fs_size), 510d347a0daSSam Leffler sblock.fs_bsize, sblock.fs_fsize); 511d347a0daSSam Leffler printf("\tusing %d cylinder groups of %.2fMB, %d blks, " 512d347a0daSSam Leffler "%d inodes.\n", 513d347a0daSSam Leffler sblock.fs_ncg, 514d347a0daSSam Leffler (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR, 515d347a0daSSam Leffler sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg); 516d347a0daSSam Leffler #undef B2MBFACTOR 517d347a0daSSam Leffler /* 518d347a0daSSam Leffler * Now determine how wide each column will be, and calculate how 519d347a0daSSam Leffler * many columns will fit in a 76 char line. 76 is the width of the 520d347a0daSSam Leffler * subwindows in sysinst. 521d347a0daSSam Leffler */ 522d347a0daSSam Leffler printcolwidth = count_digits( 523d347a0daSSam Leffler fsbtodb(&sblock, cgsblock(&sblock, sblock.fs_ncg -1))); 524d347a0daSSam Leffler nprintcols = 76 / (printcolwidth + 2); 525d347a0daSSam Leffler 526d347a0daSSam Leffler /* 527d347a0daSSam Leffler * allocate space for superblock, cylinder group map, and 528d347a0daSSam Leffler * two sets of inode blocks. 529d347a0daSSam Leffler */ 530d347a0daSSam Leffler if (sblock.fs_bsize < SBLOCKSIZE) 531d347a0daSSam Leffler iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize; 532d347a0daSSam Leffler else 533d347a0daSSam Leffler iobufsize = 4 * sblock.fs_bsize; 5345f5598b1SEd Maste iobuf = ecalloc(1, iobufsize); 535d347a0daSSam Leffler /* 536d347a0daSSam Leffler * Make a copy of the superblock into the buffer that we will be 537d347a0daSSam Leffler * writing out in each cylinder group. 538d347a0daSSam Leffler */ 539d347a0daSSam Leffler memcpy(writebuf, &sblock, sbsize); 540d347a0daSSam Leffler if (fsopts->needswap) 541d347a0daSSam Leffler ffs_sb_swap(&sblock, (struct fs*)writebuf); 542d347a0daSSam Leffler memcpy(iobuf, writebuf, SBLOCKSIZE); 543d347a0daSSam Leffler 544d347a0daSSam Leffler printf("super-block backups (for fsck -b #) at:"); 545d347a0daSSam Leffler for (cylno = 0; cylno < sblock.fs_ncg; cylno++) { 5467b03d164SEd Maste initcg(cylno, tstamp, fsopts); 547d347a0daSSam Leffler if (cylno % nprintcols == 0) 548d347a0daSSam Leffler printf("\n"); 549f21faa67SChristos Margiolis printf(" %*lld%s", printcolwidth, 550f21faa67SChristos Margiolis (long long)fsbtodb(&sblock, cgsblock(&sblock, cylno)), 551f21faa67SChristos Margiolis cylno == sblock.fs_ncg - 1 ? "" : ","); 552d347a0daSSam Leffler fflush(stdout); 553d347a0daSSam Leffler } 554d347a0daSSam Leffler printf("\n"); 555d347a0daSSam Leffler 556d347a0daSSam Leffler /* 557d347a0daSSam Leffler * Now construct the initial file system, 558d347a0daSSam Leffler * then write out the super-block. 559d347a0daSSam Leffler */ 5607b03d164SEd Maste sblock.fs_time = tstamp; 561d347a0daSSam Leffler if (Oflag <= 1) { 562d347a0daSSam Leffler sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir; 563d347a0daSSam Leffler sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree; 564d347a0daSSam Leffler sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree; 565d347a0daSSam Leffler sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree; 566d347a0daSSam Leffler } 567d347a0daSSam Leffler if (fsopts->needswap) 568d347a0daSSam Leffler sblock.fs_flags |= FS_SWAPPED; 569d347a0daSSam Leffler ffs_write_superblock(&sblock, fsopts); 570d347a0daSSam Leffler return (&sblock); 571d347a0daSSam Leffler } 572d347a0daSSam Leffler 573d347a0daSSam Leffler /* 574d347a0daSSam Leffler * Write out the superblock and its duplicates, 575d347a0daSSam Leffler * and the cylinder group summaries 576d347a0daSSam Leffler */ 577d347a0daSSam Leffler void 578d347a0daSSam Leffler ffs_write_superblock(struct fs *fs, const fsinfo_t *fsopts) 579d347a0daSSam Leffler { 5809e96f90bSEd Maste int size, blks, i, saveflag; 5819e96f90bSEd Maste uint32_t cylno; 582d347a0daSSam Leffler void *space; 583d347a0daSSam Leffler char *wrbuf; 584d347a0daSSam Leffler 585d347a0daSSam Leffler saveflag = fs->fs_flags & FS_INTERNAL; 586d347a0daSSam Leffler fs->fs_flags &= ~FS_INTERNAL; 587d347a0daSSam Leffler 588d347a0daSSam Leffler memcpy(writebuf, &sblock, sbsize); 589d347a0daSSam Leffler if (fsopts->needswap) 590d347a0daSSam Leffler ffs_sb_swap(fs, (struct fs*)writebuf); 591d347a0daSSam Leffler ffs_wtfs(fs->fs_sblockloc / sectorsize, sbsize, writebuf, fsopts); 592d347a0daSSam Leffler 593d347a0daSSam Leffler /* Write out the duplicate super blocks */ 594d347a0daSSam Leffler for (cylno = 0; cylno < fs->fs_ncg; cylno++) 595d347a0daSSam Leffler ffs_wtfs(fsbtodb(fs, cgsblock(fs, cylno)), 596d347a0daSSam Leffler sbsize, writebuf, fsopts); 597d347a0daSSam Leffler 598d347a0daSSam Leffler /* Write out the cylinder group summaries */ 599d347a0daSSam Leffler size = fs->fs_cssize; 600d347a0daSSam Leffler blks = howmany(size, fs->fs_fsize); 601d347a0daSSam Leffler space = (void *)fs->fs_csp; 6025f5598b1SEd Maste wrbuf = emalloc(size); 603d347a0daSSam Leffler for (i = 0; i < blks; i+= fs->fs_frag) { 604d347a0daSSam Leffler size = fs->fs_bsize; 605d347a0daSSam Leffler if (i + fs->fs_frag > blks) 606d347a0daSSam Leffler size = (blks - i) * fs->fs_fsize; 607d347a0daSSam Leffler if (fsopts->needswap) 608d347a0daSSam Leffler ffs_csum_swap((struct csum *)space, 609d347a0daSSam Leffler (struct csum *)wrbuf, size); 610d347a0daSSam Leffler else 611d347a0daSSam Leffler memcpy(wrbuf, space, (u_int)size); 612d347a0daSSam Leffler ffs_wtfs(fsbtodb(fs, fs->fs_csaddr + i), size, wrbuf, fsopts); 613d347a0daSSam Leffler space = (char *)space + size; 614d347a0daSSam Leffler } 615d347a0daSSam Leffler free(wrbuf); 616d347a0daSSam Leffler fs->fs_flags |= saveflag; 617d347a0daSSam Leffler } 618d347a0daSSam Leffler 619d347a0daSSam Leffler /* 620d347a0daSSam Leffler * Initialize a cylinder group. 621d347a0daSSam Leffler */ 622d347a0daSSam Leffler static void 6239e96f90bSEd Maste initcg(uint32_t cylno, time_t utime, const fsinfo_t *fsopts) 624d347a0daSSam Leffler { 625d347a0daSSam Leffler daddr_t cbase, dmax; 6269e96f90bSEd Maste int32_t blkno; 6279e96f90bSEd Maste uint32_t i, j, d, dlower, dupper; 628d347a0daSSam Leffler struct ufs1_dinode *dp1; 629d347a0daSSam Leffler struct ufs2_dinode *dp2; 630d347a0daSSam Leffler int start; 631d347a0daSSam Leffler 632d347a0daSSam Leffler /* 633d347a0daSSam Leffler * Determine block bounds for cylinder group. 634d347a0daSSam Leffler * Allow space for super block summary information in first 635d347a0daSSam Leffler * cylinder group. 636d347a0daSSam Leffler */ 637d347a0daSSam Leffler cbase = cgbase(&sblock, cylno); 638d347a0daSSam Leffler dmax = cbase + sblock.fs_fpg; 639d347a0daSSam Leffler if (dmax > sblock.fs_size) 640d347a0daSSam Leffler dmax = sblock.fs_size; 641d347a0daSSam Leffler dlower = cgsblock(&sblock, cylno) - cbase; 642d347a0daSSam Leffler dupper = cgdmin(&sblock, cylno) - cbase; 643d347a0daSSam Leffler if (cylno == 0) 644d347a0daSSam Leffler dupper += howmany(sblock.fs_cssize, sblock.fs_fsize); 645d347a0daSSam Leffler memset(&acg, 0, sblock.fs_cgsize); 646d347a0daSSam Leffler acg.cg_time = utime; 647d347a0daSSam Leffler acg.cg_magic = CG_MAGIC; 648d347a0daSSam Leffler acg.cg_cgx = cylno; 649d347a0daSSam Leffler acg.cg_niblk = sblock.fs_ipg; 650a8945bbfSMarcelo Araujo acg.cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock)); 651d347a0daSSam Leffler acg.cg_ndblk = dmax - cbase; 652d347a0daSSam Leffler if (sblock.fs_contigsumsize > 0) 653d347a0daSSam Leffler acg.cg_nclusterblks = acg.cg_ndblk >> sblock.fs_fragshift; 6540a6e34e9SKirk McKusick start = sizeof(acg); 655d347a0daSSam Leffler if (Oflag == 2) { 656d347a0daSSam Leffler acg.cg_iusedoff = start; 657d347a0daSSam Leffler } else { 658d347a0daSSam Leffler if (cylno == sblock.fs_ncg - 1) 659d347a0daSSam Leffler acg.cg_old_ncyl = howmany(acg.cg_ndblk, 660d347a0daSSam Leffler sblock.fs_fpg / sblock.fs_old_cpg); 661d347a0daSSam Leffler else 662d347a0daSSam Leffler acg.cg_old_ncyl = sblock.fs_old_cpg; 663d347a0daSSam Leffler acg.cg_old_time = acg.cg_time; 664d347a0daSSam Leffler acg.cg_time = 0; 665d347a0daSSam Leffler acg.cg_old_niblk = acg.cg_niblk; 666d347a0daSSam Leffler acg.cg_niblk = 0; 667d347a0daSSam Leffler acg.cg_initediblk = 0; 668d347a0daSSam Leffler acg.cg_old_btotoff = start; 669d347a0daSSam Leffler acg.cg_old_boff = acg.cg_old_btotoff + 670d347a0daSSam Leffler sblock.fs_old_cpg * sizeof(int32_t); 671d347a0daSSam Leffler acg.cg_iusedoff = acg.cg_old_boff + 672d347a0daSSam Leffler sblock.fs_old_cpg * sizeof(u_int16_t); 673d347a0daSSam Leffler } 674d347a0daSSam Leffler acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT); 675d347a0daSSam Leffler if (sblock.fs_contigsumsize <= 0) { 676d347a0daSSam Leffler acg.cg_nextfreeoff = acg.cg_freeoff + 677d347a0daSSam Leffler howmany(sblock.fs_fpg, CHAR_BIT); 678d347a0daSSam Leffler } else { 679d347a0daSSam Leffler acg.cg_clustersumoff = acg.cg_freeoff + 680d347a0daSSam Leffler howmany(sblock.fs_fpg, CHAR_BIT) - sizeof(int32_t); 681d347a0daSSam Leffler acg.cg_clustersumoff = 682d347a0daSSam Leffler roundup(acg.cg_clustersumoff, sizeof(int32_t)); 683d347a0daSSam Leffler acg.cg_clusteroff = acg.cg_clustersumoff + 684d347a0daSSam Leffler (sblock.fs_contigsumsize + 1) * sizeof(int32_t); 685d347a0daSSam Leffler acg.cg_nextfreeoff = acg.cg_clusteroff + 686d347a0daSSam Leffler howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT); 687d347a0daSSam Leffler } 6889e96f90bSEd Maste if (acg.cg_nextfreeoff > (uint32_t)sblock.fs_cgsize) { 689d347a0daSSam Leffler printf("Panic: cylinder group too big\n"); 690d347a0daSSam Leffler exit(37); 691d347a0daSSam Leffler } 692d347a0daSSam Leffler acg.cg_cs.cs_nifree += sblock.fs_ipg; 693d347a0daSSam Leffler if (cylno == 0) 6941dc349abSEd Maste for (i = 0; i < UFS_ROOTINO; i++) { 695d347a0daSSam Leffler setbit(cg_inosused_swap(&acg, 0), i); 696d347a0daSSam Leffler acg.cg_cs.cs_nifree--; 697d347a0daSSam Leffler } 698d347a0daSSam Leffler if (cylno > 0) { 699d347a0daSSam Leffler /* 700d347a0daSSam Leffler * In cylno 0, beginning space is reserved 701d347a0daSSam Leffler * for boot and super blocks. 702d347a0daSSam Leffler */ 703d347a0daSSam Leffler for (d = 0, blkno = 0; d < dlower;) { 704d347a0daSSam Leffler ffs_setblock(&sblock, cg_blksfree_swap(&acg, 0), blkno); 705d347a0daSSam Leffler if (sblock.fs_contigsumsize > 0) 706d347a0daSSam Leffler setbit(cg_clustersfree_swap(&acg, 0), blkno); 707d347a0daSSam Leffler acg.cg_cs.cs_nbfree++; 708d347a0daSSam Leffler d += sblock.fs_frag; 709d347a0daSSam Leffler blkno++; 710d347a0daSSam Leffler } 711d347a0daSSam Leffler } 712d347a0daSSam Leffler if ((i = (dupper & (sblock.fs_frag - 1))) != 0) { 713d347a0daSSam Leffler acg.cg_frsum[sblock.fs_frag - i]++; 714d347a0daSSam Leffler for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) { 715d347a0daSSam Leffler setbit(cg_blksfree_swap(&acg, 0), dupper); 716d347a0daSSam Leffler acg.cg_cs.cs_nffree++; 717d347a0daSSam Leffler } 718d347a0daSSam Leffler } 719d347a0daSSam Leffler for (d = dupper, blkno = dupper >> sblock.fs_fragshift; 720d347a0daSSam Leffler d + sblock.fs_frag <= acg.cg_ndblk; ) { 721d347a0daSSam Leffler ffs_setblock(&sblock, cg_blksfree_swap(&acg, 0), blkno); 722d347a0daSSam Leffler if (sblock.fs_contigsumsize > 0) 723d347a0daSSam Leffler setbit(cg_clustersfree_swap(&acg, 0), blkno); 724d347a0daSSam Leffler acg.cg_cs.cs_nbfree++; 725d347a0daSSam Leffler d += sblock.fs_frag; 726d347a0daSSam Leffler blkno++; 727d347a0daSSam Leffler } 728d347a0daSSam Leffler if (d < acg.cg_ndblk) { 729d347a0daSSam Leffler acg.cg_frsum[acg.cg_ndblk - d]++; 730d347a0daSSam Leffler for (; d < acg.cg_ndblk; d++) { 731d347a0daSSam Leffler setbit(cg_blksfree_swap(&acg, 0), d); 732d347a0daSSam Leffler acg.cg_cs.cs_nffree++; 733d347a0daSSam Leffler } 734d347a0daSSam Leffler } 735d347a0daSSam Leffler if (sblock.fs_contigsumsize > 0) { 736d347a0daSSam Leffler int32_t *sump = cg_clustersum_swap(&acg, 0); 737d347a0daSSam Leffler u_char *mapp = cg_clustersfree_swap(&acg, 0); 738d347a0daSSam Leffler int map = *mapp++; 739d347a0daSSam Leffler int bit = 1; 740d347a0daSSam Leffler int run = 0; 741d347a0daSSam Leffler 742d347a0daSSam Leffler for (i = 0; i < acg.cg_nclusterblks; i++) { 743d347a0daSSam Leffler if ((map & bit) != 0) { 744d347a0daSSam Leffler run++; 745d347a0daSSam Leffler } else if (run != 0) { 746d347a0daSSam Leffler if (run > sblock.fs_contigsumsize) 747d347a0daSSam Leffler run = sblock.fs_contigsumsize; 748d347a0daSSam Leffler sump[run]++; 749d347a0daSSam Leffler run = 0; 750d347a0daSSam Leffler } 751d347a0daSSam Leffler if ((i & (CHAR_BIT - 1)) != (CHAR_BIT - 1)) { 752d347a0daSSam Leffler bit <<= 1; 753d347a0daSSam Leffler } else { 754d347a0daSSam Leffler map = *mapp++; 755d347a0daSSam Leffler bit = 1; 756d347a0daSSam Leffler } 757d347a0daSSam Leffler } 758d347a0daSSam Leffler if (run != 0) { 759d347a0daSSam Leffler if (run > sblock.fs_contigsumsize) 760d347a0daSSam Leffler run = sblock.fs_contigsumsize; 761d347a0daSSam Leffler sump[run]++; 762d347a0daSSam Leffler } 763d347a0daSSam Leffler } 764d347a0daSSam Leffler sblock.fs_cs(&sblock, cylno) = acg.cg_cs; 765d347a0daSSam Leffler /* 766d347a0daSSam Leffler * Write out the duplicate super block, the cylinder group map 767d347a0daSSam Leffler * and two blocks worth of inodes in a single write. 768d347a0daSSam Leffler */ 769a8945bbfSMarcelo Araujo start = MAX(sblock.fs_bsize, SBLOCKSIZE); 770d347a0daSSam Leffler memcpy(&iobuf[start], &acg, sblock.fs_cgsize); 771d347a0daSSam Leffler if (fsopts->needswap) 772d347a0daSSam Leffler ffs_cg_swap(&acg, (struct cg*)&iobuf[start], &sblock); 773d347a0daSSam Leffler start += sblock.fs_bsize; 774d347a0daSSam Leffler dp1 = (struct ufs1_dinode *)(&iobuf[start]); 775d347a0daSSam Leffler dp2 = (struct ufs2_dinode *)(&iobuf[start]); 776d347a0daSSam Leffler for (i = 0; i < acg.cg_initediblk; i++) { 777d347a0daSSam Leffler if (sblock.fs_magic == FS_UFS1_MAGIC) { 778d347a0daSSam Leffler /* No need to swap, it'll stay random */ 779d347a0daSSam Leffler dp1->di_gen = random(); 780d347a0daSSam Leffler dp1++; 781d347a0daSSam Leffler } else { 782d347a0daSSam Leffler dp2->di_gen = random(); 783d347a0daSSam Leffler dp2++; 784d347a0daSSam Leffler } 785d347a0daSSam Leffler } 786d347a0daSSam Leffler ffs_wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf, 787d347a0daSSam Leffler fsopts); 788d347a0daSSam Leffler /* 789d347a0daSSam Leffler * For the old file system, we have to initialize all the inodes. 790d347a0daSSam Leffler */ 791d347a0daSSam Leffler if (Oflag <= 1) { 792d347a0daSSam Leffler for (i = 2 * sblock.fs_frag; 793d347a0daSSam Leffler i < sblock.fs_ipg / INOPF(&sblock); 794d347a0daSSam Leffler i += sblock.fs_frag) { 795d347a0daSSam Leffler dp1 = (struct ufs1_dinode *)(&iobuf[start]); 796d347a0daSSam Leffler for (j = 0; j < INOPB(&sblock); j++) { 797d347a0daSSam Leffler dp1->di_gen = random(); 798d347a0daSSam Leffler dp1++; 799d347a0daSSam Leffler } 800d347a0daSSam Leffler ffs_wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i), 801d347a0daSSam Leffler sblock.fs_bsize, &iobuf[start], fsopts); 802d347a0daSSam Leffler } 803d347a0daSSam Leffler } 804d347a0daSSam Leffler } 805d347a0daSSam Leffler 806d347a0daSSam Leffler /* 807d347a0daSSam Leffler * read a block from the file system 808d347a0daSSam Leffler */ 809d347a0daSSam Leffler void 810d347a0daSSam Leffler ffs_rdfs(daddr_t bno, int size, void *bf, const fsinfo_t *fsopts) 811d347a0daSSam Leffler { 812d347a0daSSam Leffler int n; 813d347a0daSSam Leffler off_t offset; 814d347a0daSSam Leffler 8157ef08273SNathaniel Filardo offset = (off_t)bno * fsopts->sectorsize + fsopts->offset; 816d347a0daSSam Leffler if (lseek(fsopts->fd, offset, SEEK_SET) < 0) 817870952f5SEd Maste err(1, "%s: seek error for sector %lld", __func__, 818870952f5SEd Maste (long long)bno); 819d347a0daSSam Leffler n = read(fsopts->fd, bf, size); 820d347a0daSSam Leffler if (n == -1) { 821d347a0daSSam Leffler abort(); 822870952f5SEd Maste err(1, "%s: read error bno %lld size %d", __func__, 823870952f5SEd Maste (long long)bno, size); 824d347a0daSSam Leffler } 825d347a0daSSam Leffler else if (n != size) 826870952f5SEd Maste errx(1, "%s: read error for sector %lld", __func__, 827870952f5SEd Maste (long long)bno); 828d347a0daSSam Leffler } 829d347a0daSSam Leffler 830d347a0daSSam Leffler /* 831d347a0daSSam Leffler * write a block to the file system 832d347a0daSSam Leffler */ 833d347a0daSSam Leffler void 834d347a0daSSam Leffler ffs_wtfs(daddr_t bno, int size, void *bf, const fsinfo_t *fsopts) 835d347a0daSSam Leffler { 836d347a0daSSam Leffler int n; 837d347a0daSSam Leffler off_t offset; 838d347a0daSSam Leffler 8397ef08273SNathaniel Filardo offset = (off_t)bno * fsopts->sectorsize + fsopts->offset; 840d347a0daSSam Leffler if (lseek(fsopts->fd, offset, SEEK_SET) < 0) 841870952f5SEd Maste err(1, "%s: seek error for sector %lld", __func__, 842870952f5SEd Maste (long long)bno); 843d347a0daSSam Leffler n = write(fsopts->fd, bf, size); 844d347a0daSSam Leffler if (n == -1) 845870952f5SEd Maste err(1, "%s: write error for sector %lld", __func__, 846870952f5SEd Maste (long long)bno); 847d347a0daSSam Leffler else if (n != size) 848870952f5SEd Maste errx(1, "%s: write error for sector %lld", __func__, 849870952f5SEd Maste (long long)bno); 850d347a0daSSam Leffler } 851d347a0daSSam Leffler 852d347a0daSSam Leffler 853d347a0daSSam Leffler /* Determine how many digits are needed to print a given integer */ 854d347a0daSSam Leffler static int 855d347a0daSSam Leffler count_digits(int num) 856d347a0daSSam Leffler { 857d347a0daSSam Leffler int ndig; 858d347a0daSSam Leffler 859d347a0daSSam Leffler for(ndig = 1; num > 9; num /=10, ndig++); 860d347a0daSSam Leffler 861d347a0daSSam Leffler return (ndig); 862d347a0daSSam Leffler } 863d347a0daSSam Leffler 864d347a0daSSam Leffler static int 865d347a0daSSam Leffler ilog2(int val) 866d347a0daSSam Leffler { 867d347a0daSSam Leffler u_int n; 868d347a0daSSam Leffler 869d347a0daSSam Leffler for (n = 0; n < sizeof(n) * CHAR_BIT; n++) 870d347a0daSSam Leffler if (1 << n == val) 871d347a0daSSam Leffler return (n); 872870952f5SEd Maste errx(1, "%s: %d is not a power of 2", __func__, val); 873d347a0daSSam Leffler } 874