1185222Ssam/* $NetBSD: mkfs.c,v 1.20 2004/06/24 22:30:13 lukem Exp $ */ 2185222Ssam 3185222Ssam/* 4185222Ssam * Copyright (c) 2002 Networks Associates Technology, Inc. 5185222Ssam * All rights reserved. 6185222Ssam * 7185222Ssam * This software was developed for the FreeBSD Project by Marshall 8185222Ssam * Kirk McKusick and Network Associates Laboratories, the Security 9185222Ssam * Research Division of Network Associates, Inc. under DARPA/SPAWAR 10185222Ssam * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS 11185222Ssam * research program 12185222Ssam * 13185222Ssam * Copyright (c) 1980, 1989, 1993 14185222Ssam * The Regents of the University of California. All rights reserved. 15185222Ssam * 16185222Ssam * Redistribution and use in source and binary forms, with or without 17185222Ssam * modification, are permitted provided that the following conditions 18185222Ssam * are met: 19185222Ssam * 1. Redistributions of source code must retain the above copyright 20185222Ssam * notice, this list of conditions and the following disclaimer. 21185222Ssam * 2. Redistributions in binary form must reproduce the above copyright 22185222Ssam * notice, this list of conditions and the following disclaimer in the 23185222Ssam * documentation and/or other materials provided with the distribution. 24185222Ssam * 3. Neither the name of the University nor the names of its contributors 25185222Ssam * may be used to endorse or promote products derived from this software 26185222Ssam * without specific prior written permission. 27185222Ssam * 28185222Ssam * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29185222Ssam * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30185222Ssam * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31185222Ssam * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32185222Ssam * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33185222Ssam * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34185222Ssam * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35185222Ssam * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36185222Ssam * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37185222Ssam * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38185222Ssam * SUCH DAMAGE. 39185222Ssam */ 40185222Ssam 41185222Ssam#include <sys/cdefs.h> 42186334Ssam__FBSDID("$FreeBSD: releng/10.2/usr.sbin/makefs/ffs/mkfs.c 226169 2011-10-09 16:22:31Z nwhitehorn $"); 43185222Ssam 44185222Ssam#include <sys/param.h> 45185222Ssam#include <sys/time.h> 46185222Ssam#include <sys/resource.h> 47185222Ssam 48185222Ssam#include <stdio.h> 49185222Ssam#include <stdlib.h> 50185222Ssam#include <string.h> 51185222Ssam#include <unistd.h> 52185222Ssam#include <errno.h> 53185222Ssam 54185222Ssam#include "makefs.h" 55214921Scognet#include "ffs.h" 56185222Ssam 57185222Ssam#include <ufs/ufs/dinode.h> 58185222Ssam#include <ufs/ffs/fs.h> 59185222Ssam 60186261Ssam#include "ffs/ufs_bswap.h" 61185222Ssam#include "ffs/ufs_inode.h" 62185222Ssam#include "ffs/ffs_extern.h" 63185222Ssam#include "ffs/newfs_extern.h" 64185222Ssam 65214921Scognet#ifndef BBSIZE 66214921Scognet#define BBSIZE 8192 /* size of boot area, with label */ 67214921Scognet#endif 68214921Scognet 69185222Ssamstatic void initcg(int, time_t, const fsinfo_t *); 70185222Ssamstatic int ilog2(int); 71185222Ssam 72185222Ssamstatic int count_digits(int); 73185222Ssam 74185222Ssam/* 75185222Ssam * make file system for cylinder-group style file systems 76185222Ssam */ 77185222Ssam#define UMASK 0755 78185222Ssam#define POWEROF2(num) (((num) & ((num) - 1)) == 0) 79185222Ssam 80185222Ssamunion { 81185222Ssam struct fs fs; 82185222Ssam char pad[SBLOCKSIZE]; 83185222Ssam} fsun; 84185222Ssam#define sblock fsun.fs 85185222Ssamstruct csum *fscs; 86185222Ssam 87185222Ssamunion { 88185222Ssam struct cg cg; 89185222Ssam char pad[FFS_MAXBSIZE]; 90185222Ssam} cgun; 91185222Ssam#define acg cgun.cg 92185222Ssam 93185222Ssamchar *iobuf; 94185222Ssamint iobufsize; 95185222Ssam 96185222Ssamchar writebuf[FFS_MAXBSIZE]; 97185222Ssam 98185222Ssamstatic int Oflag; /* format as an 4.3BSD file system */ 99185222Ssamstatic int64_t fssize; /* file system size */ 100185222Ssamstatic int sectorsize; /* bytes/sector */ 101185222Ssamstatic int fsize; /* fragment size */ 102185222Ssamstatic int bsize; /* block size */ 103185222Ssamstatic int maxbsize; /* maximum clustering */ 104185222Ssamstatic int maxblkspercg; 105185222Ssamstatic int minfree; /* free space threshold */ 106185222Ssamstatic int opt; /* optimization preference (space or time) */ 107185222Ssamstatic int density; /* number of bytes per inode */ 108185222Ssamstatic int maxcontig; /* max contiguous blocks to allocate */ 109185222Ssamstatic int maxbpg; /* maximum blocks per file in a cyl group */ 110214921Scognetstatic int bbsize; /* boot block size */ 111185222Ssamstatic int sbsize; /* superblock size */ 112185222Ssamstatic int avgfilesize; /* expected average file size */ 113185222Ssamstatic int avgfpdir; /* expected number of files per directory */ 114185222Ssam 115185222Ssamstruct fs * 116185222Ssamffs_mkfs(const char *fsys, const fsinfo_t *fsopts) 117185222Ssam{ 118185222Ssam int fragsperinode, optimalfpg, origdensity, minfpg, lastminfpg; 119185222Ssam int32_t cylno, i, csfrags; 120185222Ssam long long sizepb; 121185222Ssam void *space; 122185222Ssam int size, blks; 123185222Ssam int nprintcols, printcolwidth; 124214921Scognet ffs_opt_t *ffs_opts = fsopts->fs_specific; 125185222Ssam 126214921Scognet Oflag = ffs_opts->version; 127185222Ssam fssize = fsopts->size / fsopts->sectorsize; 128185222Ssam sectorsize = fsopts->sectorsize; 129214921Scognet fsize = ffs_opts->fsize; 130214921Scognet bsize = ffs_opts->bsize; 131214921Scognet maxbsize = ffs_opts->maxbsize; 132214921Scognet maxblkspercg = ffs_opts->maxblkspercg; 133214921Scognet minfree = ffs_opts->minfree; 134214921Scognet opt = ffs_opts->optimization; 135214921Scognet density = ffs_opts->density; 136214921Scognet maxcontig = ffs_opts->maxcontig; 137214921Scognet maxbpg = ffs_opts->maxbpg; 138214921Scognet avgfilesize = ffs_opts->avgfilesize; 139214921Scognet avgfpdir = ffs_opts->avgfpdir; 140214921Scognet bbsize = BBSIZE; 141185222Ssam sbsize = SBLOCKSIZE; 142226169Snwhitehorn 143226169Snwhitehorn strlcpy(sblock.fs_volname, ffs_opts->label, sizeof(sblock.fs_volname)); 144226169Snwhitehorn 145185222Ssam if (Oflag == 0) { 146185222Ssam sblock.fs_old_inodefmt = FS_42INODEFMT; 147185222Ssam sblock.fs_maxsymlinklen = 0; 148185222Ssam sblock.fs_old_flags = 0; 149185222Ssam } else { 150185222Ssam sblock.fs_old_inodefmt = FS_44INODEFMT; 151185222Ssam sblock.fs_maxsymlinklen = (Oflag == 1 ? MAXSYMLINKLEN_UFS1 : 152185222Ssam MAXSYMLINKLEN_UFS2); 153185222Ssam sblock.fs_old_flags = FS_FLAGS_UPDATED; 154185222Ssam sblock.fs_flags = 0; 155185222Ssam } 156185222Ssam /* 157185222Ssam * Validate the given file system size. 158185222Ssam * Verify that its last block can actually be accessed. 159185222Ssam * Convert to file system fragment sized units. 160185222Ssam */ 161185222Ssam if (fssize <= 0) { 162185222Ssam printf("preposterous size %lld\n", (long long)fssize); 163185222Ssam exit(13); 164185222Ssam } 165185222Ssam ffs_wtfs(fssize - 1, sectorsize, (char *)&sblock, fsopts); 166185222Ssam 167185222Ssam /* 168185222Ssam * collect and verify the filesystem density info 169185222Ssam */ 170185222Ssam sblock.fs_avgfilesize = avgfilesize; 171185222Ssam sblock.fs_avgfpdir = avgfpdir; 172185222Ssam if (sblock.fs_avgfilesize <= 0) 173185222Ssam printf("illegal expected average file size %d\n", 174185222Ssam sblock.fs_avgfilesize), exit(14); 175185222Ssam if (sblock.fs_avgfpdir <= 0) 176185222Ssam printf("illegal expected number of files per directory %d\n", 177185222Ssam sblock.fs_avgfpdir), exit(15); 178185222Ssam /* 179185222Ssam * collect and verify the block and fragment sizes 180185222Ssam */ 181185222Ssam sblock.fs_bsize = bsize; 182185222Ssam sblock.fs_fsize = fsize; 183185222Ssam if (!POWEROF2(sblock.fs_bsize)) { 184185222Ssam printf("block size must be a power of 2, not %d\n", 185185222Ssam sblock.fs_bsize); 186185222Ssam exit(16); 187185222Ssam } 188185222Ssam if (!POWEROF2(sblock.fs_fsize)) { 189185222Ssam printf("fragment size must be a power of 2, not %d\n", 190185222Ssam sblock.fs_fsize); 191185222Ssam exit(17); 192185222Ssam } 193185222Ssam if (sblock.fs_fsize < sectorsize) { 194185222Ssam printf("fragment size %d is too small, minimum is %d\n", 195185222Ssam sblock.fs_fsize, sectorsize); 196185222Ssam exit(18); 197185222Ssam } 198185222Ssam if (sblock.fs_bsize < MINBSIZE) { 199185222Ssam printf("block size %d is too small, minimum is %d\n", 200185222Ssam sblock.fs_bsize, MINBSIZE); 201185222Ssam exit(19); 202185222Ssam } 203185222Ssam if (sblock.fs_bsize > FFS_MAXBSIZE) { 204185222Ssam printf("block size %d is too large, maximum is %d\n", 205185222Ssam sblock.fs_bsize, FFS_MAXBSIZE); 206185222Ssam exit(19); 207185222Ssam } 208185222Ssam if (sblock.fs_bsize < sblock.fs_fsize) { 209185222Ssam printf("block size (%d) cannot be smaller than fragment size (%d)\n", 210185222Ssam sblock.fs_bsize, sblock.fs_fsize); 211185222Ssam exit(20); 212185222Ssam } 213185222Ssam 214185222Ssam if (maxbsize < bsize || !POWEROF2(maxbsize)) { 215185222Ssam sblock.fs_maxbsize = sblock.fs_bsize; 216185222Ssam printf("Extent size set to %d\n", sblock.fs_maxbsize); 217185222Ssam } else if (sblock.fs_maxbsize > FS_MAXCONTIG * sblock.fs_bsize) { 218185222Ssam sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize; 219185222Ssam printf("Extent size reduced to %d\n", sblock.fs_maxbsize); 220185222Ssam } else { 221185222Ssam sblock.fs_maxbsize = maxbsize; 222185222Ssam } 223185222Ssam sblock.fs_maxcontig = maxcontig; 224185222Ssam if (sblock.fs_maxcontig < sblock.fs_maxbsize / sblock.fs_bsize) { 225185222Ssam sblock.fs_maxcontig = sblock.fs_maxbsize / sblock.fs_bsize; 226185222Ssam printf("Maxcontig raised to %d\n", sblock.fs_maxbsize); 227185222Ssam } 228185222Ssam 229185222Ssam if (sblock.fs_maxcontig > 1) 230185222Ssam sblock.fs_contigsumsize = MIN(sblock.fs_maxcontig,FS_MAXCONTIG); 231185222Ssam 232185222Ssam sblock.fs_bmask = ~(sblock.fs_bsize - 1); 233185222Ssam sblock.fs_fmask = ~(sblock.fs_fsize - 1); 234185222Ssam sblock.fs_qbmask = ~sblock.fs_bmask; 235185222Ssam sblock.fs_qfmask = ~sblock.fs_fmask; 236185222Ssam for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1) 237185222Ssam sblock.fs_bshift++; 238185222Ssam for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1) 239185222Ssam sblock.fs_fshift++; 240185222Ssam sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize); 241185222Ssam for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1) 242185222Ssam sblock.fs_fragshift++; 243185222Ssam if (sblock.fs_frag > MAXFRAG) { 244185222Ssam printf("fragment size %d is too small, " 245185222Ssam "minimum with block size %d is %d\n", 246185222Ssam sblock.fs_fsize, sblock.fs_bsize, 247185222Ssam sblock.fs_bsize / MAXFRAG); 248185222Ssam exit(21); 249185222Ssam } 250185222Ssam sblock.fs_fsbtodb = ilog2(sblock.fs_fsize / sectorsize); 251185222Ssam sblock.fs_size = fssize = dbtofsb(&sblock, fssize); 252185222Ssam 253185222Ssam if (Oflag <= 1) { 254185222Ssam sblock.fs_magic = FS_UFS1_MAGIC; 255185222Ssam sblock.fs_sblockloc = SBLOCK_UFS1; 256185222Ssam sblock.fs_nindir = sblock.fs_bsize / sizeof(int32_t); 257185222Ssam sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode); 258185222Ssam sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) * 259185222Ssam sizeof (int32_t)); 260185222Ssam sblock.fs_old_inodefmt = FS_44INODEFMT; 261185222Ssam sblock.fs_old_cgoffset = 0; 262185222Ssam sblock.fs_old_cgmask = 0xffffffff; 263185222Ssam sblock.fs_old_size = sblock.fs_size; 264185222Ssam sblock.fs_old_rotdelay = 0; 265185222Ssam sblock.fs_old_rps = 60; 266185222Ssam sblock.fs_old_nspf = sblock.fs_fsize / sectorsize; 267185222Ssam sblock.fs_old_cpg = 1; 268185222Ssam sblock.fs_old_interleave = 1; 269185222Ssam sblock.fs_old_trackskew = 0; 270185222Ssam sblock.fs_old_cpc = 0; 271185222Ssam sblock.fs_old_postblformat = 1; 272185222Ssam sblock.fs_old_nrpos = 1; 273185222Ssam } else { 274185222Ssam sblock.fs_magic = FS_UFS2_MAGIC; 275185222Ssam#if 0 /* XXX makefs is used for small filesystems. */ 276185222Ssam sblock.fs_sblockloc = SBLOCK_UFS2; 277185222Ssam#else 278185222Ssam sblock.fs_sblockloc = SBLOCK_UFS1; 279185222Ssam#endif 280185222Ssam sblock.fs_nindir = sblock.fs_bsize / sizeof(int64_t); 281185222Ssam sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode); 282185222Ssam sblock.fs_maxsymlinklen = ((NDADDR + NIADDR) * 283185222Ssam sizeof (int64_t)); 284185222Ssam } 285185222Ssam 286185222Ssam sblock.fs_sblkno = 287185222Ssam roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize), 288185222Ssam sblock.fs_frag); 289185222Ssam sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno + 290185222Ssam roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag)); 291185222Ssam sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag; 292185222Ssam sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1; 293185222Ssam for (sizepb = sblock.fs_bsize, i = 0; i < NIADDR; i++) { 294185222Ssam sizepb *= NINDIR(&sblock); 295185222Ssam sblock.fs_maxfilesize += sizepb; 296185222Ssam } 297185222Ssam 298185222Ssam /* 299185222Ssam * Calculate the number of blocks to put into each cylinder group. 300185222Ssam * 301185222Ssam * This algorithm selects the number of blocks per cylinder 302185222Ssam * group. The first goal is to have at least enough data blocks 303185222Ssam * in each cylinder group to meet the density requirement. Once 304185222Ssam * this goal is achieved we try to expand to have at least 305185222Ssam * 1 cylinder group. Once this goal is achieved, we pack as 306185222Ssam * many blocks into each cylinder group map as will fit. 307185222Ssam * 308185222Ssam * We start by calculating the smallest number of blocks that we 309185222Ssam * can put into each cylinder group. If this is too big, we reduce 310185222Ssam * the density until it fits. 311185222Ssam */ 312185222Ssam origdensity = density; 313185222Ssam for (;;) { 314185222Ssam fragsperinode = MAX(numfrags(&sblock, density), 1); 315185222Ssam minfpg = fragsperinode * INOPB(&sblock); 316185222Ssam if (minfpg > sblock.fs_size) 317185222Ssam minfpg = sblock.fs_size; 318185222Ssam sblock.fs_ipg = INOPB(&sblock); 319185222Ssam sblock.fs_fpg = roundup(sblock.fs_iblkno + 320185222Ssam sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag); 321185222Ssam if (sblock.fs_fpg < minfpg) 322185222Ssam sblock.fs_fpg = minfpg; 323185222Ssam sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 324185222Ssam INOPB(&sblock)); 325185222Ssam sblock.fs_fpg = roundup(sblock.fs_iblkno + 326185222Ssam sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag); 327185222Ssam if (sblock.fs_fpg < minfpg) 328185222Ssam sblock.fs_fpg = minfpg; 329185222Ssam sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 330185222Ssam INOPB(&sblock)); 331185222Ssam if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize) 332185222Ssam break; 333185222Ssam density -= sblock.fs_fsize; 334185222Ssam } 335185222Ssam if (density != origdensity) 336185222Ssam printf("density reduced from %d to %d\n", origdensity, density); 337185222Ssam 338185222Ssam if (maxblkspercg <= 0 || maxblkspercg >= fssize) 339185222Ssam maxblkspercg = fssize - 1; 340185222Ssam /* 341185222Ssam * Start packing more blocks into the cylinder group until 342185222Ssam * it cannot grow any larger, the number of cylinder groups 343185222Ssam * drops below 1, or we reach the size requested. 344185222Ssam */ 345185222Ssam for ( ; sblock.fs_fpg < maxblkspercg; sblock.fs_fpg += sblock.fs_frag) { 346185222Ssam sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 347185222Ssam INOPB(&sblock)); 348185222Ssam if (sblock.fs_size / sblock.fs_fpg < 1) 349185222Ssam break; 350185222Ssam if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize) 351185222Ssam continue; 352185222Ssam if (CGSIZE(&sblock) == (unsigned long)sblock.fs_bsize) 353185222Ssam break; 354185222Ssam sblock.fs_fpg -= sblock.fs_frag; 355185222Ssam sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 356185222Ssam INOPB(&sblock)); 357185222Ssam break; 358185222Ssam } 359185222Ssam /* 360185222Ssam * Check to be sure that the last cylinder group has enough blocks 361185222Ssam * to be viable. If it is too small, reduce the number of blocks 362185222Ssam * per cylinder group which will have the effect of moving more 363185222Ssam * blocks into the last cylinder group. 364185222Ssam */ 365185222Ssam optimalfpg = sblock.fs_fpg; 366185222Ssam for (;;) { 367185222Ssam sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg); 368185222Ssam lastminfpg = roundup(sblock.fs_iblkno + 369185222Ssam sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag); 370185222Ssam if (sblock.fs_size < lastminfpg) { 371185222Ssam printf("Filesystem size %lld < minimum size of %d\n", 372185222Ssam (long long)sblock.fs_size, lastminfpg); 373185222Ssam exit(28); 374185222Ssam } 375185222Ssam if (sblock.fs_size % sblock.fs_fpg >= lastminfpg || 376185222Ssam sblock.fs_size % sblock.fs_fpg == 0) 377185222Ssam break; 378185222Ssam sblock.fs_fpg -= sblock.fs_frag; 379185222Ssam sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode), 380185222Ssam INOPB(&sblock)); 381185222Ssam } 382185222Ssam if (optimalfpg != sblock.fs_fpg) 383185222Ssam printf("Reduced frags per cylinder group from %d to %d %s\n", 384185222Ssam optimalfpg, sblock.fs_fpg, "to enlarge last cyl group"); 385185222Ssam sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock)); 386185222Ssam sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock); 387185222Ssam if (Oflag <= 1) { 388185222Ssam sblock.fs_old_spc = sblock.fs_fpg * sblock.fs_old_nspf; 389185222Ssam sblock.fs_old_nsect = sblock.fs_old_spc; 390185222Ssam sblock.fs_old_npsect = sblock.fs_old_spc; 391185222Ssam sblock.fs_old_ncyl = sblock.fs_ncg; 392185222Ssam } 393185222Ssam 394185222Ssam /* 395185222Ssam * fill in remaining fields of the super block 396185222Ssam */ 397185222Ssam sblock.fs_csaddr = cgdmin(&sblock, 0); 398185222Ssam sblock.fs_cssize = 399185222Ssam fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum)); 400185222Ssam 401185222Ssam /* 402185222Ssam * Setup memory for temporary in-core cylgroup summaries. 403185222Ssam * Cribbed from ffs_mountfs(). 404185222Ssam */ 405185222Ssam size = sblock.fs_cssize; 406185222Ssam blks = howmany(size, sblock.fs_fsize); 407185222Ssam if (sblock.fs_contigsumsize > 0) 408185222Ssam size += sblock.fs_ncg * sizeof(int32_t); 409185222Ssam if ((space = (char *)calloc(1, size)) == NULL) 410185222Ssam err(1, "memory allocation error for cg summaries"); 411185222Ssam sblock.fs_csp = space; 412185222Ssam space = (char *)space + sblock.fs_cssize; 413185222Ssam if (sblock.fs_contigsumsize > 0) { 414185222Ssam int32_t *lp; 415185222Ssam 416185222Ssam sblock.fs_maxcluster = lp = space; 417185222Ssam for (i = 0; i < sblock.fs_ncg; i++) 418185222Ssam *lp++ = sblock.fs_contigsumsize; 419185222Ssam } 420185222Ssam 421185222Ssam sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs)); 422185222Ssam if (sblock.fs_sbsize > SBLOCKSIZE) 423185222Ssam sblock.fs_sbsize = SBLOCKSIZE; 424185222Ssam sblock.fs_minfree = minfree; 425185222Ssam sblock.fs_maxcontig = maxcontig; 426185222Ssam sblock.fs_maxbpg = maxbpg; 427185222Ssam sblock.fs_optim = opt; 428185222Ssam sblock.fs_cgrotor = 0; 429185222Ssam sblock.fs_pendingblocks = 0; 430185222Ssam sblock.fs_pendinginodes = 0; 431185222Ssam sblock.fs_cstotal.cs_ndir = 0; 432185222Ssam sblock.fs_cstotal.cs_nbfree = 0; 433185222Ssam sblock.fs_cstotal.cs_nifree = 0; 434185222Ssam sblock.fs_cstotal.cs_nffree = 0; 435185222Ssam sblock.fs_fmod = 0; 436185222Ssam sblock.fs_ronly = 0; 437185222Ssam sblock.fs_state = 0; 438185222Ssam sblock.fs_clean = FS_ISCLEAN; 439185222Ssam sblock.fs_ronly = 0; 440185222Ssam sblock.fs_id[0] = start_time.tv_sec; 441185222Ssam sblock.fs_id[1] = random(); 442185222Ssam sblock.fs_fsmnt[0] = '\0'; 443185222Ssam csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize); 444185222Ssam sblock.fs_dsize = sblock.fs_size - sblock.fs_sblkno - 445185222Ssam sblock.fs_ncg * (sblock.fs_dblkno - sblock.fs_sblkno); 446185222Ssam sblock.fs_cstotal.cs_nbfree = 447185222Ssam fragstoblks(&sblock, sblock.fs_dsize) - 448185222Ssam howmany(csfrags, sblock.fs_frag); 449185222Ssam sblock.fs_cstotal.cs_nffree = 450185222Ssam fragnum(&sblock, sblock.fs_size) + 451185222Ssam (fragnum(&sblock, csfrags) > 0 ? 452185222Ssam sblock.fs_frag - fragnum(&sblock, csfrags) : 0); 453185222Ssam sblock.fs_cstotal.cs_nifree = sblock.fs_ncg * sblock.fs_ipg - ROOTINO; 454185222Ssam sblock.fs_cstotal.cs_ndir = 0; 455185222Ssam sblock.fs_dsize -= csfrags; 456185222Ssam sblock.fs_time = start_time.tv_sec; 457185222Ssam if (Oflag <= 1) { 458185222Ssam sblock.fs_old_time = start_time.tv_sec; 459185222Ssam sblock.fs_old_dsize = sblock.fs_dsize; 460185222Ssam sblock.fs_old_csaddr = sblock.fs_csaddr; 461185222Ssam sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir; 462185222Ssam sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree; 463185222Ssam sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree; 464185222Ssam sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree; 465185222Ssam } 466185222Ssam /* 467185222Ssam * Dump out summary information about file system. 468185222Ssam */ 469185222Ssam#define B2MBFACTOR (1 / (1024.0 * 1024.0)) 470185222Ssam printf("%s: %.1fMB (%lld sectors) block size %d, " 471185222Ssam "fragment size %d\n", 472185222Ssam fsys, (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR, 473185222Ssam (long long)fsbtodb(&sblock, sblock.fs_size), 474185222Ssam sblock.fs_bsize, sblock.fs_fsize); 475185222Ssam printf("\tusing %d cylinder groups of %.2fMB, %d blks, " 476185222Ssam "%d inodes.\n", 477185222Ssam sblock.fs_ncg, 478185222Ssam (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR, 479185222Ssam sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg); 480185222Ssam#undef B2MBFACTOR 481185222Ssam /* 482185222Ssam * Now determine how wide each column will be, and calculate how 483185222Ssam * many columns will fit in a 76 char line. 76 is the width of the 484185222Ssam * subwindows in sysinst. 485185222Ssam */ 486185222Ssam printcolwidth = count_digits( 487185222Ssam fsbtodb(&sblock, cgsblock(&sblock, sblock.fs_ncg -1))); 488185222Ssam nprintcols = 76 / (printcolwidth + 2); 489185222Ssam 490185222Ssam /* 491185222Ssam * allocate space for superblock, cylinder group map, and 492185222Ssam * two sets of inode blocks. 493185222Ssam */ 494185222Ssam if (sblock.fs_bsize < SBLOCKSIZE) 495185222Ssam iobufsize = SBLOCKSIZE + 3 * sblock.fs_bsize; 496185222Ssam else 497185222Ssam iobufsize = 4 * sblock.fs_bsize; 498185222Ssam if ((iobuf = malloc(iobufsize)) == 0) { 499185222Ssam printf("Cannot allocate I/O buffer\n"); 500185222Ssam exit(38); 501185222Ssam } 502185222Ssam memset(iobuf, 0, iobufsize); 503185222Ssam /* 504185222Ssam * Make a copy of the superblock into the buffer that we will be 505185222Ssam * writing out in each cylinder group. 506185222Ssam */ 507185222Ssam memcpy(writebuf, &sblock, sbsize); 508185222Ssam if (fsopts->needswap) 509185222Ssam ffs_sb_swap(&sblock, (struct fs*)writebuf); 510185222Ssam memcpy(iobuf, writebuf, SBLOCKSIZE); 511185222Ssam 512185222Ssam printf("super-block backups (for fsck -b #) at:"); 513185222Ssam for (cylno = 0; cylno < sblock.fs_ncg; cylno++) { 514185222Ssam initcg(cylno, start_time.tv_sec, fsopts); 515185222Ssam if (cylno % nprintcols == 0) 516185222Ssam printf("\n"); 517185222Ssam printf(" %*lld,", printcolwidth, 518185222Ssam (long long)fsbtodb(&sblock, cgsblock(&sblock, cylno))); 519185222Ssam fflush(stdout); 520185222Ssam } 521185222Ssam printf("\n"); 522185222Ssam 523185222Ssam /* 524185222Ssam * Now construct the initial file system, 525185222Ssam * then write out the super-block. 526185222Ssam */ 527185222Ssam sblock.fs_time = start_time.tv_sec; 528185222Ssam if (Oflag <= 1) { 529185222Ssam sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir; 530185222Ssam sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree; 531185222Ssam sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree; 532185222Ssam sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree; 533185222Ssam } 534185222Ssam if (fsopts->needswap) 535185222Ssam sblock.fs_flags |= FS_SWAPPED; 536185222Ssam ffs_write_superblock(&sblock, fsopts); 537185222Ssam return (&sblock); 538185222Ssam} 539185222Ssam 540185222Ssam/* 541185222Ssam * Write out the superblock and its duplicates, 542185222Ssam * and the cylinder group summaries 543185222Ssam */ 544185222Ssamvoid 545185222Ssamffs_write_superblock(struct fs *fs, const fsinfo_t *fsopts) 546185222Ssam{ 547185222Ssam int cylno, size, blks, i, saveflag; 548185222Ssam void *space; 549185222Ssam char *wrbuf; 550185222Ssam 551185222Ssam saveflag = fs->fs_flags & FS_INTERNAL; 552185222Ssam fs->fs_flags &= ~FS_INTERNAL; 553185222Ssam 554185222Ssam memcpy(writebuf, &sblock, sbsize); 555185222Ssam if (fsopts->needswap) 556185222Ssam ffs_sb_swap(fs, (struct fs*)writebuf); 557185222Ssam ffs_wtfs(fs->fs_sblockloc / sectorsize, sbsize, writebuf, fsopts); 558185222Ssam 559185222Ssam /* Write out the duplicate super blocks */ 560185222Ssam for (cylno = 0; cylno < fs->fs_ncg; cylno++) 561185222Ssam ffs_wtfs(fsbtodb(fs, cgsblock(fs, cylno)), 562185222Ssam sbsize, writebuf, fsopts); 563185222Ssam 564185222Ssam /* Write out the cylinder group summaries */ 565185222Ssam size = fs->fs_cssize; 566185222Ssam blks = howmany(size, fs->fs_fsize); 567185222Ssam space = (void *)fs->fs_csp; 568185222Ssam if ((wrbuf = malloc(size)) == NULL) 569185222Ssam err(1, "ffs_write_superblock: malloc %d", size); 570185222Ssam for (i = 0; i < blks; i+= fs->fs_frag) { 571185222Ssam size = fs->fs_bsize; 572185222Ssam if (i + fs->fs_frag > blks) 573185222Ssam size = (blks - i) * fs->fs_fsize; 574185222Ssam if (fsopts->needswap) 575185222Ssam ffs_csum_swap((struct csum *)space, 576185222Ssam (struct csum *)wrbuf, size); 577185222Ssam else 578185222Ssam memcpy(wrbuf, space, (u_int)size); 579185222Ssam ffs_wtfs(fsbtodb(fs, fs->fs_csaddr + i), size, wrbuf, fsopts); 580185222Ssam space = (char *)space + size; 581185222Ssam } 582185222Ssam free(wrbuf); 583185222Ssam fs->fs_flags |= saveflag; 584185222Ssam} 585185222Ssam 586185222Ssam/* 587185222Ssam * Initialize a cylinder group. 588185222Ssam */ 589185222Ssamstatic void 590185222Ssaminitcg(int cylno, time_t utime, const fsinfo_t *fsopts) 591185222Ssam{ 592185222Ssam daddr_t cbase, dmax; 593185222Ssam int32_t i, j, d, dlower, dupper, blkno; 594185222Ssam struct ufs1_dinode *dp1; 595185222Ssam struct ufs2_dinode *dp2; 596185222Ssam int start; 597185222Ssam 598185222Ssam /* 599185222Ssam * Determine block bounds for cylinder group. 600185222Ssam * Allow space for super block summary information in first 601185222Ssam * cylinder group. 602185222Ssam */ 603185222Ssam cbase = cgbase(&sblock, cylno); 604185222Ssam dmax = cbase + sblock.fs_fpg; 605185222Ssam if (dmax > sblock.fs_size) 606185222Ssam dmax = sblock.fs_size; 607185222Ssam dlower = cgsblock(&sblock, cylno) - cbase; 608185222Ssam dupper = cgdmin(&sblock, cylno) - cbase; 609185222Ssam if (cylno == 0) 610185222Ssam dupper += howmany(sblock.fs_cssize, sblock.fs_fsize); 611185222Ssam memset(&acg, 0, sblock.fs_cgsize); 612185222Ssam acg.cg_time = utime; 613185222Ssam acg.cg_magic = CG_MAGIC; 614185222Ssam acg.cg_cgx = cylno; 615185222Ssam acg.cg_niblk = sblock.fs_ipg; 616185222Ssam acg.cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ? 617185222Ssam sblock.fs_ipg : 2 * INOPB(&sblock); 618185222Ssam acg.cg_ndblk = dmax - cbase; 619185222Ssam if (sblock.fs_contigsumsize > 0) 620185222Ssam acg.cg_nclusterblks = acg.cg_ndblk >> sblock.fs_fragshift; 621185222Ssam start = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield); 622185222Ssam if (Oflag == 2) { 623185222Ssam acg.cg_iusedoff = start; 624185222Ssam } else { 625185222Ssam if (cylno == sblock.fs_ncg - 1) 626185222Ssam acg.cg_old_ncyl = howmany(acg.cg_ndblk, 627185222Ssam sblock.fs_fpg / sblock.fs_old_cpg); 628185222Ssam else 629185222Ssam acg.cg_old_ncyl = sblock.fs_old_cpg; 630185222Ssam acg.cg_old_time = acg.cg_time; 631185222Ssam acg.cg_time = 0; 632185222Ssam acg.cg_old_niblk = acg.cg_niblk; 633185222Ssam acg.cg_niblk = 0; 634185222Ssam acg.cg_initediblk = 0; 635185222Ssam acg.cg_old_btotoff = start; 636185222Ssam acg.cg_old_boff = acg.cg_old_btotoff + 637185222Ssam sblock.fs_old_cpg * sizeof(int32_t); 638185222Ssam acg.cg_iusedoff = acg.cg_old_boff + 639185222Ssam sblock.fs_old_cpg * sizeof(u_int16_t); 640185222Ssam } 641185222Ssam acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT); 642185222Ssam if (sblock.fs_contigsumsize <= 0) { 643185222Ssam acg.cg_nextfreeoff = acg.cg_freeoff + 644185222Ssam howmany(sblock.fs_fpg, CHAR_BIT); 645185222Ssam } else { 646185222Ssam acg.cg_clustersumoff = acg.cg_freeoff + 647185222Ssam howmany(sblock.fs_fpg, CHAR_BIT) - sizeof(int32_t); 648185222Ssam acg.cg_clustersumoff = 649185222Ssam roundup(acg.cg_clustersumoff, sizeof(int32_t)); 650185222Ssam acg.cg_clusteroff = acg.cg_clustersumoff + 651185222Ssam (sblock.fs_contigsumsize + 1) * sizeof(int32_t); 652185222Ssam acg.cg_nextfreeoff = acg.cg_clusteroff + 653185222Ssam howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT); 654185222Ssam } 655185222Ssam if (acg.cg_nextfreeoff > sblock.fs_cgsize) { 656185222Ssam printf("Panic: cylinder group too big\n"); 657185222Ssam exit(37); 658185222Ssam } 659185222Ssam acg.cg_cs.cs_nifree += sblock.fs_ipg; 660185222Ssam if (cylno == 0) 661185222Ssam for (i = 0; i < ROOTINO; i++) { 662186261Ssam setbit(cg_inosused_swap(&acg, 0), i); 663185222Ssam acg.cg_cs.cs_nifree--; 664185222Ssam } 665185222Ssam if (cylno > 0) { 666185222Ssam /* 667185222Ssam * In cylno 0, beginning space is reserved 668185222Ssam * for boot and super blocks. 669185222Ssam */ 670185222Ssam for (d = 0, blkno = 0; d < dlower;) { 671186261Ssam ffs_setblock(&sblock, cg_blksfree_swap(&acg, 0), blkno); 672185222Ssam if (sblock.fs_contigsumsize > 0) 673186261Ssam setbit(cg_clustersfree_swap(&acg, 0), blkno); 674185222Ssam acg.cg_cs.cs_nbfree++; 675185222Ssam d += sblock.fs_frag; 676185222Ssam blkno++; 677185222Ssam } 678185222Ssam } 679185222Ssam if ((i = (dupper & (sblock.fs_frag - 1))) != 0) { 680185222Ssam acg.cg_frsum[sblock.fs_frag - i]++; 681185222Ssam for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) { 682186261Ssam setbit(cg_blksfree_swap(&acg, 0), dupper); 683185222Ssam acg.cg_cs.cs_nffree++; 684185222Ssam } 685185222Ssam } 686185222Ssam for (d = dupper, blkno = dupper >> sblock.fs_fragshift; 687185222Ssam d + sblock.fs_frag <= acg.cg_ndblk; ) { 688186261Ssam ffs_setblock(&sblock, cg_blksfree_swap(&acg, 0), blkno); 689185222Ssam if (sblock.fs_contigsumsize > 0) 690186261Ssam setbit(cg_clustersfree_swap(&acg, 0), blkno); 691185222Ssam acg.cg_cs.cs_nbfree++; 692185222Ssam d += sblock.fs_frag; 693185222Ssam blkno++; 694185222Ssam } 695185222Ssam if (d < acg.cg_ndblk) { 696185222Ssam acg.cg_frsum[acg.cg_ndblk - d]++; 697185222Ssam for (; d < acg.cg_ndblk; d++) { 698186261Ssam setbit(cg_blksfree_swap(&acg, 0), d); 699185222Ssam acg.cg_cs.cs_nffree++; 700185222Ssam } 701185222Ssam } 702185222Ssam if (sblock.fs_contigsumsize > 0) { 703186261Ssam int32_t *sump = cg_clustersum_swap(&acg, 0); 704186261Ssam u_char *mapp = cg_clustersfree_swap(&acg, 0); 705185222Ssam int map = *mapp++; 706185222Ssam int bit = 1; 707185222Ssam int run = 0; 708185222Ssam 709185222Ssam for (i = 0; i < acg.cg_nclusterblks; i++) { 710185222Ssam if ((map & bit) != 0) { 711185222Ssam run++; 712185222Ssam } else if (run != 0) { 713185222Ssam if (run > sblock.fs_contigsumsize) 714185222Ssam run = sblock.fs_contigsumsize; 715185222Ssam sump[run]++; 716185222Ssam run = 0; 717185222Ssam } 718185222Ssam if ((i & (CHAR_BIT - 1)) != (CHAR_BIT - 1)) { 719185222Ssam bit <<= 1; 720185222Ssam } else { 721185222Ssam map = *mapp++; 722185222Ssam bit = 1; 723185222Ssam } 724185222Ssam } 725185222Ssam if (run != 0) { 726185222Ssam if (run > sblock.fs_contigsumsize) 727185222Ssam run = sblock.fs_contigsumsize; 728185222Ssam sump[run]++; 729185222Ssam } 730185222Ssam } 731185222Ssam sblock.fs_cs(&sblock, cylno) = acg.cg_cs; 732185222Ssam /* 733185222Ssam * Write out the duplicate super block, the cylinder group map 734185222Ssam * and two blocks worth of inodes in a single write. 735185222Ssam */ 736185222Ssam start = sblock.fs_bsize > SBLOCKSIZE ? sblock.fs_bsize : SBLOCKSIZE; 737185222Ssam memcpy(&iobuf[start], &acg, sblock.fs_cgsize); 738185222Ssam if (fsopts->needswap) 739185222Ssam ffs_cg_swap(&acg, (struct cg*)&iobuf[start], &sblock); 740185222Ssam start += sblock.fs_bsize; 741185222Ssam dp1 = (struct ufs1_dinode *)(&iobuf[start]); 742185222Ssam dp2 = (struct ufs2_dinode *)(&iobuf[start]); 743185222Ssam for (i = 0; i < acg.cg_initediblk; i++) { 744185222Ssam if (sblock.fs_magic == FS_UFS1_MAGIC) { 745185222Ssam /* No need to swap, it'll stay random */ 746185222Ssam dp1->di_gen = random(); 747185222Ssam dp1++; 748185222Ssam } else { 749185222Ssam dp2->di_gen = random(); 750185222Ssam dp2++; 751185222Ssam } 752185222Ssam } 753185222Ssam ffs_wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf, 754185222Ssam fsopts); 755185222Ssam /* 756185222Ssam * For the old file system, we have to initialize all the inodes. 757185222Ssam */ 758185222Ssam if (Oflag <= 1) { 759185222Ssam for (i = 2 * sblock.fs_frag; 760185222Ssam i < sblock.fs_ipg / INOPF(&sblock); 761185222Ssam i += sblock.fs_frag) { 762185222Ssam dp1 = (struct ufs1_dinode *)(&iobuf[start]); 763185222Ssam for (j = 0; j < INOPB(&sblock); j++) { 764185222Ssam dp1->di_gen = random(); 765185222Ssam dp1++; 766185222Ssam } 767185222Ssam ffs_wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i), 768185222Ssam sblock.fs_bsize, &iobuf[start], fsopts); 769185222Ssam } 770185222Ssam } 771185222Ssam} 772185222Ssam 773185222Ssam/* 774185222Ssam * read a block from the file system 775185222Ssam */ 776185222Ssamvoid 777185222Ssamffs_rdfs(daddr_t bno, int size, void *bf, const fsinfo_t *fsopts) 778185222Ssam{ 779185222Ssam int n; 780185222Ssam off_t offset; 781185222Ssam 782185222Ssam offset = bno; 783185222Ssam offset *= fsopts->sectorsize; 784185222Ssam if (lseek(fsopts->fd, offset, SEEK_SET) < 0) 785185222Ssam err(1, "ffs_rdfs: seek error for sector %lld: %s\n", 786185222Ssam (long long)bno, strerror(errno)); 787185222Ssam n = read(fsopts->fd, bf, size); 788185222Ssam if (n == -1) { 789185222Ssam abort(); 790185222Ssam err(1, "ffs_rdfs: read error bno %lld size %d", (long long)bno, 791185222Ssam size); 792185222Ssam } 793185222Ssam else if (n != size) 794185222Ssam errx(1, "ffs_rdfs: read error for sector %lld: %s\n", 795185222Ssam (long long)bno, strerror(errno)); 796185222Ssam} 797185222Ssam 798185222Ssam/* 799185222Ssam * write a block to the file system 800185222Ssam */ 801185222Ssamvoid 802185222Ssamffs_wtfs(daddr_t bno, int size, void *bf, const fsinfo_t *fsopts) 803185222Ssam{ 804185222Ssam int n; 805185222Ssam off_t offset; 806185222Ssam 807185222Ssam offset = bno; 808185222Ssam offset *= fsopts->sectorsize; 809185222Ssam if (lseek(fsopts->fd, offset, SEEK_SET) < 0) 810185222Ssam err(1, "wtfs: seek error for sector %lld: %s\n", 811185222Ssam (long long)bno, strerror(errno)); 812185222Ssam n = write(fsopts->fd, bf, size); 813185222Ssam if (n == -1) 814185222Ssam err(1, "wtfs: write error for sector %lld: %s\n", 815185222Ssam (long long)bno, strerror(errno)); 816185222Ssam else if (n != size) 817185222Ssam errx(1, "wtfs: write error for sector %lld: %s\n", 818185222Ssam (long long)bno, strerror(errno)); 819185222Ssam} 820185222Ssam 821185222Ssam 822185222Ssam/* Determine how many digits are needed to print a given integer */ 823185222Ssamstatic int 824185222Ssamcount_digits(int num) 825185222Ssam{ 826185222Ssam int ndig; 827185222Ssam 828185222Ssam for(ndig = 1; num > 9; num /=10, ndig++); 829185222Ssam 830185222Ssam return (ndig); 831185222Ssam} 832185222Ssam 833185222Ssamstatic int 834185222Ssamilog2(int val) 835185222Ssam{ 836185222Ssam u_int n; 837185222Ssam 838185222Ssam for (n = 0; n < sizeof(n) * CHAR_BIT; n++) 839185222Ssam if (1 << n == val) 840185222Ssam return (n); 841185222Ssam errx(1, "ilog2: %d is not a power of 2\n", val); 842185222Ssam} 843