1 /* $NetBSD: main.c,v 1.11 2022/02/27 21:05:11 zafer Exp $ */ 2 3 /*- 4 * Copyright (c) 2011 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by UCHIYAMA Yasushi. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #if HAVE_NBTOOL_CONFIG_H 33 #include "nbtool_config.h" 34 #endif 35 36 #include <sys/cdefs.h> 37 #ifndef lint 38 __RCSID("$NetBSD: main.c,v 1.11 2022/02/27 21:05:11 zafer Exp $"); 39 #endif /* not lint */ 40 41 #include <sys/param.h> 42 #include <stdio.h> 43 #include <string.h> 44 #include <errno.h> 45 #include <time.h> 46 #include <err.h> 47 48 #include "v7fs.h" 49 #include "v7fs_impl.h" 50 #include "v7fs_endian.h" 51 #include "v7fs_superblock.h" 52 #include "v7fs_inode.h" 53 #include "v7fs_datablock.h" /*v7fs_datablock_expand/last */ 54 #include "newfs_v7fs.h" 55 #include "progress.h" /*../sbin/fsck */ 56 57 #define VPRINTF(lv, fmt, args...) { if (v7fs_newfs_verbose >= lv) \ 58 printf(fmt, ##args); } 59 60 static v7fs_daddr_t 61 determine_ilist_size(v7fs_daddr_t volume_size, int32_t files) 62 { 63 v7fs_daddr_t ilist_size; 64 65 if (files) 66 ilist_size = howmany(files, V7FS_INODE_PER_BLOCK); 67 else 68 ilist_size = volume_size / 25; /* 4% */ 69 if (ilist_size > (v7fs_daddr_t)V7FS_ILISTBLK_MAX) 70 ilist_size = V7FS_ILISTBLK_MAX; 71 72 return ilist_size; 73 } 74 75 static int 76 partition_check(struct v7fs_self *fs) 77 { 78 struct v7fs_superblock *sb = &fs->superblock; 79 int error; 80 81 if ((error = v7fs_superblock_load(fs))) { 82 if (error != EINVAL) { 83 /* Invalid superblock information is OK. */ 84 warnx("Can't read superblock sector."); 85 } 86 } 87 sb->modified = 1; 88 if ((error = v7fs_superblock_writeback(fs))) { 89 if (errno == EROFS) { 90 warnx("Overwriting disk label? "); 91 } 92 warnx("Can't write superblock sector."); 93 } 94 95 return error; 96 } 97 98 static int 99 make_root(struct v7fs_self *fs) 100 { 101 struct v7fs_inode inode; 102 struct v7fs_dirent *dir; 103 int error; 104 105 /* INO 1 badblk (don't used) */ 106 memset(&inode, 0, sizeof(inode)); 107 inode.inode_number = 1; 108 inode.mode = V7FS_IFREG; /* V7 manner */ 109 v7fs_inode_writeback(fs, &inode); 110 111 /* INO 2 root */ 112 v7fs_ino_t ino; 113 if ((error = v7fs_inode_allocate(fs, &ino))) { 114 errno = error; 115 warn("Can't allocate / inode"); 116 return error; 117 } 118 119 memset(&inode, 0, sizeof(inode)); 120 inode.inode_number = ino; 121 inode.mode = 0777 | V7FS_IFDIR; 122 inode.uid = 0; 123 inode.gid = 0; 124 inode.nlink = 2; /* . + .. */ 125 inode.atime = inode.mtime = inode.ctime = time(0); 126 127 /* root dirent. */ 128 v7fs_datablock_expand(fs, &inode, sizeof(*dir) * 2); 129 v7fs_daddr_t blk = inode.addr[0]; 130 void *buf; 131 if (!(buf = scratch_read(fs, blk))) { 132 v7fs_inode_deallocate(fs, ino); 133 errno = error = EIO; 134 warn("Can't read / dirent."); 135 return error; 136 } 137 dir = (struct v7fs_dirent *)buf; /*disk endian */ 138 139 strcpy(dir[0].name, "."); 140 dir[0].inode_number = V7FS_VAL16(fs, ino); 141 strcpy(dir[1].name, ".."); 142 dir[1].inode_number = V7FS_VAL16(fs, ino); 143 if (!fs->io.write(fs->io.cookie, buf, blk)) {/*writeback */ 144 scratch_free(fs, buf); 145 errno = error = EIO; 146 warn("Can't write / dirent."); 147 return error; 148 } 149 scratch_free(fs, buf); 150 v7fs_inode_writeback(fs, &inode); 151 if ((error = v7fs_superblock_writeback(fs))) { 152 errno = error; 153 warnx("Can't write superblock."); 154 } 155 156 return error; 157 } 158 159 static v7fs_daddr_t 160 make_freeblocklist(struct v7fs_self *fs, v7fs_daddr_t listblk, uint8_t *buf) 161 { 162 uint32_t (*val32)(uint32_t) = fs->val.conv32; 163 uint16_t (*val16)(uint16_t) = fs->val.conv16; 164 struct v7fs_freeblock *fb = (struct v7fs_freeblock *)buf; 165 int i, j, k; 166 167 memset(buf, 0, V7FS_BSIZE); 168 169 for (i = V7FS_MAX_FREEBLOCK - 1, j = listblk + 1, k = 0; i >= 0; 170 i--, j++, k++) { 171 progress(0); 172 if (j == (int32_t)fs->superblock.volume_size) 173 { 174 VPRINTF(4, "\nlast freeblock #%d\n", 175 (*val32)(fb->freeblock[i + 1])); 176 177 memmove(fb->freeblock + 1, fb->freeblock + i + 1, k * 178 sizeof(v7fs_daddr_t)); 179 fb->freeblock[0] = 0; /* Terminate link; */ 180 fb->nfreeblock = (*val16)(k + 1); 181 VPRINTF(4, "last freeblock contains #%d\n", 182 (*val16)(fb->nfreeblock)); 183 fs->io.write(fs->io.cookie, buf, listblk); 184 return 0; 185 } 186 fb->freeblock[i] = (*val32)(j); 187 } 188 fb->nfreeblock = (*val16)(k); 189 190 if (!fs->io.write(fs->io.cookie, buf, listblk)) { 191 errno = EIO; 192 warn("blk=%ld", (long)listblk); 193 return 0; 194 } 195 196 /* Return next link block */ 197 return (*val32)(fb->freeblock[0]); 198 } 199 200 static int 201 make_filesystem(struct v7fs_self *fs, v7fs_daddr_t volume_size, 202 v7fs_daddr_t ilist_size) 203 { 204 struct v7fs_superblock *sb; 205 v7fs_daddr_t blk; 206 uint8_t buf[V7FS_BSIZE]; 207 int error = 0; 208 int32_t i, j; 209 210 /* Setup ilist. (ilist must be zero filled. because of they are free) */ 211 VPRINTF(4, "Zero clear ilist.\n"); 212 progress(&(struct progress_arg){ .label = "zero ilist", .tick = 213 ilist_size / PROGRESS_BAR_GRANULE }); 214 memset(buf, 0, sizeof buf); 215 for (i = V7FS_ILIST_SECTOR; i < (int32_t)ilist_size; i++) { 216 fs->io.write(fs->io.cookie, buf, i); 217 progress(0); 218 } 219 #ifndef HAVE_NBTOOL_CONFIG_H 220 progress_done(); 221 #endif 222 VPRINTF(4, "\n"); 223 224 /* Construct superblock */ 225 sb = &fs->superblock; 226 sb->volume_size = volume_size; 227 sb->datablock_start_sector = ilist_size + V7FS_ILIST_SECTOR; 228 sb->update_time = time(NULL); 229 230 /* fill free inode cache. */ 231 VPRINTF(4, "Setup inode cache.\n"); 232 sb->nfreeinode = V7FS_MAX_FREEINODE; 233 for (i = V7FS_MAX_FREEINODE - 1, j = V7FS_ROOT_INODE; i >= 0; i--, j++) 234 sb->freeinode[i] = j; 235 sb->total_freeinode = ilist_size * V7FS_INODE_PER_BLOCK - 1; 236 237 /* fill free block cache. */ 238 VPRINTF(4, "Setup free block cache.\n"); 239 sb->nfreeblock = V7FS_MAX_FREEBLOCK; 240 for (i = V7FS_MAX_FREEBLOCK - 1, j = sb->datablock_start_sector; i >= 0; 241 i--, j++) 242 sb->freeblock[i] = j; 243 244 sb->total_freeblock = volume_size - sb->datablock_start_sector; 245 246 /* Write superblock. */ 247 sb->modified = 1; 248 if ((error = v7fs_superblock_writeback(fs))) { 249 errno = error; 250 warn("Can't write back superblock."); 251 return error; 252 } 253 254 /* Construct freeblock list */ 255 VPRINTF(4, "Setup whole freeblock list.\n"); 256 progress(&(struct progress_arg){ .label = "freeblock list", .tick = 257 (volume_size - sb->datablock_start_sector) / PROGRESS_BAR_GRANULE}); 258 blk = sb->freeblock[0]; 259 while ((blk = make_freeblocklist(fs, blk, buf))) 260 continue; 261 #ifndef HAVE_NBTOOL_CONFIG_H 262 progress_done(); 263 #endif 264 265 VPRINTF(4, "done.\n"); 266 267 return 0; 268 } 269 270 int 271 v7fs_newfs(const struct v7fs_mount_device *mount, int32_t maxfile) 272 { 273 struct v7fs_self *fs; 274 v7fs_daddr_t ilist_size; 275 int error; 276 v7fs_daddr_t volume_size = mount->sectors; 277 278 /* Check and determine ilistblock, datablock size. */ 279 if (volume_size > V7FS_DADDR_MAX + 1) { 280 warnx("volume size %d over v7fs limit %d. truncated.", 281 volume_size, V7FS_DADDR_MAX + 1); 282 volume_size = V7FS_DADDR_MAX + 1; 283 } 284 285 ilist_size = determine_ilist_size(volume_size, maxfile); 286 287 VPRINTF(1, "volume size=%d, ilist size=%d, endian=%d, NAME_MAX=%d\n", 288 volume_size, ilist_size, mount->endian, V7FS_NAME_MAX); 289 290 /* Setup I/O ops. */ 291 if ((error = v7fs_io_init(&fs, mount, V7FS_BSIZE))) { 292 errno = error; 293 warn("I/O setup failed."); 294 return error; 295 } 296 fs->endian = mount->endian; 297 v7fs_endian_init(fs); 298 299 if ((error = partition_check(fs))) { 300 return error; 301 } 302 303 /* Construct filesystem. */ 304 if ((error = make_filesystem(fs, volume_size, ilist_size))) { 305 return error; 306 } 307 308 /* Setup root. */ 309 if ((error = make_root(fs))) { 310 return error; 311 } 312 313 v7fs_io_fini(fs); 314 315 return 0; 316 } 317
Indexes created Sat Sep 20 22:09:52 GMT 2025