1881e506bSEd Maste /* $NetBSD: ffs.c,v 1.45 2011/10/09 22:49:26 christos Exp $ */ 2d347a0daSSam Leffler 3d347a0daSSam Leffler /* 4d347a0daSSam Leffler * Copyright (c) 2001 Wasabi Systems, Inc. 5d347a0daSSam Leffler * All rights reserved. 6d347a0daSSam Leffler * 7d347a0daSSam Leffler * Written by Luke Mewburn for Wasabi Systems, Inc. 8d347a0daSSam Leffler * 9d347a0daSSam Leffler * Redistribution and use in source and binary forms, with or without 10d347a0daSSam Leffler * modification, are permitted provided that the following conditions 11d347a0daSSam Leffler * are met: 12d347a0daSSam Leffler * 1. Redistributions of source code must retain the above copyright 13d347a0daSSam Leffler * notice, this list of conditions and the following disclaimer. 14d347a0daSSam Leffler * 2. Redistributions in binary form must reproduce the above copyright 15d347a0daSSam Leffler * notice, this list of conditions and the following disclaimer in the 16d347a0daSSam Leffler * documentation and/or other materials provided with the distribution. 17d347a0daSSam Leffler * 3. All advertising materials mentioning features or use of this software 18d347a0daSSam Leffler * must display the following acknowledgement: 19d347a0daSSam Leffler * This product includes software developed for the NetBSD Project by 20d347a0daSSam Leffler * Wasabi Systems, Inc. 21d347a0daSSam Leffler * 4. The name of Wasabi Systems, Inc. may not be used to endorse 22d347a0daSSam Leffler * or promote products derived from this software without specific prior 23d347a0daSSam Leffler * written permission. 24d347a0daSSam Leffler * 25d347a0daSSam Leffler * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 26d347a0daSSam Leffler * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27d347a0daSSam Leffler * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28d347a0daSSam Leffler * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 29d347a0daSSam Leffler * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30d347a0daSSam Leffler * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31d347a0daSSam Leffler * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32d347a0daSSam Leffler * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33d347a0daSSam Leffler * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34d347a0daSSam Leffler * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35d347a0daSSam Leffler * POSSIBILITY OF SUCH DAMAGE. 36d347a0daSSam Leffler */ 37d347a0daSSam Leffler /* 38d347a0daSSam Leffler * Copyright (c) 1982, 1986, 1989, 1993 39d347a0daSSam Leffler * The Regents of the University of California. All rights reserved. 40d347a0daSSam Leffler * 41d347a0daSSam Leffler * Redistribution and use in source and binary forms, with or without 42d347a0daSSam Leffler * modification, are permitted provided that the following conditions 43d347a0daSSam Leffler * are met: 44d347a0daSSam Leffler * 1. Redistributions of source code must retain the above copyright 45d347a0daSSam Leffler * notice, this list of conditions and the following disclaimer. 46d347a0daSSam Leffler * 2. Redistributions in binary form must reproduce the above copyright 47d347a0daSSam Leffler * notice, this list of conditions and the following disclaimer in the 48d347a0daSSam Leffler * documentation and/or other materials provided with the distribution. 49d347a0daSSam Leffler * 3. Neither the name of the University nor the names of its contributors 50d347a0daSSam Leffler * may be used to endorse or promote products derived from this software 51d347a0daSSam Leffler * without specific prior written permission. 52d347a0daSSam Leffler * 53d347a0daSSam Leffler * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 54d347a0daSSam Leffler * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 55d347a0daSSam Leffler * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 56d347a0daSSam Leffler * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 57d347a0daSSam Leffler * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 58d347a0daSSam Leffler * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 59d347a0daSSam Leffler * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 60d347a0daSSam Leffler * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 61d347a0daSSam Leffler * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 62d347a0daSSam Leffler * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 63d347a0daSSam Leffler * SUCH DAMAGE. 64d347a0daSSam Leffler * 65d347a0daSSam Leffler * @(#)ffs_alloc.c 8.19 (Berkeley) 7/13/95 66d347a0daSSam Leffler */ 67d347a0daSSam Leffler 68d347a0daSSam Leffler #include <sys/cdefs.h> 69d347a0daSSam Leffler __FBSDID("$FreeBSD$"); 70d347a0daSSam Leffler 71d347a0daSSam Leffler #include <sys/param.h> 72d347a0daSSam Leffler 73d347a0daSSam Leffler #include <sys/mount.h> 74d347a0daSSam Leffler 75d347a0daSSam Leffler #include <assert.h> 76d347a0daSSam Leffler #include <errno.h> 77d347a0daSSam Leffler #include <fcntl.h> 78d347a0daSSam Leffler #include <stdarg.h> 7901a0f853SOlivier Houchard #include <stdint.h> 80d347a0daSSam Leffler #include <stdio.h> 81d347a0daSSam Leffler #include <stdlib.h> 82d347a0daSSam Leffler #include <string.h> 837649cb00SKirk McKusick #include <time.h> 84d347a0daSSam Leffler #include <unistd.h> 85d347a0daSSam Leffler 86d347a0daSSam Leffler #include "makefs.h" 8701a0f853SOlivier Houchard #include "ffs.h" 8801a0f853SOlivier Houchard 8901a0f853SOlivier Houchard #if HAVE_STRUCT_STATVFS_F_IOSIZE && HAVE_FSTATVFS 9001a0f853SOlivier Houchard #include <sys/statvfs.h> 9101a0f853SOlivier Houchard #endif 92d347a0daSSam Leffler 93d347a0daSSam Leffler #include <ufs/ufs/dinode.h> 94d347a0daSSam Leffler #include <ufs/ufs/dir.h> 95d347a0daSSam Leffler #include <ufs/ffs/fs.h> 96d347a0daSSam Leffler 9701a0f853SOlivier Houchard 98d347a0daSSam Leffler #include "ffs/ufs_bswap.h" 99d347a0daSSam Leffler #include "ffs/ufs_inode.h" 100d347a0daSSam Leffler #include "ffs/newfs_extern.h" 101d347a0daSSam Leffler #include "ffs/ffs_extern.h" 102d347a0daSSam Leffler 103d347a0daSSam Leffler #undef DIP 104d347a0daSSam Leffler #define DIP(dp, field) \ 10501a0f853SOlivier Houchard ((ffs_opts->version == 1) ? \ 106d347a0daSSam Leffler (dp)->ffs1_din.di_##field : (dp)->ffs2_din.di_##field) 107d347a0daSSam Leffler 108d347a0daSSam Leffler /* 109d347a0daSSam Leffler * Various file system defaults (cribbed from newfs(8)). 110d347a0daSSam Leffler */ 111d347a0daSSam Leffler #define DFL_FRAGSIZE 1024 /* fragment size */ 112d347a0daSSam Leffler #define DFL_BLKSIZE 8192 /* block size */ 113d347a0daSSam Leffler #define DFL_SECSIZE 512 /* sector size */ 114d347a0daSSam Leffler #define DFL_CYLSPERGROUP 65536 /* cylinders per group */ 115d347a0daSSam Leffler #define DFL_FRAGSPERINODE 4 /* fragments per inode */ 116d347a0daSSam Leffler #define DFL_ROTDELAY 0 /* rotational delay */ 117d347a0daSSam Leffler #define DFL_NRPOS 1 /* rotational positions */ 118d347a0daSSam Leffler #define DFL_RPM 3600 /* rpm of disk */ 119d347a0daSSam Leffler #define DFL_NSECTORS 64 /* # of sectors */ 120d347a0daSSam Leffler #define DFL_NTRACKS 16 /* # of tracks */ 121d347a0daSSam Leffler 122d347a0daSSam Leffler 123d347a0daSSam Leffler typedef struct { 124d347a0daSSam Leffler u_char *buf; /* buf for directory */ 125d347a0daSSam Leffler doff_t size; /* full size of buf */ 126d347a0daSSam Leffler doff_t cur; /* offset of current entry */ 127d347a0daSSam Leffler } dirbuf_t; 128d347a0daSSam Leffler 129d347a0daSSam Leffler 130d347a0daSSam Leffler static int ffs_create_image(const char *, fsinfo_t *); 131d347a0daSSam Leffler static void ffs_dump_fsinfo(fsinfo_t *); 132d347a0daSSam Leffler static void ffs_dump_dirbuf(dirbuf_t *, const char *, int); 133d347a0daSSam Leffler static void ffs_make_dirbuf(dirbuf_t *, const char *, fsnode *, int); 134d347a0daSSam Leffler static int ffs_populate_dir(const char *, fsnode *, fsinfo_t *); 135d347a0daSSam Leffler static void ffs_size_dir(fsnode *, fsinfo_t *); 136d347a0daSSam Leffler static void ffs_validate(const char *, fsnode *, fsinfo_t *); 137d347a0daSSam Leffler static void ffs_write_file(union dinode *, uint32_t, void *, fsinfo_t *); 138d347a0daSSam Leffler static void ffs_write_inode(union dinode *, uint32_t, const fsinfo_t *); 139d347a0daSSam Leffler static void *ffs_build_dinode1(struct ufs1_dinode *, dirbuf_t *, fsnode *, 140d347a0daSSam Leffler fsnode *, fsinfo_t *); 141d347a0daSSam Leffler static void *ffs_build_dinode2(struct ufs2_dinode *, dirbuf_t *, fsnode *, 142d347a0daSSam Leffler fsnode *, fsinfo_t *); 143d347a0daSSam Leffler 144d347a0daSSam Leffler 145d347a0daSSam Leffler 146d347a0daSSam Leffler int sectorsize; /* XXX: for buf.c::getblk() */ 1473df5ecacSUlrich Spörlein /* publicly visible functions */ 148d347a0daSSam Leffler 14901a0f853SOlivier Houchard void 15001a0f853SOlivier Houchard ffs_prep_opts(fsinfo_t *fsopts) 15101a0f853SOlivier Houchard { 15201a0f853SOlivier Houchard ffs_opt_t *ffs_opts; 15301a0f853SOlivier Houchard 15401a0f853SOlivier Houchard if ((ffs_opts = calloc(1, sizeof(ffs_opt_t))) == NULL) 15501a0f853SOlivier Houchard err(1, "Allocating memory for ffs_options"); 15601a0f853SOlivier Houchard 157*776c6824SEd Maste const option_t ffs_options[] = { 158*776c6824SEd Maste { 'b', "bsize", &ffs_opts->bsize, OPT_INT32, 159*776c6824SEd Maste 1, INT_MAX, "block size" }, 160*776c6824SEd Maste { 'f', "fsize", &ffs_opts->fsize, OPT_INT32, 161*776c6824SEd Maste 1, INT_MAX, "fragment size" }, 162*776c6824SEd Maste { 'd', "density", &ffs_opts->density, OPT_INT32, 163*776c6824SEd Maste 1, INT_MAX, "bytes per inode" }, 164*776c6824SEd Maste { 'm', "minfree", &ffs_opts->minfree, OPT_INT32, 165*776c6824SEd Maste 0, 99, "minfree" }, 166*776c6824SEd Maste { 'M', "maxbpg", &ffs_opts->maxbpg, OPT_INT32, 167*776c6824SEd Maste 1, INT_MAX, "max blocks per file in a cg" }, 168*776c6824SEd Maste { 'a', "avgfilesize", &ffs_opts->avgfilesize, OPT_INT32, 169*776c6824SEd Maste 1, INT_MAX, "expected average file size" }, 170*776c6824SEd Maste { 'n', "avgfpdir", &ffs_opts->avgfpdir, OPT_INT32, 171*776c6824SEd Maste 1, INT_MAX, "expected # of files per directory" }, 172*776c6824SEd Maste { 'x', "extent", &ffs_opts->maxbsize, OPT_INT32, 173*776c6824SEd Maste 1, INT_MAX, "maximum # extent size" }, 174*776c6824SEd Maste { 'g', "maxbpcg", &ffs_opts->maxblkspercg, OPT_INT32, 175*776c6824SEd Maste 1, INT_MAX, "max # of blocks per group" }, 176*776c6824SEd Maste { 'v', "version", &ffs_opts->version, OPT_INT32, 177*776c6824SEd Maste 1, 2, "UFS version" }, 178*776c6824SEd Maste { 'o', "optimization", NULL, OPT_STRBUF, 179*776c6824SEd Maste 0, 0, "Optimization (time|space)" }, 180*776c6824SEd Maste { 'l', "label", ffs_opts->label, OPT_STRARRAY, 181*776c6824SEd Maste 1, sizeof(ffs_opts->label), "UFS label" }, 182*776c6824SEd Maste { .name = NULL } 183*776c6824SEd Maste }; 18401a0f853SOlivier Houchard 18501a0f853SOlivier Houchard ffs_opts->bsize= -1; 18601a0f853SOlivier Houchard ffs_opts->fsize= -1; 18701a0f853SOlivier Houchard ffs_opts->cpg= -1; 18801a0f853SOlivier Houchard ffs_opts->density= -1; 18901a0f853SOlivier Houchard ffs_opts->minfree= -1; 19001a0f853SOlivier Houchard ffs_opts->optimization= -1; 19101a0f853SOlivier Houchard ffs_opts->maxcontig= -1; 19201a0f853SOlivier Houchard ffs_opts->maxbpg= -1; 19301a0f853SOlivier Houchard ffs_opts->avgfilesize= -1; 19401a0f853SOlivier Houchard ffs_opts->avgfpdir= -1; 19501a0f853SOlivier Houchard ffs_opts->version = 1; 196*776c6824SEd Maste 197*776c6824SEd Maste fsopts->fs_specific = ffs_opts; 198*776c6824SEd Maste fsopts->fs_options = copy_opts(ffs_options); 19901a0f853SOlivier Houchard } 20001a0f853SOlivier Houchard 20101a0f853SOlivier Houchard void 20201a0f853SOlivier Houchard ffs_cleanup_opts(fsinfo_t *fsopts) 20301a0f853SOlivier Houchard { 20401a0f853SOlivier Houchard free(fsopts->fs_specific); 205*776c6824SEd Maste free(fsopts->fs_options); 20601a0f853SOlivier Houchard } 20701a0f853SOlivier Houchard 208d347a0daSSam Leffler int 209d347a0daSSam Leffler ffs_parse_opts(const char *option, fsinfo_t *fsopts) 210d347a0daSSam Leffler { 21101a0f853SOlivier Houchard ffs_opt_t *ffs_opts = fsopts->fs_specific; 212*776c6824SEd Maste option_t *ffs_options = fsopts->fs_options; 213*776c6824SEd Maste char buf[1024]; 21401a0f853SOlivier Houchard 215d347a0daSSam Leffler int rv; 216d347a0daSSam Leffler 217d347a0daSSam Leffler assert(option != NULL); 218d347a0daSSam Leffler assert(fsopts != NULL); 21901a0f853SOlivier Houchard assert(ffs_opts != NULL); 220d347a0daSSam Leffler 221d347a0daSSam Leffler if (debug & DEBUG_FS_PARSE_OPTS) 222d347a0daSSam Leffler printf("ffs_parse_opts: got `%s'\n", option); 223d347a0daSSam Leffler 224*776c6824SEd Maste rv = set_option(ffs_options, option, buf, sizeof(buf)); 225*776c6824SEd Maste if (rv == -1) 226*776c6824SEd Maste return 0; 227d347a0daSSam Leffler 228*776c6824SEd Maste if (ffs_options[rv].name == NULL) 229*776c6824SEd Maste abort(); 230d347a0daSSam Leffler 231*776c6824SEd Maste switch (ffs_options[rv].letter) { 232*776c6824SEd Maste case 'o': 233*776c6824SEd Maste if (strcmp(buf, "time") == 0) { 23401a0f853SOlivier Houchard ffs_opts->optimization = FS_OPTTIME; 235*776c6824SEd Maste } else if (strcmp(buf, "space") == 0) { 23601a0f853SOlivier Houchard ffs_opts->optimization = FS_OPTSPACE; 237d347a0daSSam Leffler } else { 238*776c6824SEd Maste warnx("Invalid optimization `%s'", buf); 239*776c6824SEd Maste return 0; 240d347a0daSSam Leffler } 241*776c6824SEd Maste break; 242*776c6824SEd Maste default: 243*776c6824SEd Maste break; 244*776c6824SEd Maste } 245*776c6824SEd Maste return 1; 246d347a0daSSam Leffler } 247d347a0daSSam Leffler 248d347a0daSSam Leffler 249d347a0daSSam Leffler void 250d347a0daSSam Leffler ffs_makefs(const char *image, const char *dir, fsnode *root, fsinfo_t *fsopts) 251d347a0daSSam Leffler { 252d347a0daSSam Leffler struct fs *superblock; 253d347a0daSSam Leffler struct timeval start; 254d347a0daSSam Leffler 255d347a0daSSam Leffler assert(image != NULL); 256d347a0daSSam Leffler assert(dir != NULL); 257d347a0daSSam Leffler assert(root != NULL); 258d347a0daSSam Leffler assert(fsopts != NULL); 259d347a0daSSam Leffler 260d347a0daSSam Leffler if (debug & DEBUG_FS_MAKEFS) 261d347a0daSSam Leffler printf("ffs_makefs: image %s directory %s root %p\n", 262d347a0daSSam Leffler image, dir, root); 263d347a0daSSam Leffler 264d347a0daSSam Leffler /* validate tree and options */ 265d347a0daSSam Leffler TIMER_START(start); 266d347a0daSSam Leffler ffs_validate(dir, root, fsopts); 267d347a0daSSam Leffler TIMER_RESULTS(start, "ffs_validate"); 268d347a0daSSam Leffler 269d347a0daSSam Leffler printf("Calculated size of `%s': %lld bytes, %lld inodes\n", 270d347a0daSSam Leffler image, (long long)fsopts->size, (long long)fsopts->inodes); 271d347a0daSSam Leffler 272d347a0daSSam Leffler /* create image */ 273d347a0daSSam Leffler TIMER_START(start); 274d347a0daSSam Leffler if (ffs_create_image(image, fsopts) == -1) 275d347a0daSSam Leffler errx(1, "Image file `%s' not created.", image); 276d347a0daSSam Leffler TIMER_RESULTS(start, "ffs_create_image"); 277d347a0daSSam Leffler 2781dc349abSEd Maste fsopts->curinode = UFS_ROOTINO; 279d347a0daSSam Leffler 280d347a0daSSam Leffler if (debug & DEBUG_FS_MAKEFS) 281d347a0daSSam Leffler putchar('\n'); 282d347a0daSSam Leffler 283d347a0daSSam Leffler /* populate image */ 284d347a0daSSam Leffler printf("Populating `%s'\n", image); 285d347a0daSSam Leffler TIMER_START(start); 286d347a0daSSam Leffler if (! ffs_populate_dir(dir, root, fsopts)) 287d347a0daSSam Leffler errx(1, "Image file `%s' not populated.", image); 288d347a0daSSam Leffler TIMER_RESULTS(start, "ffs_populate_dir"); 289d347a0daSSam Leffler 290d347a0daSSam Leffler /* ensure no outstanding buffers remain */ 291d347a0daSSam Leffler if (debug & DEBUG_FS_MAKEFS) 292d347a0daSSam Leffler bcleanup(); 293d347a0daSSam Leffler 294d347a0daSSam Leffler /* update various superblock parameters */ 295d347a0daSSam Leffler superblock = fsopts->superblock; 296d347a0daSSam Leffler superblock->fs_fmod = 0; 297d347a0daSSam Leffler superblock->fs_old_cstotal.cs_ndir = superblock->fs_cstotal.cs_ndir; 298d347a0daSSam Leffler superblock->fs_old_cstotal.cs_nbfree = superblock->fs_cstotal.cs_nbfree; 299d347a0daSSam Leffler superblock->fs_old_cstotal.cs_nifree = superblock->fs_cstotal.cs_nifree; 300d347a0daSSam Leffler superblock->fs_old_cstotal.cs_nffree = superblock->fs_cstotal.cs_nffree; 301d347a0daSSam Leffler 302d347a0daSSam Leffler /* write out superblock; image is now complete */ 303d347a0daSSam Leffler ffs_write_superblock(fsopts->superblock, fsopts); 304d347a0daSSam Leffler if (close(fsopts->fd) == -1) 305d347a0daSSam Leffler err(1, "Closing `%s'", image); 306d347a0daSSam Leffler fsopts->fd = -1; 307d347a0daSSam Leffler printf("Image `%s' complete\n", image); 308d347a0daSSam Leffler } 309d347a0daSSam Leffler 310d347a0daSSam Leffler /* end of public functions */ 311d347a0daSSam Leffler 312d347a0daSSam Leffler 313d347a0daSSam Leffler static void 314d347a0daSSam Leffler ffs_validate(const char *dir, fsnode *root, fsinfo_t *fsopts) 315d347a0daSSam Leffler { 316d347a0daSSam Leffler int32_t ncg = 1; 317d347a0daSSam Leffler #if notyet 318d347a0daSSam Leffler int32_t spc, nspf, ncyl, fssize; 319d347a0daSSam Leffler #endif 32001a0f853SOlivier Houchard ffs_opt_t *ffs_opts = fsopts->fs_specific; 321d347a0daSSam Leffler 322d347a0daSSam Leffler assert(dir != NULL); 323d347a0daSSam Leffler assert(root != NULL); 324d347a0daSSam Leffler assert(fsopts != NULL); 32501a0f853SOlivier Houchard assert(ffs_opts != NULL); 326d347a0daSSam Leffler 327d347a0daSSam Leffler if (debug & DEBUG_FS_VALIDATE) { 328d347a0daSSam Leffler printf("ffs_validate: before defaults set:\n"); 329d347a0daSSam Leffler ffs_dump_fsinfo(fsopts); 330d347a0daSSam Leffler } 331d347a0daSSam Leffler 332d347a0daSSam Leffler /* set FFS defaults */ 333d347a0daSSam Leffler if (fsopts->sectorsize == -1) 334d347a0daSSam Leffler fsopts->sectorsize = DFL_SECSIZE; 33501a0f853SOlivier Houchard if (ffs_opts->fsize == -1) 33601a0f853SOlivier Houchard ffs_opts->fsize = MAX(DFL_FRAGSIZE, fsopts->sectorsize); 33701a0f853SOlivier Houchard if (ffs_opts->bsize == -1) 33801a0f853SOlivier Houchard ffs_opts->bsize = MIN(DFL_BLKSIZE, 8 * ffs_opts->fsize); 33901a0f853SOlivier Houchard if (ffs_opts->cpg == -1) 34001a0f853SOlivier Houchard ffs_opts->cpg = DFL_CYLSPERGROUP; 341d347a0daSSam Leffler else 34201a0f853SOlivier Houchard ffs_opts->cpgflg = 1; 343d347a0daSSam Leffler /* fsopts->density is set below */ 34401a0f853SOlivier Houchard if (ffs_opts->nsectors == -1) 34501a0f853SOlivier Houchard ffs_opts->nsectors = DFL_NSECTORS; 34601a0f853SOlivier Houchard if (ffs_opts->minfree == -1) 34701a0f853SOlivier Houchard ffs_opts->minfree = MINFREE; 34801a0f853SOlivier Houchard if (ffs_opts->optimization == -1) 34901a0f853SOlivier Houchard ffs_opts->optimization = DEFAULTOPT; 35001a0f853SOlivier Houchard if (ffs_opts->maxcontig == -1) 35101a0f853SOlivier Houchard ffs_opts->maxcontig = 35201a0f853SOlivier Houchard MAX(1, MIN(MAXPHYS, FFS_MAXBSIZE) / ffs_opts->bsize); 353d347a0daSSam Leffler /* XXX ondisk32 */ 35401a0f853SOlivier Houchard if (ffs_opts->maxbpg == -1) 35501a0f853SOlivier Houchard ffs_opts->maxbpg = ffs_opts->bsize / sizeof(int32_t); 35601a0f853SOlivier Houchard if (ffs_opts->avgfilesize == -1) 35701a0f853SOlivier Houchard ffs_opts->avgfilesize = AVFILESIZ; 35801a0f853SOlivier Houchard if (ffs_opts->avgfpdir == -1) 35901a0f853SOlivier Houchard ffs_opts->avgfpdir = AFPDIR; 360d347a0daSSam Leffler 3619d5a327fSDavide Italiano if (fsopts->maxsize > 0 && 3629d5a327fSDavide Italiano roundup(fsopts->minsize, ffs_opts->bsize) > fsopts->maxsize) 3635ad283b3SJuli Mallett errx(1, "`%s' minsize of %lld rounded up to ffs bsize of %d " 3645ad283b3SJuli Mallett "exceeds maxsize %lld. Lower bsize, or round the minimum " 3655ad283b3SJuli Mallett "and maximum sizes to bsize.", dir, 3665ad283b3SJuli Mallett (long long)fsopts->minsize, ffs_opts->bsize, 3675ad283b3SJuli Mallett (long long)fsopts->maxsize); 3685ad283b3SJuli Mallett 369d347a0daSSam Leffler /* calculate size of tree */ 370d347a0daSSam Leffler ffs_size_dir(root, fsopts); 3711dc349abSEd Maste fsopts->inodes += UFS_ROOTINO; /* include first two inodes */ 372d347a0daSSam Leffler 373d347a0daSSam Leffler if (debug & DEBUG_FS_VALIDATE) 374d347a0daSSam Leffler printf("ffs_validate: size of tree: %lld bytes, %lld inodes\n", 375d347a0daSSam Leffler (long long)fsopts->size, (long long)fsopts->inodes); 376d347a0daSSam Leffler 377d347a0daSSam Leffler /* add requested slop */ 378d347a0daSSam Leffler fsopts->size += fsopts->freeblocks; 379d347a0daSSam Leffler fsopts->inodes += fsopts->freefiles; 380d347a0daSSam Leffler if (fsopts->freefilepc > 0) 381d347a0daSSam Leffler fsopts->inodes = 382d347a0daSSam Leffler fsopts->inodes * (100 + fsopts->freefilepc) / 100; 383d347a0daSSam Leffler if (fsopts->freeblockpc > 0) 384d347a0daSSam Leffler fsopts->size = 385d347a0daSSam Leffler fsopts->size * (100 + fsopts->freeblockpc) / 100; 386d347a0daSSam Leffler 387d347a0daSSam Leffler /* add space needed for superblocks */ 388d347a0daSSam Leffler /* 389d347a0daSSam Leffler * The old SBOFF (SBLOCK_UFS1) is used here because makefs is 390d347a0daSSam Leffler * typically used for small filesystems where space matters. 391d347a0daSSam Leffler * XXX make this an option. 392d347a0daSSam Leffler */ 393d347a0daSSam Leffler fsopts->size += (SBLOCK_UFS1 + SBLOCKSIZE) * ncg; 394d347a0daSSam Leffler /* add space needed to store inodes, x3 for blockmaps, etc */ 39501a0f853SOlivier Houchard if (ffs_opts->version == 1) 396d347a0daSSam Leffler fsopts->size += ncg * DINODE1_SIZE * 39701a0f853SOlivier Houchard roundup(fsopts->inodes / ncg, 39801a0f853SOlivier Houchard ffs_opts->bsize / DINODE1_SIZE); 399d347a0daSSam Leffler else 400d347a0daSSam Leffler fsopts->size += ncg * DINODE2_SIZE * 40101a0f853SOlivier Houchard roundup(fsopts->inodes / ncg, 40201a0f853SOlivier Houchard ffs_opts->bsize / DINODE2_SIZE); 403d347a0daSSam Leffler 404d347a0daSSam Leffler /* add minfree */ 40501a0f853SOlivier Houchard if (ffs_opts->minfree > 0) 406d347a0daSSam Leffler fsopts->size = 40701a0f853SOlivier Houchard fsopts->size * (100 + ffs_opts->minfree) / 100; 408d347a0daSSam Leffler /* 409d347a0daSSam Leffler * XXX any other fs slop to add, such as csum's, bitmaps, etc ?? 410d347a0daSSam Leffler */ 411d347a0daSSam Leffler 412d347a0daSSam Leffler if (fsopts->size < fsopts->minsize) /* ensure meets minimum size */ 413d347a0daSSam Leffler fsopts->size = fsopts->minsize; 414d347a0daSSam Leffler 415d347a0daSSam Leffler /* round up to the next block */ 41601a0f853SOlivier Houchard fsopts->size = roundup(fsopts->size, ffs_opts->bsize); 417d347a0daSSam Leffler 418a08b904cSAdrian Chadd /* round up to requested block size, if any */ 419a08b904cSAdrian Chadd if (fsopts->roundup > 0) 420a08b904cSAdrian Chadd fsopts->size = roundup(fsopts->size, fsopts->roundup); 421a08b904cSAdrian Chadd 422d347a0daSSam Leffler /* calculate density if necessary */ 42301a0f853SOlivier Houchard if (ffs_opts->density == -1) 42401a0f853SOlivier Houchard ffs_opts->density = fsopts->size / fsopts->inodes + 1; 425d347a0daSSam Leffler 426d347a0daSSam Leffler if (debug & DEBUG_FS_VALIDATE) { 427d347a0daSSam Leffler printf("ffs_validate: after defaults set:\n"); 428d347a0daSSam Leffler ffs_dump_fsinfo(fsopts); 429d347a0daSSam Leffler printf("ffs_validate: dir %s; %lld bytes, %lld inodes\n", 430d347a0daSSam Leffler dir, (long long)fsopts->size, (long long)fsopts->inodes); 431d347a0daSSam Leffler } 432d347a0daSSam Leffler sectorsize = fsopts->sectorsize; /* XXX - see earlier */ 43301a0f853SOlivier Houchard 43401a0f853SOlivier Houchard /* now check calculated sizes vs requested sizes */ 43501a0f853SOlivier Houchard if (fsopts->maxsize > 0 && fsopts->size > fsopts->maxsize) { 43601a0f853SOlivier Houchard errx(1, "`%s' size of %lld is larger than the maxsize of %lld.", 43701a0f853SOlivier Houchard dir, (long long)fsopts->size, (long long)fsopts->maxsize); 43801a0f853SOlivier Houchard } 439d347a0daSSam Leffler } 440d347a0daSSam Leffler 441d347a0daSSam Leffler 442d347a0daSSam Leffler static void 443d347a0daSSam Leffler ffs_dump_fsinfo(fsinfo_t *f) 444d347a0daSSam Leffler { 445d347a0daSSam Leffler 44601a0f853SOlivier Houchard ffs_opt_t *fs = f->fs_specific; 44701a0f853SOlivier Houchard 448d347a0daSSam Leffler printf("fsopts at %p\n", f); 449d347a0daSSam Leffler 450d347a0daSSam Leffler printf("\tsize %lld, inodes %lld, curinode %u\n", 451d347a0daSSam Leffler (long long)f->size, (long long)f->inodes, f->curinode); 452d347a0daSSam Leffler 453d347a0daSSam Leffler printf("\tminsize %lld, maxsize %lld\n", 454d347a0daSSam Leffler (long long)f->minsize, (long long)f->maxsize); 455d347a0daSSam Leffler printf("\tfree files %lld, freefile %% %d\n", 456d347a0daSSam Leffler (long long)f->freefiles, f->freefilepc); 457d347a0daSSam Leffler printf("\tfree blocks %lld, freeblock %% %d\n", 458d347a0daSSam Leffler (long long)f->freeblocks, f->freeblockpc); 459d347a0daSSam Leffler printf("\tneedswap %d, sectorsize %d\n", f->needswap, f->sectorsize); 460d347a0daSSam Leffler 461d347a0daSSam Leffler printf("\tbsize %d, fsize %d, cpg %d, density %d\n", 46201a0f853SOlivier Houchard fs->bsize, fs->fsize, fs->cpg, fs->density); 463d347a0daSSam Leffler printf("\tnsectors %d, rpm %d, minfree %d\n", 46401a0f853SOlivier Houchard fs->nsectors, fs->rpm, fs->minfree); 465d347a0daSSam Leffler printf("\tmaxcontig %d, maxbpg %d\n", 46601a0f853SOlivier Houchard fs->maxcontig, fs->maxbpg); 467d347a0daSSam Leffler printf("\toptimization %s\n", 46801a0f853SOlivier Houchard fs->optimization == FS_OPTSPACE ? "space" : "time"); 469d347a0daSSam Leffler } 470d347a0daSSam Leffler 471d347a0daSSam Leffler 472d347a0daSSam Leffler static int 473d347a0daSSam Leffler ffs_create_image(const char *image, fsinfo_t *fsopts) 474d347a0daSSam Leffler { 47501a0f853SOlivier Houchard #if HAVE_STRUCT_STATVFS_F_IOSIZE && HAVE_FSTATVFS 476d347a0daSSam Leffler struct statvfs sfs; 477d347a0daSSam Leffler #endif 478d347a0daSSam Leffler struct fs *fs; 479d347a0daSSam Leffler char *buf; 480d347a0daSSam Leffler int i, bufsize; 481d347a0daSSam Leffler off_t bufrem; 4827b03d164SEd Maste time_t tstamp; 483d347a0daSSam Leffler 484d347a0daSSam Leffler assert (image != NULL); 485d347a0daSSam Leffler assert (fsopts != NULL); 486d347a0daSSam Leffler 487d347a0daSSam Leffler /* create image */ 48801a0f853SOlivier Houchard if ((fsopts->fd = open(image, O_RDWR | O_CREAT | O_TRUNC, 0666)) 489d347a0daSSam Leffler == -1) { 490d347a0daSSam Leffler warn("Can't open `%s' for writing", image); 491d347a0daSSam Leffler return (-1); 492d347a0daSSam Leffler } 493d347a0daSSam Leffler 494d347a0daSSam Leffler /* zero image */ 49501a0f853SOlivier Houchard #if HAVE_STRUCT_STATVFS_F_IOSIZE && HAVE_FSTATVFS 496d347a0daSSam Leffler if (fstatvfs(fsopts->fd, &sfs) == -1) { 497d347a0daSSam Leffler #endif 498d347a0daSSam Leffler bufsize = 8192; 49901a0f853SOlivier Houchard #if HAVE_STRUCT_STATVFS_F_IOSIZE && HAVE_FSTATVFS 500d347a0daSSam Leffler warn("can't fstatvfs `%s', using default %d byte chunk", 501d347a0daSSam Leffler image, bufsize); 502d347a0daSSam Leffler } else 503d347a0daSSam Leffler bufsize = sfs.f_iosize; 504d347a0daSSam Leffler #endif 505d347a0daSSam Leffler bufrem = fsopts->size; 50699c841b1SHiroki Sato if (fsopts->sparse) { 50799c841b1SHiroki Sato if (ftruncate(fsopts->fd, bufrem) == -1) { 50899c841b1SHiroki Sato warn("sparse option disabled.\n"); 50999c841b1SHiroki Sato fsopts->sparse = 0; 51099c841b1SHiroki Sato } 51199c841b1SHiroki Sato } 51299c841b1SHiroki Sato if (fsopts->sparse) { 51399c841b1SHiroki Sato /* File truncated at bufrem. Remaining is 0 */ 51499c841b1SHiroki Sato bufrem = 0; 51599c841b1SHiroki Sato buf = NULL; 51699c841b1SHiroki Sato } else { 517d347a0daSSam Leffler if (debug & DEBUG_FS_CREATE_IMAGE) 51899c841b1SHiroki Sato printf("zero-ing image `%s', %lld sectors, " 51999c841b1SHiroki Sato "using %d byte chunks\n", image, (long long)bufrem, 52099c841b1SHiroki Sato bufsize); 521d347a0daSSam Leffler if ((buf = calloc(1, bufsize)) == NULL) { 522d347a0daSSam Leffler warn("Can't create buffer for sector"); 523d347a0daSSam Leffler return (-1); 524d347a0daSSam Leffler } 52599c841b1SHiroki Sato } 526d347a0daSSam Leffler while (bufrem > 0) { 527d347a0daSSam Leffler i = write(fsopts->fd, buf, MIN(bufsize, bufrem)); 528d347a0daSSam Leffler if (i == -1) { 529d347a0daSSam Leffler warn("zeroing image, %lld bytes to go", 530d347a0daSSam Leffler (long long)bufrem); 53101a0f853SOlivier Houchard free(buf); 532d347a0daSSam Leffler return (-1); 533d347a0daSSam Leffler } 534d347a0daSSam Leffler bufrem -= i; 535d347a0daSSam Leffler } 53699c841b1SHiroki Sato if (buf) 53701a0f853SOlivier Houchard free(buf); 538d347a0daSSam Leffler 539d347a0daSSam Leffler /* make the file system */ 540d347a0daSSam Leffler if (debug & DEBUG_FS_CREATE_IMAGE) 541d347a0daSSam Leffler printf("calling mkfs(\"%s\", ...)\n", image); 5427b03d164SEd Maste 5437b03d164SEd Maste if (stampst.st_ino != 0) 5447b03d164SEd Maste tstamp = stampst.st_ctime; 5457b03d164SEd Maste else 5467b03d164SEd Maste tstamp = start_time.tv_sec; 5477b03d164SEd Maste 5487b03d164SEd Maste srandom(tstamp); 5497b03d164SEd Maste 5507b03d164SEd Maste fs = ffs_mkfs(image, fsopts, tstamp); 551d347a0daSSam Leffler fsopts->superblock = (void *)fs; 552d347a0daSSam Leffler if (debug & DEBUG_FS_CREATE_IMAGE) { 553d347a0daSSam Leffler time_t t; 554d347a0daSSam Leffler 555d347a0daSSam Leffler t = (time_t)((struct fs *)fsopts->superblock)->fs_time; 556d347a0daSSam Leffler printf("mkfs returned %p; fs_time %s", 557d347a0daSSam Leffler fsopts->superblock, ctime(&t)); 558d347a0daSSam Leffler printf("fs totals: nbfree %lld, nffree %lld, nifree %lld, ndir %lld\n", 559d347a0daSSam Leffler (long long)fs->fs_cstotal.cs_nbfree, 560d347a0daSSam Leffler (long long)fs->fs_cstotal.cs_nffree, 561d347a0daSSam Leffler (long long)fs->fs_cstotal.cs_nifree, 562d347a0daSSam Leffler (long long)fs->fs_cstotal.cs_ndir); 563d347a0daSSam Leffler } 564d347a0daSSam Leffler 5651dc349abSEd Maste if (fs->fs_cstotal.cs_nifree + UFS_ROOTINO < fsopts->inodes) { 566d347a0daSSam Leffler warnx( 567d347a0daSSam Leffler "Image file `%s' has %lld free inodes; %lld are required.", 568d347a0daSSam Leffler image, 5691dc349abSEd Maste (long long)(fs->fs_cstotal.cs_nifree + UFS_ROOTINO), 570d347a0daSSam Leffler (long long)fsopts->inodes); 571d347a0daSSam Leffler return (-1); 572d347a0daSSam Leffler } 573d347a0daSSam Leffler return (fsopts->fd); 574d347a0daSSam Leffler } 575d347a0daSSam Leffler 576d347a0daSSam Leffler 577d347a0daSSam Leffler static void 578d347a0daSSam Leffler ffs_size_dir(fsnode *root, fsinfo_t *fsopts) 579d347a0daSSam Leffler { 580d347a0daSSam Leffler struct direct tmpdir; 581d347a0daSSam Leffler fsnode * node; 582d347a0daSSam Leffler int curdirsize, this; 58301a0f853SOlivier Houchard ffs_opt_t *ffs_opts = fsopts->fs_specific; 584d347a0daSSam Leffler 585d347a0daSSam Leffler /* node may be NULL (empty directory) */ 586d347a0daSSam Leffler assert(fsopts != NULL); 58701a0f853SOlivier Houchard assert(ffs_opts != NULL); 588d347a0daSSam Leffler 589d347a0daSSam Leffler if (debug & DEBUG_FS_SIZE_DIR) 590d347a0daSSam Leffler printf("ffs_size_dir: entry: bytes %lld inodes %lld\n", 591d347a0daSSam Leffler (long long)fsopts->size, (long long)fsopts->inodes); 592d347a0daSSam Leffler 593d347a0daSSam Leffler #define ADDDIRENT(e) do { \ 594d347a0daSSam Leffler tmpdir.d_namlen = strlen((e)); \ 595d347a0daSSam Leffler this = DIRSIZ_SWAP(0, &tmpdir, 0); \ 596d347a0daSSam Leffler if (debug & DEBUG_FS_SIZE_DIR_ADD_DIRENT) \ 597d347a0daSSam Leffler printf("ADDDIRENT: was: %s (%d) this %d cur %d\n", \ 598d347a0daSSam Leffler e, tmpdir.d_namlen, this, curdirsize); \ 599d347a0daSSam Leffler if (this + curdirsize > roundup(curdirsize, DIRBLKSIZ)) \ 600d347a0daSSam Leffler curdirsize = roundup(curdirsize, DIRBLKSIZ); \ 601d347a0daSSam Leffler curdirsize += this; \ 602d347a0daSSam Leffler if (debug & DEBUG_FS_SIZE_DIR_ADD_DIRENT) \ 603d347a0daSSam Leffler printf("ADDDIRENT: now: %s (%d) this %d cur %d\n", \ 604d347a0daSSam Leffler e, tmpdir.d_namlen, this, curdirsize); \ 605d347a0daSSam Leffler } while (0); 606d347a0daSSam Leffler 607d347a0daSSam Leffler /* 608d347a0daSSam Leffler * XXX this needs to take into account extra space consumed 609d347a0daSSam Leffler * by indirect blocks, etc. 610d347a0daSSam Leffler */ 611d347a0daSSam Leffler #define ADDSIZE(x) do { \ 61201a0f853SOlivier Houchard fsopts->size += roundup((x), ffs_opts->fsize); \ 613d347a0daSSam Leffler } while (0); 614d347a0daSSam Leffler 615d347a0daSSam Leffler curdirsize = 0; 616d347a0daSSam Leffler for (node = root; node != NULL; node = node->next) { 617d347a0daSSam Leffler ADDDIRENT(node->name); 618d347a0daSSam Leffler if (node == root) { /* we're at "." */ 619d347a0daSSam Leffler assert(strcmp(node->name, ".") == 0); 620d347a0daSSam Leffler ADDDIRENT(".."); 621d347a0daSSam Leffler } else if ((node->inode->flags & FI_SIZED) == 0) { 622d347a0daSSam Leffler /* don't count duplicate names */ 623d347a0daSSam Leffler node->inode->flags |= FI_SIZED; 624d347a0daSSam Leffler if (debug & DEBUG_FS_SIZE_DIR_NODE) 625d347a0daSSam Leffler printf("ffs_size_dir: `%s' size %lld\n", 626d347a0daSSam Leffler node->name, 627d347a0daSSam Leffler (long long)node->inode->st.st_size); 628d347a0daSSam Leffler fsopts->inodes++; 629d347a0daSSam Leffler if (node->type == S_IFREG) 630d347a0daSSam Leffler ADDSIZE(node->inode->st.st_size); 631d347a0daSSam Leffler if (node->type == S_IFLNK) { 632d347a0daSSam Leffler int slen; 633d347a0daSSam Leffler 634d347a0daSSam Leffler slen = strlen(node->symlink) + 1; 63501a0f853SOlivier Houchard if (slen >= (ffs_opts->version == 1 ? 6361dc349abSEd Maste UFS1_MAXSYMLINKLEN : 6371dc349abSEd Maste UFS2_MAXSYMLINKLEN)) 638d347a0daSSam Leffler ADDSIZE(slen); 639d347a0daSSam Leffler } 640d347a0daSSam Leffler } 641d347a0daSSam Leffler if (node->type == S_IFDIR) 642d347a0daSSam Leffler ffs_size_dir(node->child, fsopts); 643d347a0daSSam Leffler } 644d347a0daSSam Leffler ADDSIZE(curdirsize); 645d347a0daSSam Leffler 646d347a0daSSam Leffler if (debug & DEBUG_FS_SIZE_DIR) 647d347a0daSSam Leffler printf("ffs_size_dir: exit: size %lld inodes %lld\n", 648d347a0daSSam Leffler (long long)fsopts->size, (long long)fsopts->inodes); 649d347a0daSSam Leffler } 650d347a0daSSam Leffler 651d347a0daSSam Leffler static void * 652d347a0daSSam Leffler ffs_build_dinode1(struct ufs1_dinode *dinp, dirbuf_t *dbufp, fsnode *cur, 653d347a0daSSam Leffler fsnode *root, fsinfo_t *fsopts) 654d347a0daSSam Leffler { 655d347a0daSSam Leffler int slen; 656d347a0daSSam Leffler void *membuf; 6577b03d164SEd Maste struct stat *st = stampst.st_ino != 0 ? &stampst : &cur->inode->st; 658d347a0daSSam Leffler 659d347a0daSSam Leffler memset(dinp, 0, sizeof(*dinp)); 660d347a0daSSam Leffler dinp->di_mode = cur->inode->st.st_mode; 661d347a0daSSam Leffler dinp->di_nlink = cur->inode->nlink; 662d347a0daSSam Leffler dinp->di_size = cur->inode->st.st_size; 663d347a0daSSam Leffler #if HAVE_STRUCT_STAT_ST_FLAGS 664d347a0daSSam Leffler dinp->di_flags = cur->inode->st.st_flags; 665d347a0daSSam Leffler #endif 6664ad8d733SMarcel Moolenaar dinp->di_gen = random(); 667d347a0daSSam Leffler dinp->di_uid = cur->inode->st.st_uid; 668d347a0daSSam Leffler dinp->di_gid = cur->inode->st.st_gid; 6697b03d164SEd Maste 6707b03d164SEd Maste dinp->di_atime = st->st_atime; 6717b03d164SEd Maste dinp->di_mtime = st->st_mtime; 6727b03d164SEd Maste dinp->di_ctime = st->st_ctime; 6737b03d164SEd Maste #if HAVE_STRUCT_STAT_ST_MTIMENSEC 6747b03d164SEd Maste dinp->di_atimensec = st->st_atimensec; 6757b03d164SEd Maste dinp->di_mtimensec = st->st_mtimensec; 6767b03d164SEd Maste dinp->di_ctimensec = st->st_ctimensec; 6777b03d164SEd Maste #endif 678d347a0daSSam Leffler /* not set: di_db, di_ib, di_blocks, di_spare */ 679d347a0daSSam Leffler 680d347a0daSSam Leffler membuf = NULL; 681d347a0daSSam Leffler if (cur == root) { /* "."; write dirbuf */ 682d347a0daSSam Leffler membuf = dbufp->buf; 683d347a0daSSam Leffler dinp->di_size = dbufp->size; 684d347a0daSSam Leffler } else if (S_ISBLK(cur->type) || S_ISCHR(cur->type)) { 685d347a0daSSam Leffler dinp->di_size = 0; /* a device */ 686d347a0daSSam Leffler dinp->di_rdev = 687d347a0daSSam Leffler ufs_rw32(cur->inode->st.st_rdev, fsopts->needswap); 688d347a0daSSam Leffler } else if (S_ISLNK(cur->type)) { /* symlink */ 689d347a0daSSam Leffler slen = strlen(cur->symlink); 6901dc349abSEd Maste if (slen < UFS1_MAXSYMLINKLEN) { /* short link */ 691d347a0daSSam Leffler memcpy(dinp->di_db, cur->symlink, slen); 692d347a0daSSam Leffler } else 693d347a0daSSam Leffler membuf = cur->symlink; 694d347a0daSSam Leffler dinp->di_size = slen; 695d347a0daSSam Leffler } 696d347a0daSSam Leffler return membuf; 697d347a0daSSam Leffler } 698d347a0daSSam Leffler 699d347a0daSSam Leffler static void * 700d347a0daSSam Leffler ffs_build_dinode2(struct ufs2_dinode *dinp, dirbuf_t *dbufp, fsnode *cur, 701d347a0daSSam Leffler fsnode *root, fsinfo_t *fsopts) 702d347a0daSSam Leffler { 703d347a0daSSam Leffler int slen; 704d347a0daSSam Leffler void *membuf; 7057b03d164SEd Maste struct stat *st = stampst.st_ino != 0 ? &stampst : &cur->inode->st; 706d347a0daSSam Leffler 707d347a0daSSam Leffler memset(dinp, 0, sizeof(*dinp)); 708d347a0daSSam Leffler dinp->di_mode = cur->inode->st.st_mode; 709d347a0daSSam Leffler dinp->di_nlink = cur->inode->nlink; 710d347a0daSSam Leffler dinp->di_size = cur->inode->st.st_size; 711d347a0daSSam Leffler #if HAVE_STRUCT_STAT_ST_FLAGS 712d347a0daSSam Leffler dinp->di_flags = cur->inode->st.st_flags; 713d347a0daSSam Leffler #endif 7144ad8d733SMarcel Moolenaar dinp->di_gen = random(); 715d347a0daSSam Leffler dinp->di_uid = cur->inode->st.st_uid; 716d347a0daSSam Leffler dinp->di_gid = cur->inode->st.st_gid; 7177b03d164SEd Maste 7187b03d164SEd Maste dinp->di_atime = st->st_atime; 7197b03d164SEd Maste dinp->di_mtime = st->st_mtime; 7207b03d164SEd Maste dinp->di_ctime = st->st_ctime; 7217b03d164SEd Maste #if HAVE_STRUCT_STAT_ST_MTIMENSEC 7227b03d164SEd Maste dinp->di_atimensec = st->st_atimensec; 7237b03d164SEd Maste dinp->di_mtimensec = st->st_mtimensec; 7247b03d164SEd Maste dinp->di_ctimensec = st->st_ctimensec; 7257b03d164SEd Maste #endif 7267b03d164SEd Maste #if HAVE_STRUCT_STAT_BIRTHTIME 7277b03d164SEd Maste dinp->di_birthtime = st->st_birthtime; 7287b03d164SEd Maste dinp->di_birthnsec = st->st_birthtimensec; 7297b03d164SEd Maste #endif 730d347a0daSSam Leffler /* not set: di_db, di_ib, di_blocks, di_spare */ 731d347a0daSSam Leffler 732d347a0daSSam Leffler membuf = NULL; 733d347a0daSSam Leffler if (cur == root) { /* "."; write dirbuf */ 734d347a0daSSam Leffler membuf = dbufp->buf; 735d347a0daSSam Leffler dinp->di_size = dbufp->size; 736d347a0daSSam Leffler } else if (S_ISBLK(cur->type) || S_ISCHR(cur->type)) { 737d347a0daSSam Leffler dinp->di_size = 0; /* a device */ 738d347a0daSSam Leffler dinp->di_rdev = 739d347a0daSSam Leffler ufs_rw64(cur->inode->st.st_rdev, fsopts->needswap); 740d347a0daSSam Leffler } else if (S_ISLNK(cur->type)) { /* symlink */ 741d347a0daSSam Leffler slen = strlen(cur->symlink); 7421dc349abSEd Maste if (slen < UFS2_MAXSYMLINKLEN) { /* short link */ 743d347a0daSSam Leffler memcpy(dinp->di_db, cur->symlink, slen); 744d347a0daSSam Leffler } else 745d347a0daSSam Leffler membuf = cur->symlink; 746d347a0daSSam Leffler dinp->di_size = slen; 747d347a0daSSam Leffler } 748d347a0daSSam Leffler return membuf; 749d347a0daSSam Leffler } 750d347a0daSSam Leffler 751d347a0daSSam Leffler static int 752d347a0daSSam Leffler ffs_populate_dir(const char *dir, fsnode *root, fsinfo_t *fsopts) 753d347a0daSSam Leffler { 754d347a0daSSam Leffler fsnode *cur; 755d347a0daSSam Leffler dirbuf_t dirbuf; 756d347a0daSSam Leffler union dinode din; 757d347a0daSSam Leffler void *membuf; 758d347a0daSSam Leffler char path[MAXPATHLEN + 1]; 75901a0f853SOlivier Houchard ffs_opt_t *ffs_opts = fsopts->fs_specific; 760d347a0daSSam Leffler 761d347a0daSSam Leffler assert(dir != NULL); 762d347a0daSSam Leffler assert(root != NULL); 763d347a0daSSam Leffler assert(fsopts != NULL); 76401a0f853SOlivier Houchard assert(ffs_opts != NULL); 765d347a0daSSam Leffler 766d347a0daSSam Leffler (void)memset(&dirbuf, 0, sizeof(dirbuf)); 767d347a0daSSam Leffler 768d347a0daSSam Leffler if (debug & DEBUG_FS_POPULATE) 769d347a0daSSam Leffler printf("ffs_populate_dir: PASS 1 dir %s node %p\n", dir, root); 770d347a0daSSam Leffler 771d347a0daSSam Leffler /* 772d347a0daSSam Leffler * pass 1: allocate inode numbers, build directory `file' 773d347a0daSSam Leffler */ 774d347a0daSSam Leffler for (cur = root; cur != NULL; cur = cur->next) { 775d347a0daSSam Leffler if ((cur->inode->flags & FI_ALLOCATED) == 0) { 776d347a0daSSam Leffler cur->inode->flags |= FI_ALLOCATED; 777d347a0daSSam Leffler if (cur == root && cur->parent != NULL) 778d347a0daSSam Leffler cur->inode->ino = cur->parent->inode->ino; 779d347a0daSSam Leffler else { 780d347a0daSSam Leffler cur->inode->ino = fsopts->curinode; 781d347a0daSSam Leffler fsopts->curinode++; 782d347a0daSSam Leffler } 783d347a0daSSam Leffler } 784d347a0daSSam Leffler ffs_make_dirbuf(&dirbuf, cur->name, cur, fsopts->needswap); 785d347a0daSSam Leffler if (cur == root) { /* we're at "."; add ".." */ 786d347a0daSSam Leffler ffs_make_dirbuf(&dirbuf, "..", 787d347a0daSSam Leffler cur->parent == NULL ? cur : cur->parent->first, 788d347a0daSSam Leffler fsopts->needswap); 789d347a0daSSam Leffler root->inode->nlink++; /* count my parent's link */ 790d347a0daSSam Leffler } else if (cur->child != NULL) 791d347a0daSSam Leffler root->inode->nlink++; /* count my child's link */ 792d347a0daSSam Leffler 793d347a0daSSam Leffler /* 794d347a0daSSam Leffler * XXX possibly write file and long symlinks here, 795d347a0daSSam Leffler * ensuring that blocks get written before inodes? 796d347a0daSSam Leffler * otoh, this isn't a real filesystem, so who 797d347a0daSSam Leffler * cares about ordering? :-) 798d347a0daSSam Leffler */ 799d347a0daSSam Leffler } 800d347a0daSSam Leffler if (debug & DEBUG_FS_POPULATE_DIRBUF) 801d347a0daSSam Leffler ffs_dump_dirbuf(&dirbuf, dir, fsopts->needswap); 802d347a0daSSam Leffler 803d347a0daSSam Leffler /* 804d347a0daSSam Leffler * pass 2: write out dirbuf, then non-directories at this level 805d347a0daSSam Leffler */ 806d347a0daSSam Leffler if (debug & DEBUG_FS_POPULATE) 807d347a0daSSam Leffler printf("ffs_populate_dir: PASS 2 dir %s\n", dir); 808d347a0daSSam Leffler for (cur = root; cur != NULL; cur = cur->next) { 809d347a0daSSam Leffler if (cur->inode->flags & FI_WRITTEN) 810d347a0daSSam Leffler continue; /* skip hard-linked entries */ 811d347a0daSSam Leffler cur->inode->flags |= FI_WRITTEN; 812d347a0daSSam Leffler 813484b5c25SMarcel Moolenaar if (cur->contents == NULL) { 814688aaa09SJung-uk Kim if (snprintf(path, sizeof(path), "%s/%s/%s", cur->root, 815688aaa09SJung-uk Kim cur->path, cur->name) >= (int)sizeof(path)) 816d347a0daSSam Leffler errx(1, "Pathname too long."); 817484b5c25SMarcel Moolenaar } 818d347a0daSSam Leffler 819d347a0daSSam Leffler if (cur->child != NULL) 820d347a0daSSam Leffler continue; /* child creates own inode */ 821d347a0daSSam Leffler 822d347a0daSSam Leffler /* build on-disk inode */ 82301a0f853SOlivier Houchard if (ffs_opts->version == 1) 824d347a0daSSam Leffler membuf = ffs_build_dinode1(&din.ffs1_din, &dirbuf, cur, 825d347a0daSSam Leffler root, fsopts); 826d347a0daSSam Leffler else 827d347a0daSSam Leffler membuf = ffs_build_dinode2(&din.ffs2_din, &dirbuf, cur, 828d347a0daSSam Leffler root, fsopts); 829d347a0daSSam Leffler 830d347a0daSSam Leffler if (debug & DEBUG_FS_POPULATE_NODE) { 831d347a0daSSam Leffler printf("ffs_populate_dir: writing ino %d, %s", 832d347a0daSSam Leffler cur->inode->ino, inode_type(cur->type)); 833d347a0daSSam Leffler if (cur->inode->nlink > 1) 834d347a0daSSam Leffler printf(", nlink %d", cur->inode->nlink); 835d347a0daSSam Leffler putchar('\n'); 836d347a0daSSam Leffler } 837d347a0daSSam Leffler 838d347a0daSSam Leffler if (membuf != NULL) { 839d347a0daSSam Leffler ffs_write_file(&din, cur->inode->ino, membuf, fsopts); 840d347a0daSSam Leffler } else if (S_ISREG(cur->type)) { 841484b5c25SMarcel Moolenaar ffs_write_file(&din, cur->inode->ino, 842484b5c25SMarcel Moolenaar (cur->contents) ? cur->contents : path, fsopts); 843d347a0daSSam Leffler } else { 844d347a0daSSam Leffler assert (! S_ISDIR(cur->type)); 845d347a0daSSam Leffler ffs_write_inode(&din, cur->inode->ino, fsopts); 846d347a0daSSam Leffler } 847d347a0daSSam Leffler } 848d347a0daSSam Leffler 849d347a0daSSam Leffler /* 850d347a0daSSam Leffler * pass 3: write out sub-directories 851d347a0daSSam Leffler */ 852d347a0daSSam Leffler if (debug & DEBUG_FS_POPULATE) 853d347a0daSSam Leffler printf("ffs_populate_dir: PASS 3 dir %s\n", dir); 854d347a0daSSam Leffler for (cur = root; cur != NULL; cur = cur->next) { 855d347a0daSSam Leffler if (cur->child == NULL) 856d347a0daSSam Leffler continue; 857d347a0daSSam Leffler if (snprintf(path, sizeof(path), "%s/%s", dir, cur->name) 858d347a0daSSam Leffler >= sizeof(path)) 859d347a0daSSam Leffler errx(1, "Pathname too long."); 860d347a0daSSam Leffler if (! ffs_populate_dir(path, cur->child, fsopts)) 861d347a0daSSam Leffler return (0); 862d347a0daSSam Leffler } 863d347a0daSSam Leffler 864d347a0daSSam Leffler if (debug & DEBUG_FS_POPULATE) 865d347a0daSSam Leffler printf("ffs_populate_dir: DONE dir %s\n", dir); 866d347a0daSSam Leffler 867d347a0daSSam Leffler /* cleanup */ 868d347a0daSSam Leffler if (dirbuf.buf != NULL) 869d347a0daSSam Leffler free(dirbuf.buf); 870d347a0daSSam Leffler return (1); 871d347a0daSSam Leffler } 872d347a0daSSam Leffler 873d347a0daSSam Leffler 874d347a0daSSam Leffler static void 875d347a0daSSam Leffler ffs_write_file(union dinode *din, uint32_t ino, void *buf, fsinfo_t *fsopts) 876d347a0daSSam Leffler { 877d347a0daSSam Leffler int isfile, ffd; 878d347a0daSSam Leffler char *fbuf, *p; 879d347a0daSSam Leffler off_t bufleft, chunk, offset; 88001a0f853SOlivier Houchard ssize_t nread; 881d347a0daSSam Leffler struct inode in; 882d347a0daSSam Leffler struct buf * bp; 88301a0f853SOlivier Houchard ffs_opt_t *ffs_opts = fsopts->fs_specific; 884d347a0daSSam Leffler 885d347a0daSSam Leffler assert (din != NULL); 886d347a0daSSam Leffler assert (buf != NULL); 887d347a0daSSam Leffler assert (fsopts != NULL); 88801a0f853SOlivier Houchard assert (ffs_opts != NULL); 889d347a0daSSam Leffler 890d347a0daSSam Leffler isfile = S_ISREG(DIP(din, mode)); 891d347a0daSSam Leffler fbuf = NULL; 892d347a0daSSam Leffler ffd = -1; 89301a0f853SOlivier Houchard p = NULL; 894d347a0daSSam Leffler 895d347a0daSSam Leffler in.i_fs = (struct fs *)fsopts->superblock; 896d347a0daSSam Leffler 897d347a0daSSam Leffler if (debug & DEBUG_FS_WRITE_FILE) { 898d347a0daSSam Leffler printf( 899d347a0daSSam Leffler "ffs_write_file: ino %u, din %p, isfile %d, %s, size %lld", 900d347a0daSSam Leffler ino, din, isfile, inode_type(DIP(din, mode) & S_IFMT), 901d347a0daSSam Leffler (long long)DIP(din, size)); 902d347a0daSSam Leffler if (isfile) 903d347a0daSSam Leffler printf(", file '%s'\n", (char *)buf); 904d347a0daSSam Leffler else 905d347a0daSSam Leffler printf(", buffer %p\n", buf); 906d347a0daSSam Leffler } 907d347a0daSSam Leffler 908d347a0daSSam Leffler in.i_number = ino; 909d347a0daSSam Leffler in.i_size = DIP(din, size); 91001a0f853SOlivier Houchard if (ffs_opts->version == 1) 911d347a0daSSam Leffler memcpy(&in.i_din.ffs1_din, &din->ffs1_din, 912d347a0daSSam Leffler sizeof(in.i_din.ffs1_din)); 913d347a0daSSam Leffler else 914d347a0daSSam Leffler memcpy(&in.i_din.ffs2_din, &din->ffs2_din, 915d347a0daSSam Leffler sizeof(in.i_din.ffs2_din)); 916d347a0daSSam Leffler in.i_fd = fsopts->fd; 917d347a0daSSam Leffler 918d347a0daSSam Leffler if (DIP(din, size) == 0) 919d347a0daSSam Leffler goto write_inode_and_leave; /* mmm, cheating */ 920d347a0daSSam Leffler 921d347a0daSSam Leffler if (isfile) { 92201a0f853SOlivier Houchard if ((fbuf = malloc(ffs_opts->bsize)) == NULL) 923d347a0daSSam Leffler err(1, "Allocating memory for write buffer"); 924d347a0daSSam Leffler if ((ffd = open((char *)buf, O_RDONLY, 0444)) == -1) { 925d347a0daSSam Leffler warn("Can't open `%s' for reading", (char *)buf); 926d347a0daSSam Leffler goto leave_ffs_write_file; 927d347a0daSSam Leffler } 928d347a0daSSam Leffler } else { 929d347a0daSSam Leffler p = buf; 930d347a0daSSam Leffler } 931d347a0daSSam Leffler 932d347a0daSSam Leffler chunk = 0; 933d347a0daSSam Leffler for (bufleft = DIP(din, size); bufleft > 0; bufleft -= chunk) { 93401a0f853SOlivier Houchard chunk = MIN(bufleft, ffs_opts->bsize); 93501a0f853SOlivier Houchard if (!isfile) 93601a0f853SOlivier Houchard ; 93701a0f853SOlivier Houchard else if ((nread = read(ffd, fbuf, chunk)) == -1) 93801a0f853SOlivier Houchard err(EXIT_FAILURE, "Reading `%s', %lld bytes to go", 939d347a0daSSam Leffler (char *)buf, (long long)bufleft); 94001a0f853SOlivier Houchard else if (nread != chunk) 94101a0f853SOlivier Houchard errx(EXIT_FAILURE, "Reading `%s', %lld bytes to go, " 94201a0f853SOlivier Houchard "read %zd bytes, expected %ju bytes, does " 94301a0f853SOlivier Houchard "metalog size= attribute mismatch source size?", 94401a0f853SOlivier Houchard (char *)buf, (long long)bufleft, nread, 94501a0f853SOlivier Houchard (uintmax_t)chunk); 94601a0f853SOlivier Houchard else 947d347a0daSSam Leffler p = fbuf; 948d347a0daSSam Leffler offset = DIP(din, size) - bufleft; 949d347a0daSSam Leffler if (debug & DEBUG_FS_WRITE_FILE_BLOCK) 950d347a0daSSam Leffler printf( 951d347a0daSSam Leffler "ffs_write_file: write %p offset %lld size %lld left %lld\n", 952d347a0daSSam Leffler p, (long long)offset, 953d347a0daSSam Leffler (long long)chunk, (long long)bufleft); 954d347a0daSSam Leffler /* 955d347a0daSSam Leffler * XXX if holey support is desired, do the check here 956d347a0daSSam Leffler * 957d347a0daSSam Leffler * XXX might need to write out last bit in fragroundup 958d347a0daSSam Leffler * sized chunk. however, ffs_balloc() handles this for us 959d347a0daSSam Leffler */ 960d347a0daSSam Leffler errno = ffs_balloc(&in, offset, chunk, &bp); 961d347a0daSSam Leffler bad_ffs_write_file: 962d347a0daSSam Leffler if (errno != 0) 963d347a0daSSam Leffler err(1, 964d347a0daSSam Leffler "Writing inode %d (%s), bytes %lld + %lld", 965d347a0daSSam Leffler ino, 966d347a0daSSam Leffler isfile ? (char *)buf : 967d347a0daSSam Leffler inode_type(DIP(din, mode) & S_IFMT), 968d347a0daSSam Leffler (long long)offset, (long long)chunk); 969d347a0daSSam Leffler memcpy(bp->b_data, p, chunk); 970d347a0daSSam Leffler errno = bwrite(bp); 971d347a0daSSam Leffler if (errno != 0) 972d347a0daSSam Leffler goto bad_ffs_write_file; 97378b11a59SEd Maste brelse(bp, 0); 974d347a0daSSam Leffler if (!isfile) 975d347a0daSSam Leffler p += chunk; 976d347a0daSSam Leffler } 977d347a0daSSam Leffler 978d347a0daSSam Leffler write_inode_and_leave: 979d347a0daSSam Leffler ffs_write_inode(&in.i_din, in.i_number, fsopts); 980d347a0daSSam Leffler 981d347a0daSSam Leffler leave_ffs_write_file: 982d347a0daSSam Leffler if (fbuf) 983d347a0daSSam Leffler free(fbuf); 984d347a0daSSam Leffler if (ffd != -1) 985d347a0daSSam Leffler close(ffd); 986d347a0daSSam Leffler } 987d347a0daSSam Leffler 988d347a0daSSam Leffler 989d347a0daSSam Leffler static void 990d347a0daSSam Leffler ffs_dump_dirbuf(dirbuf_t *dbuf, const char *dir, int needswap) 991d347a0daSSam Leffler { 992d347a0daSSam Leffler doff_t i; 993d347a0daSSam Leffler struct direct *de; 994d347a0daSSam Leffler uint16_t reclen; 995d347a0daSSam Leffler 996d347a0daSSam Leffler assert (dbuf != NULL); 997d347a0daSSam Leffler assert (dir != NULL); 998d347a0daSSam Leffler printf("ffs_dump_dirbuf: dir %s size %d cur %d\n", 999d347a0daSSam Leffler dir, dbuf->size, dbuf->cur); 1000d347a0daSSam Leffler 1001d347a0daSSam Leffler for (i = 0; i < dbuf->size; ) { 1002d347a0daSSam Leffler de = (struct direct *)(dbuf->buf + i); 1003d347a0daSSam Leffler reclen = ufs_rw16(de->d_reclen, needswap); 1004d347a0daSSam Leffler printf( 1005d347a0daSSam Leffler " inode %4d %7s offset %4d reclen %3d namlen %3d name %s\n", 1006d347a0daSSam Leffler ufs_rw32(de->d_ino, needswap), 1007d347a0daSSam Leffler inode_type(DTTOIF(de->d_type)), i, reclen, 1008d347a0daSSam Leffler de->d_namlen, de->d_name); 1009d347a0daSSam Leffler i += reclen; 1010d347a0daSSam Leffler assert(reclen > 0); 1011d347a0daSSam Leffler } 1012d347a0daSSam Leffler } 1013d347a0daSSam Leffler 1014d347a0daSSam Leffler static void 1015d347a0daSSam Leffler ffs_make_dirbuf(dirbuf_t *dbuf, const char *name, fsnode *node, int needswap) 1016d347a0daSSam Leffler { 1017d347a0daSSam Leffler struct direct de, *dp; 1018d347a0daSSam Leffler uint16_t llen, reclen; 101901a0f853SOlivier Houchard u_char *newbuf; 1020d347a0daSSam Leffler 1021d347a0daSSam Leffler assert (dbuf != NULL); 1022d347a0daSSam Leffler assert (name != NULL); 1023d347a0daSSam Leffler assert (node != NULL); 1024d347a0daSSam Leffler /* create direct entry */ 1025d347a0daSSam Leffler (void)memset(&de, 0, sizeof(de)); 1026d347a0daSSam Leffler de.d_ino = ufs_rw32(node->inode->ino, needswap); 1027d347a0daSSam Leffler de.d_type = IFTODT(node->type); 1028d347a0daSSam Leffler de.d_namlen = (uint8_t)strlen(name); 1029d347a0daSSam Leffler strcpy(de.d_name, name); 1030d347a0daSSam Leffler reclen = DIRSIZ_SWAP(0, &de, needswap); 1031d347a0daSSam Leffler de.d_reclen = ufs_rw16(reclen, needswap); 1032d347a0daSSam Leffler 1033d347a0daSSam Leffler dp = (struct direct *)(dbuf->buf + dbuf->cur); 1034d347a0daSSam Leffler llen = 0; 1035d347a0daSSam Leffler if (dp != NULL) 1036d347a0daSSam Leffler llen = DIRSIZ_SWAP(0, dp, needswap); 1037d347a0daSSam Leffler 1038d347a0daSSam Leffler if (debug & DEBUG_FS_MAKE_DIRBUF) 1039d347a0daSSam Leffler printf( 1040d347a0daSSam Leffler "ffs_make_dirbuf: dbuf siz %d cur %d lastlen %d\n" 1041d347a0daSSam Leffler " ino %d type %d reclen %d namlen %d name %.30s\n", 1042d347a0daSSam Leffler dbuf->size, dbuf->cur, llen, 1043d347a0daSSam Leffler ufs_rw32(de.d_ino, needswap), de.d_type, reclen, 1044d347a0daSSam Leffler de.d_namlen, de.d_name); 1045d347a0daSSam Leffler 1046d347a0daSSam Leffler if (reclen + dbuf->cur + llen > roundup(dbuf->size, DIRBLKSIZ)) { 1047d347a0daSSam Leffler if (debug & DEBUG_FS_MAKE_DIRBUF) 1048d347a0daSSam Leffler printf("ffs_make_dirbuf: growing buf to %d\n", 1049d347a0daSSam Leffler dbuf->size + DIRBLKSIZ); 1050d347a0daSSam Leffler if ((newbuf = realloc(dbuf->buf, dbuf->size + DIRBLKSIZ)) == NULL) 1051d347a0daSSam Leffler err(1, "Allocating memory for directory buffer"); 1052d347a0daSSam Leffler dbuf->buf = newbuf; 1053d347a0daSSam Leffler dbuf->size += DIRBLKSIZ; 1054d347a0daSSam Leffler memset(dbuf->buf + dbuf->size - DIRBLKSIZ, 0, DIRBLKSIZ); 1055d347a0daSSam Leffler dbuf->cur = dbuf->size - DIRBLKSIZ; 105601a0f853SOlivier Houchard } else if (dp) { /* shrink end of previous */ 1057d347a0daSSam Leffler dp->d_reclen = ufs_rw16(llen,needswap); 1058d347a0daSSam Leffler dbuf->cur += llen; 1059d347a0daSSam Leffler } 1060d347a0daSSam Leffler dp = (struct direct *)(dbuf->buf + dbuf->cur); 1061d347a0daSSam Leffler memcpy(dp, &de, reclen); 1062d347a0daSSam Leffler dp->d_reclen = ufs_rw16(dbuf->size - dbuf->cur, needswap); 1063d347a0daSSam Leffler } 1064d347a0daSSam Leffler 1065d347a0daSSam Leffler /* 1066d347a0daSSam Leffler * cribbed from sys/ufs/ffs/ffs_alloc.c 1067d347a0daSSam Leffler */ 1068d347a0daSSam Leffler static void 1069d347a0daSSam Leffler ffs_write_inode(union dinode *dp, uint32_t ino, const fsinfo_t *fsopts) 1070d347a0daSSam Leffler { 1071d347a0daSSam Leffler char *buf; 1072d347a0daSSam Leffler struct ufs1_dinode *dp1; 1073d347a0daSSam Leffler struct ufs2_dinode *dp2, *dip; 1074d347a0daSSam Leffler struct cg *cgp; 1075d347a0daSSam Leffler struct fs *fs; 1076d347a0daSSam Leffler int cg, cgino, i; 1077d347a0daSSam Leffler daddr_t d; 1078d347a0daSSam Leffler char sbbuf[FFS_MAXBSIZE]; 1079d347a0daSSam Leffler int32_t initediblk; 108001a0f853SOlivier Houchard ffs_opt_t *ffs_opts = fsopts->fs_specific; 1081d347a0daSSam Leffler 1082d347a0daSSam Leffler assert (dp != NULL); 1083d347a0daSSam Leffler assert (ino > 0); 1084d347a0daSSam Leffler assert (fsopts != NULL); 108501a0f853SOlivier Houchard assert (ffs_opts != NULL); 1086d347a0daSSam Leffler 1087d347a0daSSam Leffler fs = (struct fs *)fsopts->superblock; 1088d347a0daSSam Leffler cg = ino_to_cg(fs, ino); 1089d347a0daSSam Leffler cgino = ino % fs->fs_ipg; 1090d347a0daSSam Leffler if (debug & DEBUG_FS_WRITE_INODE) 1091d347a0daSSam Leffler printf("ffs_write_inode: din %p ino %u cg %d cgino %d\n", 1092d347a0daSSam Leffler dp, ino, cg, cgino); 1093d347a0daSSam Leffler 1094d347a0daSSam Leffler ffs_rdfs(fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf, 1095d347a0daSSam Leffler fsopts); 1096d347a0daSSam Leffler cgp = (struct cg *)sbbuf; 1097d347a0daSSam Leffler if (!cg_chkmagic_swap(cgp, fsopts->needswap)) 1098d347a0daSSam Leffler errx(1, "ffs_write_inode: cg %d: bad magic number", cg); 1099d347a0daSSam Leffler 1100d347a0daSSam Leffler assert (isclr(cg_inosused_swap(cgp, fsopts->needswap), cgino)); 1101d347a0daSSam Leffler 1102d347a0daSSam Leffler buf = malloc(fs->fs_bsize); 1103d347a0daSSam Leffler if (buf == NULL) 1104d347a0daSSam Leffler errx(1, "ffs_write_inode: cg %d: can't alloc inode block", cg); 1105d347a0daSSam Leffler 1106d347a0daSSam Leffler dp1 = (struct ufs1_dinode *)buf; 1107d347a0daSSam Leffler dp2 = (struct ufs2_dinode *)buf; 1108d347a0daSSam Leffler 1109d347a0daSSam Leffler if (fs->fs_cstotal.cs_nifree == 0) 1110d347a0daSSam Leffler errx(1, "ffs_write_inode: fs out of inodes for ino %u", 1111d347a0daSSam Leffler ino); 1112d347a0daSSam Leffler if (fs->fs_cs(fs, cg).cs_nifree == 0) 1113d347a0daSSam Leffler errx(1, 1114d347a0daSSam Leffler "ffs_write_inode: cg %d out of inodes for ino %u", 1115d347a0daSSam Leffler cg, ino); 1116d347a0daSSam Leffler setbit(cg_inosused_swap(cgp, fsopts->needswap), cgino); 1117d347a0daSSam Leffler ufs_add32(cgp->cg_cs.cs_nifree, -1, fsopts->needswap); 1118d347a0daSSam Leffler fs->fs_cstotal.cs_nifree--; 1119d347a0daSSam Leffler fs->fs_cs(fs, cg).cs_nifree--; 1120d347a0daSSam Leffler if (S_ISDIR(DIP(dp, mode))) { 1121d347a0daSSam Leffler ufs_add32(cgp->cg_cs.cs_ndir, 1, fsopts->needswap); 1122d347a0daSSam Leffler fs->fs_cstotal.cs_ndir++; 1123d347a0daSSam Leffler fs->fs_cs(fs, cg).cs_ndir++; 1124d347a0daSSam Leffler } 1125d347a0daSSam Leffler 1126d347a0daSSam Leffler /* 1127d347a0daSSam Leffler * Initialize inode blocks on the fly for UFS2. 1128d347a0daSSam Leffler */ 1129d347a0daSSam Leffler initediblk = ufs_rw32(cgp->cg_initediblk, fsopts->needswap); 113001a0f853SOlivier Houchard if (ffs_opts->version == 2 && cgino + INOPB(fs) > initediblk && 1131d347a0daSSam Leffler initediblk < ufs_rw32(cgp->cg_niblk, fsopts->needswap)) { 1132d347a0daSSam Leffler memset(buf, 0, fs->fs_bsize); 1133d347a0daSSam Leffler dip = (struct ufs2_dinode *)buf; 1134d347a0daSSam Leffler for (i = 0; i < INOPB(fs); i++) { 113540d39b4bSPedro F. Giffuni dip->di_gen = random(); 1136d347a0daSSam Leffler dip++; 1137d347a0daSSam Leffler } 1138d347a0daSSam Leffler ffs_wtfs(fsbtodb(fs, ino_to_fsba(fs, 1139d347a0daSSam Leffler cg * fs->fs_ipg + initediblk)), 1140d347a0daSSam Leffler fs->fs_bsize, buf, fsopts); 1141d347a0daSSam Leffler initediblk += INOPB(fs); 1142d347a0daSSam Leffler cgp->cg_initediblk = ufs_rw32(initediblk, fsopts->needswap); 1143d347a0daSSam Leffler } 1144d347a0daSSam Leffler 1145d347a0daSSam Leffler 1146d347a0daSSam Leffler ffs_wtfs(fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize, &sbbuf, 1147d347a0daSSam Leffler fsopts); 1148d347a0daSSam Leffler 1149d347a0daSSam Leffler /* now write inode */ 1150d347a0daSSam Leffler d = fsbtodb(fs, ino_to_fsba(fs, ino)); 1151d347a0daSSam Leffler ffs_rdfs(d, fs->fs_bsize, buf, fsopts); 1152d347a0daSSam Leffler if (fsopts->needswap) { 115301a0f853SOlivier Houchard if (ffs_opts->version == 1) 1154d347a0daSSam Leffler ffs_dinode1_swap(&dp->ffs1_din, 1155d347a0daSSam Leffler &dp1[ino_to_fsbo(fs, ino)]); 1156d347a0daSSam Leffler else 1157d347a0daSSam Leffler ffs_dinode2_swap(&dp->ffs2_din, 1158d347a0daSSam Leffler &dp2[ino_to_fsbo(fs, ino)]); 1159d347a0daSSam Leffler } else { 116001a0f853SOlivier Houchard if (ffs_opts->version == 1) 1161d347a0daSSam Leffler dp1[ino_to_fsbo(fs, ino)] = dp->ffs1_din; 1162d347a0daSSam Leffler else 1163d347a0daSSam Leffler dp2[ino_to_fsbo(fs, ino)] = dp->ffs2_din; 1164d347a0daSSam Leffler } 1165d347a0daSSam Leffler ffs_wtfs(d, fs->fs_bsize, buf, fsopts); 1166d347a0daSSam Leffler free(buf); 1167d347a0daSSam Leffler } 1168d347a0daSSam Leffler 1169d347a0daSSam Leffler void 1170d347a0daSSam Leffler panic(const char *fmt, ...) 1171d347a0daSSam Leffler { 1172d347a0daSSam Leffler va_list ap; 1173d347a0daSSam Leffler 1174d347a0daSSam Leffler va_start(ap, fmt); 1175d347a0daSSam Leffler vwarnx(fmt, ap); 1176d347a0daSSam Leffler va_end(ap); 1177d347a0daSSam Leffler exit(1); 1178d347a0daSSam Leffler } 1179