1 /* $NetBSD: make_lfs.c,v 1.59 2015/10/15 06:24:33 dholland Exp $ */
2
3 /*-
4 * Copyright (c) 2003 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Konrad E. Schroder <perseant@hhhh.org>.
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 * Copyright (c) 1991, 1993
33 * The Regents of the University of California. All rights reserved.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 * notice, this list of conditions and the following disclaimer in the
42 * documentation and/or other materials provided with the distribution.
43 * 3. Neither the name of the University nor the names of its contributors
44 * may be used to endorse or promote products derived from this software
45 * without specific prior written permission.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57 * SUCH DAMAGE.
58 */
59
60 #include <sys/cdefs.h>
61 #ifndef lint
62 #if 0
63 static char sccsid[] = "@(#)lfs.c 8.5 (Berkeley) 5/24/95";
64 #else
65 __RCSID("$NetBSD: make_lfs.c,v 1.59 2015/10/15 06:24:33 dholland Exp $");
66 #endif
67 #endif /* not lint */
68
69 #include <sys/param.h>
70 #include <sys/disk.h>
71 #include <sys/time.h>
72 #include <sys/mount.h>
73 #include <sys/stat.h>
74
75 /* Override certain things to make <ufs/lfs/lfs.h> work */
76 # undef simple_lock
77 # define simple_lock(x)
78 # undef simple_unlock
79 # define simple_unlock(x)
80 # define vnode uvnode
81 # define buf ubuf
82 # define panic call_panic
83 #include <ufs/lfs/lfs.h>
84 #include <ufs/lfs/lfs_accessors.h>
85 #include <ufs/lfs/lfs_inode.h>
86
87 #include <err.h>
88 #include <errno.h>
89 #include <stdio.h>
90 #include <stdlib.h>
91 #include <string.h>
92 #include <time.h>
93 #include <unistd.h>
94
95 #include "config.h"
96 #include "extern.h"
97
98 #include "bufcache.h"
99 #include "vnode.h"
100 #include "lfs_user.h"
101 #include "segwrite.h"
102
103 extern int Nflag; /* Don't write anything */
104
105 static blkcnt_t ifibc; /* How many indirect blocks */
106
107 #ifdef MAKE_LF_DIR
108 # define HIGHEST_USED_INO LOSTFOUNDINO
109 #else
110 # define HIGHEST_USED_INO ULFS_ROOTINO
111 #endif
112
113 static const struct dlfs dlfs32_default = {
114 .dlfs_magic = LFS_MAGIC,
115 .dlfs_version = LFS_VERSION,
116 .dlfs_size = 0,
117 .dlfs_ssize = DFL_LFSSEG,
118 .dlfs_dsize = 0,
119 .dlfs_bsize = DFL_LFSBLOCK,
120 .dlfs_fsize = DFL_LFSFRAG,
121 .dlfs_frag = DFL_LFSBLOCK/DFL_LFSFRAG,
122 .dlfs_freehd = HIGHEST_USED_INO + 1,
123 .dlfs_bfree = 0,
124 .dlfs_nfiles = 0,
125 .dlfs_avail = 0,
126 .dlfs_uinodes = 0,
127 .dlfs_idaddr = 0,
128 .dlfs_ifile = LFS_IFILE_INUM,
129 .dlfs_lastseg = 0,
130 .dlfs_nextseg = 0,
131 .dlfs_curseg = 0,
132 .dlfs_offset = 0,
133 .dlfs_lastpseg = 0,
134 .dlfs_inopf = 0,
135 .dlfs_minfree = MINFREE,
136 .dlfs_maxfilesize = 0,
137 .dlfs_fsbpseg = 0,
138 .dlfs_inopb = DFL_LFSBLOCK/sizeof(struct lfs32_dinode),
139 .dlfs_ifpb = DFL_LFSBLOCK/sizeof(IFILE32),
140 .dlfs_sepb = DFL_LFSBLOCK/sizeof(SEGUSE),
141 .dlfs_nindir = DFL_LFSBLOCK/sizeof(int32_t),
142 .dlfs_nseg = 0,
143 .dlfs_nspf = 0,
144 .dlfs_cleansz = 0,
145 .dlfs_segtabsz = 0,
146 .dlfs_segmask = DFL_LFSSEG_MASK,
147 .dlfs_segshift = DFL_LFSSEG_SHIFT,
148 .dlfs_bshift = DFL_LFSBLOCK_SHIFT,
149 .dlfs_ffshift = DFL_LFS_FFSHIFT,
150 .dlfs_fbshift = DFL_LFS_FBSHIFT,
151 .dlfs_bmask = DFL_LFSBLOCK_MASK,
152 .dlfs_ffmask = DFL_LFS_FFMASK,
153 .dlfs_fbmask = DFL_LFS_FBMASK,
154 .dlfs_blktodb = 0,
155 .dlfs_sushift = 0,
156 .dlfs_maxsymlinklen = LFS32_MAXSYMLINKLEN,
157 .dlfs_sboffs = { 0 },
158 .dlfs_nclean = 0,
159 .dlfs_fsmnt = { 0 },
160 .dlfs_pflags = LFS_PF_CLEAN,
161 .dlfs_dmeta = 0,
162 .dlfs_minfreeseg = 0,
163 .dlfs_sumsize = 0,
164 .dlfs_serial = 0,
165 .dlfs_ibsize = DFL_LFSFRAG,
166 .dlfs_s0addr = 0,
167 .dlfs_tstamp = 0,
168 .dlfs_inodefmt = LFS_44INODEFMT,
169 .dlfs_interleave = 0,
170 .dlfs_ident = 0,
171 .dlfs_fsbtodb = 0,
172 .dlfs_resvseg = 0,
173
174 .dlfs_pad = { 0 },
175 .dlfs_cksum = 0
176 };
177
178 static const struct dlfs64 dlfs64_default = {
179 .dlfs_magic = LFS64_MAGIC,
180 .dlfs_version = LFS_VERSION,
181 .dlfs_size = 0,
182 .dlfs_dsize = 0,
183 .dlfs_ssize = DFL_LFSSEG,
184 .dlfs_bsize = DFL_LFSBLOCK,
185 .dlfs_fsize = DFL_LFSFRAG,
186 .dlfs_frag = DFL_LFSBLOCK/DFL_LFSFRAG,
187 .dlfs_freehd = HIGHEST_USED_INO + 1,
188 .dlfs_nfiles = 0,
189 .dlfs_bfree = 0,
190 .dlfs_avail = 0,
191 .dlfs_idaddr = 0,
192 .dlfs_uinodes = 0,
193 .dlfs_unused_0 = 0,
194 .dlfs_lastseg = 0,
195 .dlfs_nextseg = 0,
196 .dlfs_curseg = 0,
197 .dlfs_offset = 0,
198 .dlfs_lastpseg = 0,
199 .dlfs_inopf = 0,
200 .dlfs_minfree = MINFREE,
201 .dlfs_maxfilesize = 0,
202 .dlfs_fsbpseg = 0,
203 .dlfs_inopb = DFL_LFSBLOCK/sizeof(struct lfs64_dinode),
204 .dlfs_ifpb = DFL_LFSBLOCK/sizeof(IFILE64),
205 .dlfs_sepb = DFL_LFSBLOCK/sizeof(SEGUSE),
206 .dlfs_nindir = DFL_LFSBLOCK/sizeof(int64_t),
207 .dlfs_nseg = 0,
208 .dlfs_nspf = 0,
209 .dlfs_cleansz = 0,
210 .dlfs_segtabsz = 0,
211 .dlfs_bshift = DFL_LFSBLOCK_SHIFT,
212 .dlfs_ffshift = DFL_LFS_FFSHIFT,
213 .dlfs_fbshift = DFL_LFS_FBSHIFT,
214 .dlfs_bmask = DFL_LFSBLOCK_MASK,
215 .dlfs_ffmask = DFL_LFS_FFMASK,
216 .dlfs_fbmask = DFL_LFS_FBMASK,
217 .dlfs_blktodb = 0,
218 .dlfs_sushift = 0,
219 .dlfs_sboffs = { 0 },
220 .dlfs_maxsymlinklen = LFS64_MAXSYMLINKLEN,
221 .dlfs_nclean = 0,
222 .dlfs_fsmnt = { 0 },
223 .dlfs_pflags = LFS_PF_CLEAN,
224 .dlfs_dmeta = 0,
225 .dlfs_minfreeseg = 0,
226 .dlfs_sumsize = 0,
227 .dlfs_ibsize = DFL_LFSFRAG,
228 .dlfs_inodefmt = LFS_44INODEFMT,
229 .dlfs_serial = 0,
230 .dlfs_s0addr = 0,
231 .dlfs_tstamp = 0,
232 .dlfs_interleave = 0,
233 .dlfs_ident = 0,
234 .dlfs_fsbtodb = 0,
235 .dlfs_resvseg = 0,
236
237 .dlfs_pad = { 0 },
238 .dlfs_cksum = 0
239 };
240
241 static const struct lfs lfs_default;
242
243 #define UMASK 0755
244
245 struct dirproto {
246 ino_t dp_ino;
247 const char *dp_name;
248 unsigned dp_type;
249 };
250
251 static const struct dirproto lfs_root_dir[] = {
252 { ULFS_ROOTINO, ".", LFS_DT_DIR },
253 { ULFS_ROOTINO, "..", LFS_DT_DIR },
254 /*{ LFS_IFILE_INUM, "ifile", LFS_DT_REG },*/
255 #ifdef MAKE_LF_DIR
256 { LOSTFOUNDINO, "lost+found", LFS_DT_DIR },
257 #endif
258 };
259
260 #ifdef MAKE_LF_DIR
261 static const struct dirproto lfs_lf_dir[] = {
262 { LOSTFOUNDINO, ".", LFS_DT_DIR },
263 { ULFS_ROOTINO, "..", LFS_DT_DIR },
264 };
265 #endif
266
267 void pwarn(const char *, ...);
268 static void make_dinode(ino_t, union lfs_dinode *, int, struct lfs *);
269 static void make_dir(struct lfs *, void *,
270 const struct dirproto *, unsigned);
271
272 /*
273 * calculate the maximum file size allowed with the specified block shift.
274 */
275 static uint64_t
maxfilesize(struct lfs * fs,int bshift)276 maxfilesize(struct lfs *fs, int bshift)
277 {
278 uint64_t nptr; /* number of block pointers per block */
279 uint64_t maxblock;
280
281 nptr = (1 << bshift) / LFS_BLKPTRSIZE(fs);
282 maxblock = ULFS_NDADDR + nptr + nptr * nptr + nptr * nptr * nptr;
283
284 return maxblock << bshift;
285 }
286
287 /*
288 * Create the root directory for this file system and the lost+found
289 * directory.
290 */
291 static void
make_dinode(ino_t ino,union lfs_dinode * dip,int nfrags,struct lfs * fs)292 make_dinode(ino_t ino, union lfs_dinode *dip, int nfrags, struct lfs *fs)
293 {
294 int i;
295 int nblocks, bb, base, factor, lvl;
296 time_t t;
297
298 nblocks = howmany(nfrags, lfs_sb_getfrag(fs));
299 if (nblocks >= ULFS_NDADDR)
300 nfrags = roundup(nfrags, lfs_sb_getfrag(fs));
301
302 lfs_dino_setnlink(fs, dip, 1);
303 lfs_dino_setblocks(fs, dip, nfrags);
304
305 lfs_dino_setsize(fs, dip, nfrags << lfs_sb_getffshift(fs));
306 t = lfs_sb_gettstamp(fs);
307 lfs_dino_setatime(fs, dip, t);
308 lfs_dino_setmtime(fs, dip, t);
309 lfs_dino_setctime(fs, dip, t);
310 lfs_dino_setatimensec(fs, dip, 0);
311 lfs_dino_setmtimensec(fs, dip, 0);
312 lfs_dino_setctimensec(fs, dip, 0);
313 lfs_dino_setinumber(fs, dip, ino);
314 lfs_dino_setgen(fs, dip, 1);
315
316 if (ULFS_NDADDR < nblocks) {
317 /* Count up how many indirect blocks we need, recursively */
318 /* XXX We are only called with nblocks > 1 for Ifile */
319 bb = nblocks - ULFS_NDADDR;
320 while (bb > 0) {
321 bb = howmany(bb, LFS_NINDIR(fs));
322 ifibc += bb;
323 --bb;
324 }
325 lfs_dino_setblocks(fs, dip,
326 lfs_dino_getblocks(fs, dip) + lfs_blkstofrags(fs, ifibc));
327 }
328
329 /* Assign the block addresses for the ifile */
330 for (i = 0; i < MIN(nblocks,ULFS_NDADDR); i++) {
331 lfs_dino_setdb(fs, dip, i, 0x0);
332 }
333 if (nblocks > ULFS_NDADDR) {
334 lfs_dino_setib(fs, dip, 0, 0x0);
335 bb = howmany(nblocks - ULFS_NDADDR, LFS_NINDIR(fs)) - 1;
336 factor = LFS_NINDIR(fs);
337 base = -ULFS_NDADDR - factor;
338 lvl = 1;
339 while (bb > 0) {
340 lfs_dino_setib(fs, dip, lvl, 0x0);
341 bb = howmany(bb, LFS_NINDIR(fs));
342 --bb;
343 factor *= LFS_NINDIR(fs);
344 base -= factor;
345 ++lvl;
346 }
347 }
348 }
349
350 /*
351 * Construct a set of directory entries in "bufp". We assume that all the
352 * entries in protodir fit in the first DIRBLKSIZ.
353 */
354 static void
make_dir(struct lfs * fs,void * bufp,const struct dirproto * protodir,unsigned numentries)355 make_dir(struct lfs *fs, void *bufp,
356 const struct dirproto *protodir, unsigned numentries)
357 {
358 LFS_DIRHEADER *ep;
359 unsigned spaceleft;
360 unsigned namlen, reclen;
361 unsigned i;
362
363 spaceleft = LFS_DIRBLKSIZ;
364 ep = bufp;
365 for (i = 0; i < numentries; i++) {
366 namlen = strlen(protodir[i].dp_name);
367 reclen = LFS_DIRECTSIZ(fs, namlen);
368 if (spaceleft < reclen)
369 fatal("%s: %s", special, "directory too big");
370
371 /* Last entry includes all the free space. */
372 if (i + 1 == numentries) {
373 reclen = spaceleft;
374 }
375 spaceleft -= reclen;
376
377 lfs_dir_setino(fs, ep, protodir[i].dp_ino);
378 lfs_dir_setreclen(fs, ep, reclen);
379 lfs_dir_settype(fs, ep, protodir[i].dp_type);
380 lfs_dir_setnamlen(fs, ep, namlen);
381 lfs_copydirname(fs, lfs_dir_nameptr(fs, ep), protodir[i].dp_name,
382 namlen, reclen);
383 ep = LFS_NEXTDIR(fs, ep);
384 }
385 assert(spaceleft == 0);
386 }
387
388 int
make_lfs(int devfd,uint secsize,struct dkwedge_info * dkw,int minfree,int block_size,int frag_size,int seg_size,int minfreeseg,int resvseg,int version,daddr_t start,int ibsize,int interleave,u_int32_t roll_id,int bitwidth)389 make_lfs(int devfd, uint secsize, struct dkwedge_info *dkw, int minfree,
390 int block_size, int frag_size, int seg_size, int minfreeseg,
391 int resvseg, int version, daddr_t start, int ibsize, int interleave,
392 u_int32_t roll_id, int bitwidth)
393 {
394 union lfs_dinode *dip; /* Pointer to a disk inode */
395 CLEANERINFO *cip; /* Segment cleaner information table */
396 IFILE *ipall; /* Pointer to array of ifile structures */
397 IFILE64 *ip64 = NULL;
398 IFILE32 *ip32 = NULL;
399 IFILE_V1 *ip_v1 = NULL;
400 struct lfs *fs; /* Superblock */
401 SEGUSE *segp; /* Segment usage table */
402 daddr_t sb_addr; /* Address of superblocks */
403 daddr_t seg_addr; /* Address of current segment */
404 int bsize; /* Block size */
405 int fsize; /* Fragment size */
406 int db_per_blk; /* Disk blocks per file block */
407 int i, j;
408 int sb_interval; /* number of segs between super blocks */
409 int ssize; /* Segment size */
410 double fssize;
411 int warned_segtoobig=0;
412 int label_fsb, sb_fsb;
413 int curw, ww;
414 char tbuf[BUFSIZ];
415 struct ubuf *bp;
416 struct uvnode *vp, *save_devvp;
417 daddr_t bb, ubb;
418 int dmeta, labelskew;
419 u_int64_t tsepb, tnseg;
420 time_t stamp;
421 bool is64;
422 bool dobyteswap = false; /* XXX notyet */
423
424 is64 = (bitwidth == 64);
425
426 /*
427 * Initialize buffer cache. Use a ballpark guess of the length of
428 * the segment table for the number of hash chains.
429 */
430 tnseg = dkw->dkw_size / ((seg_size ? seg_size : DFL_LFSSEG) / secsize);
431 tsepb = (block_size ? block_size : DFL_LFSBLOCK) / sizeof(SEGSUM32);
432 if (tnseg == 0)
433 fatal("zero size partition");
434 bufinit(tnseg / tsepb);
435
436 /* Initialize LFS subsystem with blank superblock and ifile. */
437 fs = lfs_init(devfd, start, 0, 1, 1/* XXX debug*/);
438 save_devvp = fs->lfs_devvp;
439 vp = fs->lfs_ivnode;
440 /* XXX this seems like a rubbish */
441 *fs = lfs_default;
442 if (is64) {
443 fs->lfs_dlfs_u.u_64 = dlfs64_default;
444 } else {
445 fs->lfs_dlfs_u.u_32 = dlfs32_default;
446 }
447 fs->lfs_is64 = is64;
448 fs->lfs_dobyteswap = dobyteswap;
449 fs->lfs_hasolddirfmt = false;
450 fs->lfs_ivnode = vp;
451 fs->lfs_devvp = save_devvp;
452
453
454 /* Set version first of all since it is used to compute other fields */
455 lfs_sb_setversion(fs, version);
456
457 /* If partition is not an LFS partition, warn that that is the case */
458 if (strcmp(dkw->dkw_ptype, DKW_PTYPE_LFS) != 0) {
459 fatal("partition label indicated fs type \"%s\", "
460 "expected \"%s\"", dkw->dkw_ptype, DKW_PTYPE_LFS);
461 }
462
463 if (!(bsize = block_size)) {
464 bsize = DFL_LFSBLOCK;
465 if (dkw->dkw_size <= SMALL_FSSIZE)
466 bsize = SMALL_LFSBLOCK;
467 }
468 if (!(fsize = frag_size)) {
469 fsize = DFL_LFSFRAG;
470 if (dkw->dkw_size <= SMALL_FSSIZE)
471 fsize = SMALL_LFSFRAG;
472 }
473 if (!(ssize = seg_size)) {
474 ssize = DFL_LFSSEG;
475 if (dkw->dkw_size <= SMALL_FSSIZE)
476 ssize = SMALL_LFSSEG;
477 }
478 if (version > 1) {
479 if (ibsize == 0)
480 ibsize = fsize;
481 if (ibsize <= 0 || ibsize % fsize)
482 fatal("illegal inode block size: %d\n", ibsize);
483 } else if (ibsize && ibsize != bsize)
484 fatal("cannot specify inode block size when version == 1\n");
485
486 /* Sanity check: fsize<=bsize<ssize */
487 if (fsize > bsize) {
488 /* Only complain if fsize was explicitly set */
489 if(frag_size)
490 fatal("fragment size must be <= block size %d", bsize);
491 fsize = bsize;
492 }
493 if (bsize >= ssize) {
494 /* Only fatal if ssize was explicitly set */
495 if(seg_size)
496 fatal("block size must be < segment size");
497 warnx("%s: disklabel segment size (%d) too small, using default (%d)",
498 progname, ssize, DFL_LFSSEG);
499 ssize = DFL_LFSSEG;
500 }
501 if (start < 0 || start >= dkw->dkw_size)
502 fatal("filesystem offset %ld out of range", (long)start);
503 if (version == 1) {
504 if (start)
505 warnx("filesystem offset ignored for version 1 filesystem");
506 start = LFS_LABELPAD / secsize;
507 }
508
509 tryagain:
510 /* Modify parts of superblock overridden by command line arguments */
511 if (bsize != DFL_LFSBLOCK || fsize != DFL_LFSFRAG) {
512 lfs_sb_setbshift(fs, lfs_log2(bsize));
513 if (1 << lfs_sb_getbshift(fs) != bsize)
514 fatal("%d: block size not a power of 2", bsize);
515 lfs_sb_setbsize(fs, bsize);
516 lfs_sb_setfsize(fs, fsize);
517 lfs_sb_setbmask(fs, bsize - 1);
518 lfs_sb_setffmask(fs, fsize - 1);
519 lfs_sb_setffshift(fs, lfs_log2(fsize));
520 if (1 << lfs_sb_getffshift(fs) != fsize)
521 fatal("%d: frag size not a power of 2", fsize);
522 lfs_sb_setfrag(fs, lfs_numfrags(fs, bsize));
523 lfs_sb_setfbmask(fs, lfs_sb_getfrag(fs) - 1);
524 lfs_sb_setfbshift(fs, lfs_log2(lfs_sb_getfrag(fs)));
525 lfs_sb_setifpb(fs, bsize / IFILE_ENTRYSIZE(fs));
526 lfs_sb_setnindir(fs, bsize / LFS_BLKPTRSIZE(fs));
527 }
528
529 if (lfs_sb_getversion(fs) == 1) {
530 lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);
531 if (!is64) {
532 unsigned segshift;
533
534 segshift = lfs_log2(ssize);
535 if (1 << segshift != ssize)
536 fatal("%d: segment size not power of 2",
537 ssize);
538 fs->lfs_dlfs_u.u_32.dlfs_segshift = segshift;
539 fs->lfs_dlfs_u.u_32.dlfs_segmask = ssize - 1;
540 }
541 lfs_sb_setifpb(fs, lfs_sb_getbsize(fs) / sizeof(IFILE_V1));
542 lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));
543 lfs_sb_setsepb(fs, bsize / sizeof(SEGUSE_V1));
544 lfs_sb_setssize(fs, ssize >> lfs_sb_getbshift(fs));
545 } else {
546 if (ssize % fsize) {
547 fprintf(stderr,
548 "Segment size %d is not a multiple of frag size; ",
549 ssize);
550 ssize = roundup(ssize, fsize);
551 fprintf(stderr, "trying size %d.\n", ssize);
552 goto tryagain;
553 }
554 lfs_sb_setsumsize(fs, fsize);
555 if (!is64) {
556 /* these do not exist in the 64-bit superblock */
557 fs->lfs_dlfs_u.u_32.dlfs_segshift = 0;
558 fs->lfs_dlfs_u.u_32.dlfs_segmask = 0;
559 }
560 lfs_sb_setsepb(fs, bsize / sizeof(SEGUSE));
561 lfs_sb_setssize(fs, ssize);
562 lfs_sb_setibsize(fs, ibsize);
563 }
564 lfs_sb_setinopb(fs, lfs_sb_getibsize(fs) / DINOSIZE(fs));
565 lfs_sb_setminfree(fs, minfree);
566
567 if (version > 1) {
568 lfs_sb_setinopf(fs, secsize/DINOSIZE(fs));
569 lfs_sb_setinterleave(fs, interleave);
570 if (roll_id == 0)
571 roll_id = arc4random();
572 lfs_sb_setident(fs, roll_id);
573 }
574
575 /*
576 * Fill in parts of superblock that can be computed from file system
577 * size, disk geometry and current time.
578 *
579 * XXX: this seems to set dlfs_size wrong for version 1... as in,
580 * sets it and then overwrites it a few lines later.
581 */
582 db_per_blk = bsize/secsize;
583 lfs_sb_setblktodb(fs, lfs_log2(db_per_blk));
584 lfs_sb_setfsbtodb(fs, lfs_log2(fsize / secsize));
585 if (version == 1) {
586 lfs_sb_setsushift(fs, lfs_log2(lfs_sb_getsepb(fs)));
587 lfs_sb_setfsbtodb(fs, 0);
588 lfs_sb_setsize(fs, dkw->dkw_size >> lfs_sb_getblktodb(fs));
589 }
590 label_fsb = lfs_btofsb(fs, roundup(LFS_LABELPAD, fsize));
591 sb_fsb = lfs_btofsb(fs, roundup(LFS_SBPAD, fsize));
592 lfs_sb_setfsbpseg(fs, LFS_DBTOFSB(fs, ssize / secsize));
593 lfs_sb_setsize(fs, dkw->dkw_size >> lfs_sb_getfsbtodb(fs));
594 lfs_sb_setdsize(fs, LFS_DBTOFSB(fs, dkw->dkw_size) -
595 MAX(label_fsb, LFS_DBTOFSB(fs, start)));
596 lfs_sb_setnseg(fs, lfs_sb_getdsize(fs) / lfs_segtod(fs, 1));
597
598 lfs_sb_setnclean(fs, lfs_sb_getnseg(fs) - 1);
599 lfs_sb_setmaxfilesize(fs, maxfilesize(fs, lfs_sb_getbshift(fs)));
600
601 if (minfreeseg == 0)
602 lfs_sb_setminfreeseg(fs, lfs_sb_getnseg(fs) / DFL_MIN_FREE_SEGS);
603 else
604 lfs_sb_setminfreeseg(fs, minfreeseg);
605 if (lfs_sb_getminfreeseg(fs) < MIN_FREE_SEGS)
606 lfs_sb_setminfreeseg(fs, MIN_FREE_SEGS);
607
608 if (resvseg == 0)
609 lfs_sb_setresvseg(fs, lfs_sb_getminfreeseg(fs) / 2 + 1);
610 else
611 lfs_sb_setresvseg(fs, resvseg);
612 if (lfs_sb_getresvseg(fs) < MIN_RESV_SEGS)
613 lfs_sb_setresvseg(fs, MIN_RESV_SEGS);
614
615 if(lfs_sb_getnseg(fs) < (4 * lfs_sb_getminfreeseg(fs))
616 || lfs_sb_getnseg(fs) < LFS_MIN_SBINTERVAL + 1)
617 {
618 if(seg_size == 0 && ssize > (bsize<<1)) {
619 if(!warned_segtoobig) {
620 fprintf(stderr,"Segment size %d is too large; "
621 "trying smaller sizes.\n", ssize);
622 if (ssize == (bsize << 16)) {
623 fprintf(stderr, "(Did you perhaps "
624 "accidentally leave \"16\" "
625 "in the disklabel's sgs "
626 "field?)\n");
627 }
628 }
629 ++warned_segtoobig;
630 ssize >>= 1;
631 goto tryagain;
632 }
633 fatal("Could not allocate enough segments with segment "
634 "size %d and block size %d;\nplease decrease the "
635 "segment size.\n", ssize, lfs_sb_getbsize(fs));
636 }
637 if(warned_segtoobig)
638 fprintf(stderr,"Using segment size %d, block size %d, frag size %d.\n", ssize, bsize, fsize);
639
640 /*
641 * Now that we've determined what we're going to do, announce it
642 * to the user.
643 */
644 printf("Creating a version %d LFS%d", lfs_sb_getversion(fs), bitwidth);
645 if (lfs_sb_getversion(fs) > 1)
646 printf(" with roll-forward ident 0x%x", lfs_sb_getident(fs));
647 printf("\n");
648 if (bitwidth == 64) {
649 printf("WARNING: The LFS64 on-disk format is not final.\n");
650 printf("WARNING: 64-bit volumes should be used only for "
651 "testing.\n");
652 }
653 fssize = (double)lfs_sb_getnseg(fs);
654 fssize *= (double)ssize;
655 fssize /= 1048576.0;
656 printf("%.1fMB in %d segments of size %d\n", fssize,
657 lfs_sb_getnseg(fs), ssize);
658
659 /*
660 * The number of free blocks is set from the number of segments
661 * times the segment size - lfs_minfreesegs (that we never write
662 * because we need to make sure the cleaner can run). Then
663 * we'll subtract off the room for the superblocks ifile entries
664 * and segment usage table, and half a block per segment that can't
665 * be written due to fragmentation.
666 */
667 lfs_sb_setdsize(fs,
668 lfs_segtod(fs, lfs_sb_getnseg(fs) - lfs_sb_getminfreeseg(fs)));
669 lfs_sb_setbfree(fs, lfs_sb_getdsize(fs));
670 lfs_sb_subbfree(fs, LFS_DBTOFSB(fs, ((lfs_sb_getnseg(fs) / 2) <<
671 lfs_sb_getblktodb(fs))));
672
673 lfs_sb_setsegtabsz(fs, SEGTABSIZE_SU(fs));
674 lfs_sb_setcleansz(fs, CLEANSIZE_SU(fs));
675 if (time(&stamp) == -1)
676 fatal("time: %s", strerror(errno));
677 lfs_sb_settstamp(fs, stamp);
678 if (version == 1)
679 lfs_sb_setotstamp(fs, stamp);
680
681 if ((sb_interval = lfs_sb_getnseg(fs) / LFS_MAXNUMSB) < LFS_MIN_SBINTERVAL)
682 sb_interval = LFS_MIN_SBINTERVAL;
683
684 /*
685 * Figure out where the superblocks are going to live.
686 *
687 * Make segment 0 start at either zero, or LFS_LABELPAD, or
688 * >= LFS_SBPAD+LFS_LABELPAD, in order to prevent segment 0
689 * from having half a superblock in it.
690 */
691 if (LFS_FSBTODB(fs, LFS_DBTOFSB(fs, start)) != start)
692 fatal("Segment 0 offset is not multiple of frag size\n");
693 if (start != 0 && dbtob(start) != LFS_LABELPAD &&
694 dbtob(start) < LFS_SBPAD + LFS_LABELPAD) {
695 fatal("Using flags \"-O %" PRId64 "\" would result in the "
696 "first segment containing only\npart of a superblock. "
697 "Please choose an offset of 0, %d, or %d or more,\n",
698 start, btodb(LFS_LABELPAD),
699 btodb(LFS_LABELPAD + LFS_SBPAD));
700 }
701 lfs_sb_setsboff(fs, 0, label_fsb);
702 if (version == 1)
703 lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));
704 else
705 lfs_sb_sets0addr(fs, LFS_DBTOFSB(fs, start));
706 lfs_sb_subdsize(fs, sb_fsb);
707 for (i = 1; i < LFS_MAXNUMSB; i++) {
708 sb_addr = ((i * sb_interval) * lfs_segtod(fs, 1))
709 + lfs_sb_getsboff(fs, 0);
710 /* Segment 0 eats the label, except for version 1 */
711 if (lfs_sb_getversion(fs) > 1 && lfs_sb_gets0addr(fs) < label_fsb)
712 sb_addr -= label_fsb - start;
713 if (sb_addr + sizeof(struct dlfs)
714 >= LFS_DBTOFSB(fs, dkw->dkw_size))
715 break;
716 lfs_sb_setsboff(fs, i, sb_addr);
717 lfs_sb_subdsize(fs, sb_fsb);
718 }
719
720 /* We need >= 2 superblocks */
721 if (lfs_sb_getsboff(fs, 1) == 0x0) {
722 fatal("Could not assign a disk address for the second "
723 "superblock.\nPlease decrease the segment size.\n");
724 }
725
726 lfs_sb_setlastseg(fs, lfs_sntod(fs, lfs_sb_getnseg(fs) - 2));
727 lfs_sb_setcurseg(fs, lfs_sntod(fs, lfs_sb_getnseg(fs) - 1));
728 lfs_sb_setoffset(fs, lfs_sntod(fs, lfs_sb_getnseg(fs)));
729 lfs_sb_setnextseg(fs, lfs_sntod(fs, 0));
730
731 /*
732 * Initialize the Ifile inode. Do this before we do anything
733 * with the Ifile or segment tables.
734 *
735 * XXX: is there some reason this allocates a new dinode? we
736 * already have an empty one generated by vget.
737 */
738 dip = malloc(sizeof(*dip));
739 if (dip == NULL)
740 err(1, NULL);
741 memset(dip, 0, sizeof(*dip));
742
743 VTOI(fs->lfs_ivnode)->i_din = dip;
744
745 lfs_dino_setmode(fs, dip, LFS_IFREG | 0600);
746 lfs_dino_setflags(fs, dip, SF_IMMUTABLE);
747 make_dinode(LFS_IFILE_INUM, dip,
748 lfs_blkstofrags(fs, lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs) + 1), fs);
749 lfs_dino_setsize(fs, dip, (lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs) + 1) << lfs_sb_getbshift(fs));
750 for (i = 0; i < ULFS_NDADDR && i < (lfs_dino_getsize(fs, dip) >> lfs_sb_getbshift(fs)); i++)
751 VTOI(fs->lfs_ivnode)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);
752
753 /*
754 * Set up in-superblock segment usage cache
755 */
756 fs->lfs_suflags = (u_int32_t **) malloc(2 * sizeof(u_int32_t *));
757 if (fs->lfs_suflags == NULL)
758 err(1, NULL);
759 fs->lfs_suflags[0] = (u_int32_t *) malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
760 if (fs->lfs_suflags[0] == NULL)
761 err(1, NULL);
762 fs->lfs_suflags[1] = (u_int32_t *) malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
763 if (fs->lfs_suflags[1] == NULL)
764 err(1, NULL);
765
766 /*
767 * Initialize the cleanerinfo block
768 */
769 LFS_CLEANERINFO(cip, fs, bp);
770 lfs_ci_setclean(fs, cip, lfs_sb_getnseg(fs));
771 lfs_ci_setdirty(fs, cip, 0);
772 if (version > 1) {
773 lfs_ci_setfree_head(fs, cip, HIGHEST_USED_INO + 1);
774 lfs_ci_setfree_tail(fs, cip, lfs_sb_getifpb(fs) - 1);
775 }
776 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
777
778 /*
779 * Run through segment table and initialize that
780 */
781 for (i = j = 0; i < lfs_sb_getnseg(fs); i++) {
782 LFS_SEGENTRY(segp, fs, i, bp);
783
784 if (i == 0 &&
785 lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD + LFS_SBPAD)) {
786 segp->su_flags = SEGUSE_SUPERBLOCK;
787 lfs_sb_subbfree(fs, sb_fsb);
788 ++j;
789 }
790 if (i > 0) {
791 if ((i % sb_interval) == 0 && j < LFS_MAXNUMSB) {
792 segp->su_flags = SEGUSE_SUPERBLOCK;
793 lfs_sb_subbfree(fs, sb_fsb);
794 ++j;
795 } else
796 segp->su_flags = 0;
797 }
798 segp->su_lastmod = 0;
799 segp->su_nbytes = 0;
800 segp->su_ninos = 0;
801 segp->su_nsums = 0;
802
803 LFS_WRITESEGENTRY(segp, fs, i, bp);
804 }
805
806 /* Initialize root directory */
807 vp = lfs_raw_vget(fs, ULFS_ROOTINO, devfd, 0x0);
808 dip = VTOI(vp)->i_din;
809 make_dinode(ULFS_ROOTINO, dip, howmany(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs)), fs);
810 lfs_dino_setmode(fs, dip, LFS_IFDIR | UMASK);
811 VTOI(vp)->i_lfs_osize = LFS_DIRBLKSIZ;
812 #ifdef MAKE_LF_DIR
813 VTOI(vp)->i_nlink = 3;
814 #else
815 VTOI(vp)->i_nlink = 2;
816 #endif
817 VTOI(vp)->i_lfs_effnblks =
818 lfs_btofsb(fs, roundup(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs)));
819 lfs_dino_setsize(fs, dip, VTOI(vp)->i_lfs_osize);
820 lfs_dino_setnlink(fs, dip, VTOI(vp)->i_nlink);
821 lfs_dino_setblocks(fs, dip, VTOI(vp)->i_lfs_effnblks);
822 for (i = 0; i < ULFS_NDADDR && i < howmany(LFS_DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)
823 VTOI(vp)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);
824 if (LFS_DIRBLKSIZ < lfs_sb_getbsize(fs))
825 VTOI(vp)->i_lfs_fragsize[i - 1] =
826 roundup(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs));
827 bread(vp, 0, lfs_sb_getfsize(fs), 0, &bp);
828 make_dir(fs, bp->b_data, lfs_root_dir, __arraycount(lfs_root_dir));
829 VOP_BWRITE(bp);
830
831 #ifdef MAKE_LF_DIR
832 /* Initialize lost+found directory */
833 vp = lfs_raw_vget(fs, LOSTFOUNDINO, devfd, 0x0);
834 dip = VTOI(vp)->i_din.ffs1_din;
835 make_dinode(LOSTFOUNDINO, dip, howmany(DIRBLKSIZ,fs->lfs_fsize), fs);
836 dip->di_mode = IFDIR | UMASK;
837 VTOI(vp)->i_lfs_osize = dip->di_size = DIRBLKSIZ;
838 VTOI(vp)->i_nlink = dip->di_nlink = 2;
839 VTOI(vp)->i_lfs_effnblks = dip->di_blocks =
840 lfs_btofsb(fs, roundup(DIRBLKSIZ,fs->lfs_fsize));
841 for (i = 0; i < ULFS_NDADDR && i < howmany(DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)
842 VTOI(vp)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);
843 if (DIRBLKSIZ < lfs_sb_getbsize(fs))
844 VTOI(vp)->i_lfs_fragsize[i - 1] =
845 roundup(DIRBLKSIZ,fs->lfs_fsize);
846 bread(vp, 0, fs->lfs_fsize, 0, &bp);
847 make_dir(fs, bp->b_data, lfs_lf_dir, __arraycount(lfs_lf_dir));
848 VOP_BWRITE(bp);
849 #endif /* MAKE_LF_DIR */
850
851 /* Set their IFILE entry version numbers to 1 */
852 LFS_IENTRY(ipall, fs, 1, bp);
853 if (is64) {
854 ip64 = &ipall->u_64;
855 for (i = LFS_IFILE_INUM; i <= HIGHEST_USED_INO; i++) {
856 ip64->if_version = 1;
857 ip64->if_daddr = 0x0;
858 ip64->if_nextfree = 0;
859 ++ip64;
860 }
861 } else if (version > 1) {
862 ip32 = &ipall->u_32;
863 for (i = LFS_IFILE_INUM; i <= HIGHEST_USED_INO; i++) {
864 ip32->if_version = 1;
865 ip32->if_daddr = 0x0;
866 ip32->if_nextfree = 0;
867 ++ip32;
868 }
869 } else {
870 ip_v1 = &ipall->u_v1;
871 for (i = LFS_IFILE_INUM; i <= HIGHEST_USED_INO; i++) {
872 ip_v1->if_version = 1;
873 ip_v1->if_daddr = 0x0;
874 ip_v1->if_nextfree = 0;
875 ++ip_v1;
876 }
877 }
878 /* Link remaining IFILE entries in free list */
879 if (is64) {
880 for (;
881 i < lfs_sb_getifpb(fs); ++ip64) {
882 ip64->if_version = 1;
883 ip64->if_daddr = LFS_UNUSED_DADDR;
884 ip64->if_nextfree = ++i;
885 }
886 --ip64;
887 ip64->if_nextfree = LFS_UNUSED_INUM;
888 } else if (version > 1) {
889 for (;
890 i < lfs_sb_getifpb(fs); ++ip32) {
891 ip32->if_version = 1;
892 ip32->if_daddr = LFS_UNUSED_DADDR;
893 ip32->if_nextfree = ++i;
894 }
895 --ip32;
896 ip32->if_nextfree = LFS_UNUSED_INUM;
897 } else {
898 for (;
899 i < lfs_sb_getifpb(fs); ++ip_v1) {
900 ip_v1->if_version = 1;
901 ip_v1->if_daddr = LFS_UNUSED_DADDR;
902 ip_v1->if_nextfree = ++i;
903 }
904 --ip_v1;
905 ip_v1->if_nextfree = LFS_UNUSED_INUM;
906 }
907 VOP_BWRITE(bp);
908
909 /* Write it all to disk. */
910 if (!Nflag)
911 lfs_segwrite(fs, SEGM_CKP);
912
913 /*
914 * Now that we've written everything, look to see what's available
915 * for writing.
916 */
917 lfs_sb_setavail(fs, 0);
918 bb = ubb = dmeta = 0;
919 for (i = 0; i < lfs_sb_getnseg(fs); i++) {
920 LFS_SEGENTRY(segp, fs, i, bp);
921 if (segp->su_flags & SEGUSE_DIRTY) {
922 bb += lfs_btofsb(fs, segp->su_nbytes +
923 segp->su_nsums * lfs_sb_getsumsize(fs));
924 ubb += lfs_btofsb(fs, segp->su_nbytes +
925 segp->su_nsums * lfs_sb_getsumsize(fs) +
926 segp->su_ninos * lfs_sb_getibsize(fs));
927 dmeta += lfs_btofsb(fs,
928 lfs_sb_getsumsize(fs) * segp->su_nsums);
929 dmeta += lfs_btofsb(fs,
930 lfs_sb_getibsize(fs) * segp->su_ninos);
931 } else {
932 lfs_sb_addavail(fs, lfs_segtod(fs, 1));
933 if (segp->su_flags & SEGUSE_SUPERBLOCK)
934 lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_SBPAD));
935 if (i == 0 && lfs_sb_getversion(fs) > 1 &&
936 lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))
937 lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) -
938 lfs_sb_gets0addr(fs));
939 }
940 brelse(bp, 0);
941 }
942 /* Also may be available bytes in current seg */
943 i = lfs_dtosn(fs, lfs_sb_getoffset(fs));
944 lfs_sb_addavail(fs, lfs_sntod(fs, i + 1) - lfs_sb_getoffset(fs));
945 /* But do not count minfreesegs */
946 lfs_sb_subavail(fs, lfs_segtod(fs, (lfs_sb_getminfreeseg(fs) - (lfs_sb_getminfreeseg(fs) / 2))));
947
948 labelskew = 0;
949 if (lfs_sb_getversion(fs) > 1 && lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))
950 labelskew = lfs_btofsb(fs, LFS_LABELPAD);
951 lfs_sb_setbfree(fs, lfs_sb_getdsize(fs) - labelskew - (ubb + bb) / 2);
952
953 /* Put that in the Ifile version too, and write it */
954 LFS_CLEANERINFO(cip, fs, bp);
955 lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs));
956 lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs));
957 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
958 if (!Nflag)
959 lfs_segwrite(fs, SEGM_CKP);
960
961 /*
962 * Finally write out superblocks.
963 */
964 printf("super-block backups (for fsck -b #) at:\n");
965 curw = 0;
966 for (i = 0; i < LFS_MAXNUMSB; i++) {
967 seg_addr = lfs_sb_getsboff(fs, i);
968 if (seg_addr == 0)
969 break;
970
971 if (i != 0)
972 curw += printf(", ");
973 ww = snprintf(tbuf, sizeof(tbuf), "%lld",
974 (long long)LFS_FSBTODB(fs, seg_addr));
975 curw += ww;
976 if (curw >= 78) {
977 printf("\n%s", tbuf);
978 curw = ww;
979 } else
980 printf("%s", tbuf);
981 fflush(stdout);
982
983 /* Leave the time stamp on the alt sb, zero the rest */
984 if (i == 2) {
985 lfs_sb_settstamp(fs, 0);
986 lfs_sb_setcksum(fs, lfs_sb_cksum(fs));
987 }
988 if (!Nflag)
989 lfs_writesuper(fs, seg_addr);
990 }
991 printf(".\n");
992
993 return 0;
994 }
995
996 /*
997 * Compatibility with fsck_lfs, since the "generic" LFS userland code uses it.
998 */
999 void
pwarn(const char * fmt,...)1000 pwarn(const char *fmt, ...)
1001 {
1002 va_list ap;
1003
1004 va_start(ap, fmt);
1005 vfprintf(stderr, fmt, ap);
1006 va_end(ap);
1007 }
1008