From d038e02fd667ab6c02875840105798aaa7029504 Mon Sep 17 00:00:00 2001 From: rgrimes Date: Thu, 26 May 1994 06:35:07 +0000 Subject: BSD 4.4 Lite sbin Sources Note: XNSrouted and routed NOT imported here, they shall be imported with usr.sbin. --- sbin/newlfs/Makefile | 9 + sbin/newlfs/config.h | 134 ++++++++++ sbin/newlfs/extern.h | 45 ++++ sbin/newlfs/lfs.c | 673 +++++++++++++++++++++++++++++++++++++++++++++++++++ sbin/newlfs/misc.c | 83 +++++++ sbin/newlfs/newfs.c | 466 +++++++++++++++++++++++++++++++++++ sbin/newlfs/newlfs.8 | 95 ++++++++ 7 files changed, 1505 insertions(+) create mode 100644 sbin/newlfs/Makefile create mode 100644 sbin/newlfs/config.h create mode 100644 sbin/newlfs/extern.h create mode 100644 sbin/newlfs/lfs.c create mode 100644 sbin/newlfs/misc.c create mode 100644 sbin/newlfs/newfs.c create mode 100644 sbin/newlfs/newlfs.8 (limited to 'sbin/newlfs') diff --git a/sbin/newlfs/Makefile b/sbin/newlfs/Makefile new file mode 100644 index 0000000..c79c83e --- /dev/null +++ b/sbin/newlfs/Makefile @@ -0,0 +1,9 @@ +# @(#)Makefile 8.1 (Berkeley) 6/18/93 + +PROG= newlfs +CFLAGS+=-I/sys/ufs/lfs +SRCS= dkcksum.c lfs.c lfs_cksum.c misc.c newfs.c +MAN8= newlfs.0 +.PATH: /sys/ufs/lfs ${.CURDIR}/../disklabel + +.include diff --git a/sbin/newlfs/config.h b/sbin/newlfs/config.h new file mode 100644 index 0000000..9c8b394 --- /dev/null +++ b/sbin/newlfs/config.h @@ -0,0 +1,134 @@ +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)config.h 8.2 (Berkeley) 4/22/94 + */ + +/* + * The first boot and super blocks are given in absolute disk addresses. + * The byte-offset forms are preferred, as they don't imply a sector size. + */ +#define BBSIZE 8192 +#define SBSIZE 8192 + +/* + * The following two constants set the default block and fragment sizes. + * Both constants must be a power of 2 and meet the following constraints: + * MINBSIZE <= DESBLKSIZE <= MAXBSIZE + * sectorsize <= DESFRAGSIZE <= DESBLKSIZE + * DESBLKSIZE / DESFRAGSIZE <= 8 + */ +#define DFL_FRAGSIZE 1024 +#define DFL_BLKSIZE 8192 + +/* + * Cylinder groups may have up to many cylinders. The actual + * number used depends upon how much information can be stored + * on a single cylinder. The default is to use 16 cylinders + * per group. + */ +#define DESCPG 16 /* desired fs_cpg */ + +/* + * MINFREE gives the minimum acceptable percentage of file system + * blocks which may be free. If the freelist drops below this level + * only the superuser may continue to allocate blocks. This may + * be set to 0 if no reserve of free blocks is deemed necessary, + * however throughput drops by fifty percent if the file system + * is run at between 90% and 100% full; thus the default value of + * fs_minfree is 10%. With 10% free space, fragmentation is not a + * problem, so we choose to optimize for time. + */ +#define MINFREE 10 +#define DEFAULTOPT FS_OPTTIME + +/* + * Preference for optimization. + */ +#define FS_OPTTIME 0 /* minimize allocation time */ +#define FS_OPTSPACE 1 /* minimize disk fragmentation */ + + +/* + * ROTDELAY gives the minimum number of milliseconds to initiate + * another disk transfer on the same cylinder. It is used in + * determining the rotationally optimal layout for disk blocks + * within a file; the default of fs_rotdelay is 4ms. + */ +#define ROTDELAY 4 + +/* + * MAXCONTIG sets the default for the maximum number of blocks + * that may be allocated sequentially. Since UNIX drivers are + * not capable of scheduling multi-block transfers, this defaults + * to 1 (ie no contiguous blocks are allocated). + */ +#define MAXCONTIG 1 + +/* + * MAXBLKPG determines the maximum number of data blocks which are + * placed in a single cylinder group. The default is one indirect + * block worth of data blocks. + */ +#define MAXBLKPG(bsize) ((bsize) / sizeof(daddr_t)) + +/* + * Each file system has a number of inodes statically allocated. + * We allocate one inode slot per NFPI fragments, expecting this + * to be far more than we will ever need. + */ +#define NFPI 4 + +/* + * For each cylinder we keep track of the availability of blocks at different + * rotational positions, so that we can lay out the data to be picked + * up with minimum rotational latency. NRPOS is the default number of + * rotational positions that we distinguish. With NRPOS of 8 the resolution + * of our summary information is 2ms for a typical 3600 rpm drive. + */ +#define NRPOS 8 /* number distinct rotational positions */ + +/* + * The following constants set the default block and segment size for a log + * structured file system. Both must be powers of two and the segment size + * must be a multiple of the block size. We also set minimum block and segment + * sizes. + */ +#define LFS_MINSEGSIZE (64*1024) +#define DFL_LFSSEG (1024 * 1024) +#define DFL_LFSSEG_SHIFT 20 +#define DFL_LFSSEG_MASK 0xFFFFF + +#define LFS_MINBLOCKSIZE 1024 +#define DFL_LFSBLOCK 4096 +#define DFL_LFSBLOCK_SHIFT 12 +#define DFL_LFSBLOCK_MASK 0xFFF diff --git a/sbin/newlfs/extern.h b/sbin/newlfs/extern.h new file mode 100644 index 0000000..c65cdba --- /dev/null +++ b/sbin/newlfs/extern.h @@ -0,0 +1,45 @@ +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)extern.h 8.1 (Berkeley) 6/5/93 + */ + +u_long cksum __P((void *, size_t)); +u_short dkcksum __P((struct disklabel *)); +void fatal __P((const char *fmt, ...)); +u_int log2 __P((u_int)); +int make_lfs + __P((int, struct disklabel *, struct partition *, int, int, int)); +int mkfs __P((struct partition *, char *, int, int)); + +extern char *progname; +extern char *special; diff --git a/sbin/newlfs/lfs.c b/sbin/newlfs/lfs.c new file mode 100644 index 0000000..c79a0dc --- /dev/null +++ b/sbin/newlfs/lfs.c @@ -0,0 +1,673 @@ +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char sccsid[] = "@(#)lfs.c 8.1 (Berkeley) 6/5/93"; +#endif /* not lint */ + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include "config.h" +#include "extern.h" + +/* + * This table is indexed by the log base 2 of the block size. + * It returns the maximum file size allowed in a file system + * with the specified block size. For block sizes smaller than + * 8K, the size is limited by tha maximum number of blocks that + * can be reached by triply indirect blocks: + * NDADDR + INOPB(bsize) + INOPB(bsize)^2 + INOPB(bsize)^3 + * For block size of 8K or larger, the file size is limited by the + * number of blocks that can be represented in the file system. Since + * we use negative block numbers to represent indirect blocks, we can + * have a maximum of 2^31 blocks. + */ + +u_quad_t maxtable[] = { + /* 1 */ -1, + /* 2 */ -1, + /* 4 */ -1, + /* 8 */ -1, + /* 16 */ -1, + /* 32 */ -1, + /* 64 */ -1, + /* 128 */ -1, + /* 256 */ -1, + /* 512 */ NDADDR + 128 + 128 * 128 + 128 * 128 * 128, + /* 1024 */ NDADDR + 256 + 256 * 256 + 256 * 256 * 256, + /* 2048 */ NDADDR + 512 + 512 * 512 + 512 * 512 * 512, + /* 4096 */ NDADDR + 1024 + 1024 * 1024 + 1024 * 1024 * 1024, + /* 8192 */ 1 << 31, + /* 16 K */ 1 << 31, + /* 32 K */ 1 << 31, +}; + +static struct lfs lfs_default = { + /* lfs_magic */ LFS_MAGIC, + /* lfs_version */ LFS_VERSION, + /* lfs_size */ 0, + /* lfs_ssize */ DFL_LFSSEG/DFL_LFSBLOCK, + /* lfs_dsize */ 0, + /* lfs_bsize */ DFL_LFSBLOCK, + /* lfs_fsize */ DFL_LFSBLOCK, + /* lfs_frag */ 1, + /* lfs_free */ LFS_FIRST_INUM, + /* lfs_bfree */ 0, + /* lfs_nfiles */ 0, + /* lfs_avail */ 0, + /* lfs_uinodes */ 0, + /* lfs_idaddr */ 0, + /* lfs_ifile */ LFS_IFILE_INUM, + /* lfs_lastseg */ 0, + /* lfs_nextseg */ 0, + /* lfs_curseg */ 0, + /* lfs_offset */ 0, + /* lfs_lastpseg */ 0, + /* lfs_tstamp */ 0, + /* lfs_minfree */ MINFREE, + /* lfs_maxfilesize */ 0, + /* lfs_dbpseg */ DFL_LFSSEG/DEV_BSIZE, + /* lfs_inopb */ DFL_LFSBLOCK/sizeof(struct dinode), + /* lfs_ifpb */ DFL_LFSBLOCK/sizeof(IFILE), + /* lfs_sepb */ DFL_LFSBLOCK/sizeof(SEGUSE), + /* lfs_nindir */ DFL_LFSBLOCK/sizeof(daddr_t), + /* lfs_nseg */ 0, + /* lfs_nspf */ 0, + /* lfs_cleansz */ 0, + /* lfs_segtabsz */ 0, + /* lfs_segmask */ DFL_LFSSEG_MASK, + /* lfs_segshift */ DFL_LFSSEG_SHIFT, + /* lfs_bmask */ DFL_LFSBLOCK_MASK, + /* lfs_bshift */ DFL_LFSBLOCK_SHIFT, + /* lfs_ffmask */ 0, + /* lfs_ffshift */ 0, + /* lfs_fbmask */ 0, + /* lfs_fbshift */ 0, + /* lfs_fsbtodb */ 0, + /* lfs_sushift */ 0, + /* lfs_sboffs */ { 0 }, + /* lfs_sp */ NULL, + /* lfs_ivnode */ NULL, + /* lfs_seglock */ 0, + /* lfs_lockpid */ 0, + /* lfs_iocount */ 0, + /* lfs_writer */ 0, + /* lfs_dirops */ 0, + /* lfs_doifile */ 0, + /* lfs_nactive */ 0, + /* lfs_fmod */ 0, + /* lfs_clean */ 0, + /* lfs_ronly */ 0, + /* lfs_flags */ 0, + /* lfs_fsmnt */ { 0 }, + /* lfs_pad */ { 0 }, + /* lfs_cksum */ 0 +}; + + +struct direct lfs_root_dir[] = { + { ROOTINO, sizeof(struct direct), DT_DIR, 1, "."}, + { ROOTINO, sizeof(struct direct), DT_DIR, 2, ".."}, + { LFS_IFILE_INUM, sizeof(struct direct), DT_REG, 5, "ifile"}, + { LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 10, "lost+found"}, +}; + +struct direct lfs_lf_dir[] = { + { LOSTFOUNDINO, sizeof(struct direct), DT_DIR, 1, "." }, + { ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." }, +}; + +static daddr_t make_dinode + __P((ino_t, struct dinode *, int, daddr_t, struct lfs *)); +static void make_dir __P(( void *, struct direct *, int)); +static void put __P((int, off_t, void *, size_t)); + +int +make_lfs(fd, lp, partp, minfree, block_size, seg_size) + int fd; + struct disklabel *lp; + struct partition *partp; + int minfree; + int block_size; + int seg_size; +{ + struct dinode *dip; /* Pointer to a disk inode */ + struct dinode *dpagep; /* Pointer to page of disk inodes */ + CLEANERINFO *cleaninfo; /* Segment cleaner information table */ + FINFO file_info; /* File info structure in summary blocks */ + IFILE *ifile; /* Pointer to array of ifile structures */ + IFILE *ip; /* Pointer to array of ifile structures */ + struct lfs *lfsp; /* Superblock */ + SEGUSE *segp; /* Segment usage table */ + SEGUSE *segtable; /* Segment usage table */ + SEGSUM summary; /* Segment summary structure */ + SEGSUM *sp; /* Segment summary pointer */ + daddr_t last_sb_addr; /* Address of superblocks */ + daddr_t last_addr; /* Previous segment address */ + daddr_t sb_addr; /* Address of superblocks */ + daddr_t seg_addr; /* Address of current segment */ + void *ipagep; /* Pointer to the page we use to write stuff */ + void *sump; /* Used to copy stuff into segment buffer */ + u_long *block_array; /* Array of logical block nos to put in sum */ + u_long blocks_used; /* Number of blocks in first segment */ + u_long *dp; /* Used to computed checksum on data */ + u_long *datasump; /* Used to computed checksum on data */ + int block_array_size; /* How many entries in block array */ + int bsize; /* Block size */ + int db_per_fb; /* Disk blocks per file block */ + int i, j; + int off; /* Offset at which to write */ + int sb_interval; /* number of segs between super blocks */ + int seg_seek; /* Seek offset for a segment */ + int ssize; /* Segment size */ + int sum_size; /* Size of the summary block */ + + lfsp = &lfs_default; + + if (!(bsize = block_size)) + bsize = DFL_LFSBLOCK; + if (!(ssize = seg_size)) + ssize = DFL_LFSSEG; + + /* Modify parts of superblock overridden by command line arguments */ + if (bsize != DFL_LFSBLOCK) { + lfsp->lfs_bshift = log2(bsize); + if (1 << lfsp->lfs_bshift != bsize) + fatal("%d: block size not a power of 2", bsize); + lfsp->lfs_bsize = bsize; + lfsp->lfs_fsize = bsize; + lfsp->lfs_bmask = bsize - 1; + lfsp->lfs_inopb = bsize / sizeof(struct dinode); +/* MIS -- should I round to power of 2 */ + lfsp->lfs_ifpb = bsize / sizeof(IFILE); + lfsp->lfs_sepb = bsize / sizeof(SEGUSE); + lfsp->lfs_nindir = bsize / sizeof(daddr_t); + } + + if (ssize != DFL_LFSSEG) { + lfsp->lfs_segshift = log2(ssize); + if (1 << lfsp->lfs_segshift != ssize) + fatal("%d: segment size not power of 2", ssize); + lfsp->lfs_ssize = ssize; + lfsp->lfs_segmask = ssize - 1; + lfsp->lfs_dbpseg = ssize / DEV_BSIZE; + } + lfsp->lfs_ssize = ssize >> lfsp->lfs_bshift; + + if (minfree) + lfsp->lfs_minfree = minfree; + + /* + * Fill in parts of superblock that can be computed from file system + * size, disk geometry and current time. + */ + db_per_fb = bsize/lp->d_secsize; + lfsp->lfs_fsbtodb = log2(db_per_fb); + lfsp->lfs_sushift = log2(lfsp->lfs_sepb); + lfsp->lfs_size = partp->p_size >> lfsp->lfs_fsbtodb; + lfsp->lfs_dsize = lfsp->lfs_size - (LFS_LABELPAD >> lfsp->lfs_bshift); + lfsp->lfs_nseg = lfsp->lfs_dsize / lfsp->lfs_ssize; + lfsp->lfs_maxfilesize = maxtable[lfsp->lfs_bshift] << lfsp->lfs_bshift; + + /* + * The number of free blocks is set from the number of segments times + * the segment size - 2 (that we never write because we need to make + * sure the cleaner can run). Then we'll subtract off the room for the + * superblocks ifile entries and segment usage table. + */ + lfsp->lfs_dsize = fsbtodb(lfsp, (lfsp->lfs_nseg - 2) * lfsp->lfs_ssize); + lfsp->lfs_bfree = lfsp->lfs_dsize; + lfsp->lfs_segtabsz = SEGTABSIZE_SU(lfsp); + lfsp->lfs_cleansz = CLEANSIZE_SU(lfsp); + if ((lfsp->lfs_tstamp = time(NULL)) == -1) + fatal("time: %s", strerror(errno)); + if ((sb_interval = lfsp->lfs_nseg / LFS_MAXNUMSB) < LFS_MIN_SBINTERVAL) + sb_interval = LFS_MIN_SBINTERVAL; + + /* + * Now, lay out the file system. We need to figure out where + * the superblocks go, initialize the checkpoint information + * for the first two superblocks, initialize the segment usage + * information, put the segusage information in the ifile, create + * the first block of IFILE structures, and link all the IFILE + * structures into a free list. + */ + + /* Figure out where the superblocks are going to live */ + lfsp->lfs_sboffs[0] = LFS_LABELPAD/lp->d_secsize; + for (i = 1; i < LFS_MAXNUMSB; i++) { + sb_addr = ((i * sb_interval) << + (lfsp->lfs_segshift - lfsp->lfs_bshift + lfsp->lfs_fsbtodb)) + + lfsp->lfs_sboffs[0]; + if (sb_addr > partp->p_size) + break; + lfsp->lfs_sboffs[i] = sb_addr; + } + last_sb_addr = lfsp->lfs_sboffs[i - 1]; + lfsp->lfs_lastseg = lfsp->lfs_sboffs[0]; + lfsp->lfs_nextseg = + lfsp->lfs_sboffs[1] ? lfsp->lfs_sboffs[1] : lfsp->lfs_sboffs[0]; + lfsp->lfs_curseg = lfsp->lfs_lastseg; + + /* + * Initialize the segment usage table. The first segment will + * contain the superblock, the cleanerinfo (cleansz), the segusage + * table * (segtabsz), 1 block's worth of IFILE entries, the root + * directory, the lost+found directory and one block's worth of + * inodes (containing the ifile, root, and l+f inodes). + */ + if (!(cleaninfo = malloc(lfsp->lfs_cleansz << lfsp->lfs_bshift))) + fatal("%s", strerror(errno)); + cleaninfo->clean = lfsp->lfs_nseg - 1; + cleaninfo->dirty = 1; + + if (!(segtable = malloc(lfsp->lfs_segtabsz << lfsp->lfs_bshift))) + fatal("%s", strerror(errno)); + segp = segtable; + blocks_used = lfsp->lfs_segtabsz + lfsp->lfs_cleansz + 4; + segp->su_nbytes = ((blocks_used - 1) << lfsp->lfs_bshift) + + 3 * sizeof(struct dinode) + LFS_SUMMARY_SIZE; + segp->su_lastmod = lfsp->lfs_tstamp; + segp->su_nsums = 1; /* 1 summary blocks */ + segp->su_ninos = 1; /* 1 inode block */ + segp->su_flags = SEGUSE_SUPERBLOCK | SEGUSE_DIRTY; + lfsp->lfs_bfree -= LFS_SUMMARY_SIZE / lp->d_secsize; + lfsp->lfs_bfree -= + fsbtodb(lfsp, lfsp->lfs_cleansz + lfsp->lfs_segtabsz + 4); + + /* + * Now figure out the address of the ifile inode. The inode block + * appears immediately after the segment summary. + */ + lfsp->lfs_idaddr = (LFS_LABELPAD + LFS_SBPAD + LFS_SUMMARY_SIZE) / + lp->d_secsize; + + for (segp = segtable + 1, i = 1; i < lfsp->lfs_nseg; i++, segp++) { + if ((i % sb_interval) == 0) { + segp->su_flags = SEGUSE_SUPERBLOCK; + lfsp->lfs_bfree -= (LFS_SBPAD / lp->d_secsize); + } else + segp->su_flags = 0; + segp->su_lastmod = 0; + segp->su_nbytes = 0; + segp->su_ninos = 0; + segp->su_nsums = 0; + } + + /* + * Initialize dynamic accounting. The blocks available for + * writing are the bfree blocks minus 1 segment summary for + * each segment since you can't write any new data without + * creating a segment summary - 2 segments that the cleaner + * needs. + */ + lfsp->lfs_avail = lfsp->lfs_bfree - lfsp->lfs_nseg - + fsbtodb(lfsp, 2 * lfsp->lfs_ssize); + lfsp->lfs_uinodes = 0; + /* + * Ready to start writing segments. The first segment is different + * because it contains the segment usage table and the ifile inode + * as well as a superblock. For the rest of the segments, set the + * time stamp to be 0 so that the first segment is the most recent. + * For each segment that is supposed to contain a copy of the super + * block, initialize its first few blocks and its segment summary + * to indicate this. + */ + lfsp->lfs_nfiles = LFS_FIRST_INUM - 1; + lfsp->lfs_cksum = + cksum(lfsp, sizeof(struct lfs) - sizeof(lfsp->lfs_cksum)); + + /* Now create a block of disk inodes */ + if (!(dpagep = malloc(lfsp->lfs_bsize))) + fatal("%s", strerror(errno)); + dip = (struct dinode *)dpagep; + bzero(dip, lfsp->lfs_bsize); + + /* Create a block of IFILE structures. */ + if (!(ipagep = malloc(lfsp->lfs_bsize))) + fatal("%s", strerror(errno)); + ifile = (IFILE *)ipagep; + + /* + * Initialize IFILE. It is the next block following the + * block of inodes (whose address has been calculated in + * lfsp->lfs_idaddr; + */ + sb_addr = lfsp->lfs_idaddr + lfsp->lfs_bsize / lp->d_secsize; + sb_addr = make_dinode(LFS_IFILE_INUM, dip, + lfsp->lfs_cleansz + lfsp->lfs_segtabsz+1, sb_addr, lfsp); + dip->di_mode = IFREG|IREAD|IWRITE; + ip = &ifile[LFS_IFILE_INUM]; + ip->if_version = 1; + ip->if_daddr = lfsp->lfs_idaddr; + + /* Initialize the ROOT Directory */ + sb_addr = make_dinode(ROOTINO, ++dip, 1, sb_addr, lfsp); + dip->di_mode = IFDIR|IREAD|IWRITE|IEXEC; + dip->di_size = DIRBLKSIZ; + dip->di_nlink = 3; + ip = &ifile[ROOTINO]; + ip->if_version = 1; + ip->if_daddr = lfsp->lfs_idaddr; + + /* Initialize the lost+found Directory */ + sb_addr = make_dinode(LOSTFOUNDINO, ++dip, 1, sb_addr, lfsp); + dip->di_mode = IFDIR|IREAD|IWRITE|IEXEC; + dip->di_size = DIRBLKSIZ; + dip->di_nlink = 2; + ip = &ifile[LOSTFOUNDINO]; + ip->if_version = 1; + ip->if_daddr = lfsp->lfs_idaddr; + + /* Make all the other dinodes invalid */ + for (i = INOPB(lfsp)-3, dip++; i; i--, dip++) + dip->di_inumber = LFS_UNUSED_INUM; + + + /* Link remaining IFILE entries in free list */ + for (ip = &ifile[LFS_FIRST_INUM], i = LFS_FIRST_INUM; + i < lfsp->lfs_ifpb; ++ip) { + ip->if_version = 1; + ip->if_daddr = LFS_UNUSED_DADDR; + ip->if_nextfree = ++i; + } + ifile[lfsp->lfs_ifpb - 1].if_nextfree = LFS_UNUSED_INUM; + + /* Now, write the segment */ + + /* Compute a checksum across all the data you're writing */ + dp = datasump = malloc (blocks_used * sizeof(u_long)); + *dp++ = ((u_long *)dpagep)[0]; /* inode block */ + for (i = 0; i < lfsp->lfs_cleansz; i++) + *dp++ = ((u_long *)cleaninfo)[(i << lfsp->lfs_bshift) / + sizeof(u_long)]; /* Cleaner info */ + for (i = 0; i < lfsp->lfs_segtabsz; i++) + *dp++ = ((u_long *)segtable)[(i << lfsp->lfs_bshift) / + sizeof(u_long)]; /* Segusage table */ + *dp++ = ((u_long *)ifile)[0]; /* Ifile */ + + /* Still need the root and l+f bytes; get them later */ + + /* Write out the inode block */ + off = LFS_LABELPAD + LFS_SBPAD + LFS_SUMMARY_SIZE; + put(fd, off, dpagep, lfsp->lfs_bsize); + free(dpagep); + off += lfsp->lfs_bsize; + + /* Write out the ifile */ + + put(fd, off, cleaninfo, lfsp->lfs_cleansz << lfsp->lfs_bshift); + off += (lfsp->lfs_cleansz << lfsp->lfs_bshift); + (void)free(cleaninfo); + + put(fd, off, segtable, lfsp->lfs_segtabsz << lfsp->lfs_bshift); + off += (lfsp->lfs_segtabsz << lfsp->lfs_bshift); + (void)free(segtable); + + put(fd, off, ifile, lfsp->lfs_bsize); + off += lfsp->lfs_bsize; + + /* + * use ipagep for space for writing out other stuff. It used to + * contain the ifile, but we're done with it. + */ + + /* Write out the root and lost and found directories */ + bzero(ipagep, lfsp->lfs_bsize); + make_dir(ipagep, lfs_root_dir, + sizeof(lfs_root_dir) / sizeof(struct direct)); + *dp++ = ((u_long *)ipagep)[0]; + put(fd, off, ipagep, lfsp->lfs_bsize); + off += lfsp->lfs_bsize; + + bzero(ipagep, lfsp->lfs_bsize); + make_dir(ipagep, lfs_lf_dir, + sizeof(lfs_lf_dir) / sizeof(struct direct)); + *dp++ = ((u_long *)ipagep)[0]; + put(fd, off, ipagep, lfsp->lfs_bsize); + + /* Write Supberblock */ + lfsp->lfs_offset = (off + lfsp->lfs_bsize) / lp->d_secsize; + put(fd, LFS_LABELPAD, lfsp, sizeof(struct lfs)); + + /* + * Finally, calculate all the fields for the summary structure + * and write it. + */ + + summary.ss_next = lfsp->lfs_nextseg; + summary.ss_create = lfsp->lfs_tstamp; + summary.ss_nfinfo = 3; + summary.ss_ninos = 3; + summary.ss_datasum = cksum(datasump, sizeof(u_long) * blocks_used); + + /* + * Make sure that we don't overflow a summary block. We have to + * record: FINFO structures for ifile, root, and l+f. The number + * of blocks recorded for the ifile is determined by the size of + * the cleaner info and the segments usage table. There is room + * for one block included in sizeof(FINFO) so we don't need to add + * any extra space for the ROOT and L+F, and one block of the ifile + * is already counted. Finally, we leave room for 1 inode block + * address. + */ + sum_size = 3*sizeof(FINFO) + sizeof(SEGSUM) + sizeof(daddr_t) + + (lfsp->lfs_cleansz + lfsp->lfs_segtabsz) * sizeof(u_long); +#define SUMERR \ +"Multiple summary blocks in segment 1 not yet implemented\nsummary is %d bytes." + if (sum_size > LFS_SUMMARY_SIZE) + fatal(SUMERR, sum_size); + + block_array_size = lfsp->lfs_cleansz + lfsp->lfs_segtabsz + 1; + + if (!(block_array = malloc(block_array_size *sizeof(int)))) + fatal("%s: %s", special, strerror(errno)); + + /* fill in the array */ + for (i = 0; i < block_array_size; i++) + block_array[i] = i; + + /* copy into segment */ + sump = ipagep; + bcopy(&summary, sump, sizeof(SEGSUM)); + sump += sizeof(SEGSUM); + + /* Now, add the ifile */ + file_info.fi_nblocks = block_array_size; + file_info.fi_version = 1; + file_info.fi_ino = LFS_IFILE_INUM; + + bcopy(&file_info, sump, sizeof(FINFO) - sizeof(u_long)); + sump += sizeof(FINFO) - sizeof(u_long); + bcopy(block_array, sump, sizeof(u_long) * file_info.fi_nblocks); + sump += sizeof(u_long) * file_info.fi_nblocks; + + /* Now, add the root directory */ + file_info.fi_nblocks = 1; + file_info.fi_version = 1; + file_info.fi_ino = ROOTINO; + file_info.fi_blocks[0] = 0; + bcopy(&file_info, sump, sizeof(FINFO)); + sump += sizeof(FINFO); + + /* Now, add the lost and found */ + file_info.fi_ino = LOSTFOUNDINO; + bcopy(&file_info, sump, sizeof(FINFO)); + + ((daddr_t *)ipagep)[LFS_SUMMARY_SIZE / sizeof(daddr_t) - 1] = + lfsp->lfs_idaddr; + ((SEGSUM *)ipagep)->ss_sumsum = cksum(ipagep+sizeof(summary.ss_sumsum), + LFS_SUMMARY_SIZE - sizeof(summary.ss_sumsum)); + put(fd, LFS_LABELPAD + LFS_SBPAD, ipagep, LFS_SUMMARY_SIZE); + + sp = (SEGSUM *)ipagep; + sp->ss_create = 0; + sp->ss_nfinfo = 0; + sp->ss_ninos = 0; + sp->ss_datasum = 0; + + /* Now write the summary block for the next partial so it's invalid */ + lfsp->lfs_tstamp = 0; + off += lfsp->lfs_bsize; + sp->ss_sumsum = + cksum(&sp->ss_datasum, LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum)); + put(fd, off, sp, LFS_SUMMARY_SIZE); + + /* Now, write rest of segments containing superblocks */ + lfsp->lfs_cksum = + cksum(lfsp, sizeof(struct lfs) - sizeof(lfsp->lfs_cksum)); + for (seg_addr = last_addr = lfsp->lfs_sboffs[0], j = 1, i = 1; + i < lfsp->lfs_nseg; i++) { + + seg_addr += lfsp->lfs_ssize << lfsp->lfs_fsbtodb; + sp->ss_next = last_addr; + last_addr = seg_addr; + seg_seek = seg_addr * lp->d_secsize; + + if (seg_addr == lfsp->lfs_sboffs[j]) { + if (j < (LFS_MAXNUMSB - 2)) + j++; + put(fd, seg_seek, lfsp, sizeof(struct lfs)); + seg_seek += LFS_SBPAD; + } + + /* Summary */ + sp->ss_sumsum = cksum(&sp->ss_datasum, + LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum)); + put(fd, seg_seek, sp, LFS_SUMMARY_SIZE); + } + free(ipagep); + close(fd); + return (0); +} + +static void +put(fd, off, p, len) + int fd; + off_t off; + void *p; + size_t len; +{ + int wbytes; + + if (lseek(fd, off, SEEK_SET) < 0) + fatal("%s: %s", special, strerror(errno)); + if ((wbytes = write(fd, p, len)) < 0) + fatal("%s: %s", special, strerror(errno)); + if (wbytes != len) + fatal("%s: short write (%d, not %d)", special, wbytes, len); +} + +/* + * Create the root directory for this file system and the lost+found + * directory. + */ + + u_long d_ino; /* inode number of entry */ + u_short d_reclen; /* length of this record */ + u_short d_namlen; /* length of string in d_name */ + char d_name[MAXNAMLEN + 1]; /* name with length <= MAXNAMLEN */ +void +lfsinit() +{} + +static daddr_t +make_dinode(ino, dip, nblocks, saddr, lfsp) + ino_t ino; /* inode we're creating */ + struct dinode *dip; /* disk inode */ + int nblocks; /* number of blocks in file */ + daddr_t saddr; /* starting block address */ + struct lfs *lfsp; /* superblock */ +{ + int db_per_fb, i; + + dip->di_nlink = 1; + dip->di_blocks = nblocks << lfsp->lfs_fsbtodb; + + dip->di_size = (nblocks << lfsp->lfs_bshift); + dip->di_atime.ts_sec = dip->di_mtime.ts_sec = + dip->di_ctime.ts_sec = lfsp->lfs_tstamp; + dip->di_atime.ts_nsec = dip->di_mtime.ts_nsec = + dip->di_ctime.ts_nsec = 0; + dip->di_inumber = ino; + +#define SEGERR \ +"File requires more than the number of direct blocks; increase block or segment size." + if (NDADDR < nblocks) + fatal("%s", SEGERR); + + /* Assign the block addresses for the ifile */ + db_per_fb = 1 << lfsp->lfs_fsbtodb; + for (i = 0; i < nblocks; i++, saddr += db_per_fb) + dip->di_db[i] = saddr; + + return (saddr); +} + + +/* + * Construct a set of directory entries in "bufp". We assume that all the + * entries in protodir fir in the first DIRBLKSIZ. + */ +static void +make_dir(bufp, protodir, entries) + void *bufp; + register struct direct *protodir; + int entries; +{ + char *cp; + int i, spcleft; + + spcleft = DIRBLKSIZ; + for (cp = bufp, i = 0; i < entries - 1; i++) { + protodir[i].d_reclen = DIRSIZ(NEWDIRFMT, &protodir[i]); + bcopy(&protodir[i], cp, protodir[i].d_reclen); + cp += protodir[i].d_reclen; + if ((spcleft -= protodir[i].d_reclen) < 0) + fatal("%s: %s", special, "directory too big"); + } + protodir[i].d_reclen = spcleft; + bcopy(&protodir[i], cp, DIRSIZ(NEWDIRFMT, &protodir[i])); +} diff --git a/sbin/newlfs/misc.c b/sbin/newlfs/misc.c new file mode 100644 index 0000000..074fb71 --- /dev/null +++ b/sbin/newlfs/misc.c @@ -0,0 +1,83 @@ +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char sccsid[] = "@(#)misc.c 8.1 (Berkeley) 6/5/93"; +#endif /* not lint */ + +#include +#include +#include +#include +#include +#include "extern.h" + +u_int +log2(num) + u_int num; +{ + register u_int i, limit; + + limit = 1; + for (i = 0; limit < num; limit = limit << 1, i++); + return (i); +} + +#if __STDC__ +#include +#else +#include +#endif + +void +#if __STDC__ +fatal(const char *fmt, ...) +#else +fatal(fmt, va_alist) + char *fmt; + va_dcl +#endif +{ + va_list ap; +#if __STDC__ + va_start(ap, fmt); +#else + va_start(ap); +#endif + (void)fprintf(stderr, "%s: ", progname); + (void)vfprintf(stderr, fmt, ap); + va_end(ap); + (void)fprintf(stderr, "\n"); + exit(1); + /* NOTREACHED */ +} diff --git a/sbin/newlfs/newfs.c b/sbin/newlfs/newfs.c new file mode 100644 index 0000000..25ac7f0 --- /dev/null +++ b/sbin/newlfs/newfs.c @@ -0,0 +1,466 @@ +/*- + * Copyright (c) 1989, 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char copyright[] = +"@(#) Copyright (c) 1989, 1992, 1993\n\ + The Regents of the University of California. All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)newfs.c 8.3 (Berkeley) 4/22/94"; +#endif /* not lint */ + +/* + * newfs: friendly front end to mkfs + */ +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include "config.h" +#include "extern.h" + +#define COMPAT /* allow non-labeled disks */ + +int mfs; /* run as the memory based filesystem */ +int Nflag; /* run without writing file system */ +int fssize; /* file system size */ +int ntracks; /* # tracks/cylinder */ +int nsectors; /* # sectors/track */ +int nphyssectors; /* # sectors/track including spares */ +int secpercyl; /* sectors per cylinder */ +int trackspares = -1; /* spare sectors per track */ +int cylspares = -1; /* spare sectors per cylinder */ +int sectorsize; /* bytes/sector */ +#ifdef tahoe +int realsectorsize; /* bytes/sector in hardware */ +#endif +int rpm; /* revolutions/minute of drive */ +int interleave; /* hardware sector interleave */ +int trackskew = -1; /* sector 0 skew, per track */ +int headswitch; /* head switch time, usec */ +int trackseek; /* track-to-track seek, usec */ +int fsize = 0; /* fragment size */ +int bsize = 0; /* block size */ +int cpg = DESCPG; /* cylinders/cylinder group */ +int cpgflg; /* cylinders/cylinder group flag was given */ +int minfree = MINFREE; /* free space threshold */ +int opt = DEFAULTOPT; /* optimization preference (space or time) */ +int density; /* number of bytes per inode */ +int maxcontig = MAXCONTIG; /* max contiguous blocks to allocate */ +int rotdelay = ROTDELAY; /* rotational delay between blocks */ +int maxbpg; /* maximum blocks per file in a cyl group */ +int nrpos = NRPOS; /* # of distinguished rotational positions */ +int bbsize = BBSIZE; /* boot block size */ +int sbsize = SBSIZE; /* superblock size */ +int mntflags; /* flags to be passed to mount */ +u_long memleft; /* virtual memory available */ +caddr_t membase; /* start address of memory based filesystem */ +#ifdef COMPAT +char *disktype; +int unlabeled; +#endif + +char device[MAXPATHLEN]; +char *progname, *special; + +static struct disklabel *getdisklabel __P((char *, int)); +static struct disklabel *debug_readlabel __P((int)); +static void rewritelabel __P((char *, int, struct disklabel *)); +static void usage __P((void)); + +int +main(argc, argv) + int argc; + char *argv[]; +{ + register int ch; + register struct partition *pp; + register struct disklabel *lp; + struct partition oldpartition; + struct stat st; + int debug, lfs, fsi, fso, segsize; + char *cp, *opstring; + + if (progname = rindex(*argv, '/')) + ++progname; + else + progname = *argv; + + if (strstr(progname, "mfs")) { + mfs = 1; + Nflag++; + } + + /* -F is mfs only and MUST come first! */ + opstring = "F:B:DLNS:T:a:b:c:d:e:f:i:k:l:m:n:o:p:r:s:t:u:x:"; + if (!mfs) + opstring += 2; + + debug = lfs = segsize = 0; + while ((ch = getopt(argc, argv, opstring)) != EOF) + switch(ch) { + case 'B': /* LFS segment size */ + if ((segsize = atoi(optarg)) < LFS_MINSEGSIZE) + fatal("%s: bad segment size", optarg); + break; + case 'D': + debug = 1; + break; + case 'F': + if ((mntflags = atoi(optarg)) == 0) + fatal("%s: bad mount flags", optarg); + break; + case 'L': /* Create lfs */ + lfs = 1; + break; + case 'N': + Nflag++; + break; + case 'S': + if ((sectorsize = atoi(optarg)) <= 0) + fatal("%s: bad sector size", optarg); + break; +#ifdef COMPAT + case 'T': + disktype = optarg; + break; +#endif + case 'a': + if ((maxcontig = atoi(optarg)) <= 0) + fatal("%s: bad max contiguous blocks\n", + optarg); + break; + case 'b': /* used for LFS */ + if ((bsize = atoi(optarg)) < LFS_MINBLOCKSIZE) + fatal("%s: bad block size", optarg); + break; + case 'c': + if ((cpg = atoi(optarg)) <= 0) + fatal("%s: bad cylinders/group", optarg); + cpgflg++; + break; + case 'd': + if ((rotdelay = atoi(optarg)) < 0) + fatal("%s: bad rotational delay\n", optarg); + break; + case 'e': + if ((maxbpg = atoi(optarg)) <= 0) + fatal("%s: bad blocks per file in a cyl group\n", + optarg); + break; + case 'f': + if ((fsize = atoi(optarg)) <= 0) + fatal("%s: bad frag size", optarg); + break; + case 'i': + if ((density = atoi(optarg)) <= 0) + fatal("%s: bad bytes per inode\n", optarg); + break; + case 'k': + if ((trackskew = atoi(optarg)) < 0) + fatal("%s: bad track skew", optarg); + break; + case 'l': + if ((interleave = atoi(optarg)) <= 0) + fatal("%s: bad interleave", optarg); + break; + case 'm': /* used for LFS */ + if ((minfree = atoi(optarg)) < 0 || minfree > 99) + fatal("%s: bad free space %%\n", optarg); + break; + case 'n': + if ((nrpos = atoi(optarg)) <= 0) + fatal("%s: bad rotational layout count\n", + optarg); + break; + case 'o': + if (strcmp(optarg, "space") == 0) + opt = FS_OPTSPACE; + else if (strcmp(optarg, "time") == 0) + opt = FS_OPTTIME; + else + fatal("%s: bad optimization preference %s", + optarg, "(options are `space' or `time')"); + break; + case 'p': + if ((trackspares = atoi(optarg)) < 0) + fatal("%s: bad spare sectors per track", + optarg); + break; + case 'r': + if ((rpm = atoi(optarg)) <= 0) + fatal("%s: bad revs/minute\n", optarg); + break; + case 's': /* used for LFS */ + if ((fssize = atoi(optarg)) <= 0) + fatal("%s: bad file system size", optarg); + break; + case 't': + if ((ntracks = atoi(optarg)) <= 0) + fatal("%s: bad total tracks", optarg); + break; + case 'u': + if ((nsectors = atoi(optarg)) <= 0) + fatal("%s: bad sectors/track", optarg); + break; + case 'x': + if ((cylspares = atoi(optarg)) < 0) + fatal("%s: bad spare sectors per cylinder", + optarg); + break; + case '?': + default: + usage(); + } + argc -= optind; + argv += optind; + + if (argc != 2 && (mfs || argc != 1)) + usage(); + + /* + * If the -N flag isn't specified, open the output file. If no path + * prefix, try /dev/r%s and then /dev/%s. + */ + special = argv[0]; + if (index(special, '/') == NULL) { + (void)sprintf(device, "%sr%s", _PATH_DEV, special); + if (stat(device, &st) == -1) + (void)sprintf(device, "%s%s", _PATH_DEV, special); + special = device; + } + if (!Nflag) { + fso = open(special, + (debug ? O_CREAT : 0) | O_WRONLY, DEFFILEMODE); + if (fso < 0) + fatal("%s: %s", special, strerror(errno)); + } else + fso = -1; + + /* Open the input file. */ + fsi = open(special, O_RDONLY); + if (fsi < 0) + fatal("%s: %s", special, strerror(errno)); + if (fstat(fsi, &st) < 0) + fatal("%s: %s", special, strerror(errno)); + + if (!debug && !mfs && !S_ISCHR(st.st_mode)) + (void)printf("%s: %s: not a character-special device\n", + progname, special); + cp = index(argv[0], '\0') - 1; + if (!debug && (cp == 0 || (*cp < 'a' || *cp > 'h') && !isdigit(*cp))) + fatal("%s: can't figure out file system partition", argv[0]); + +#ifdef COMPAT + if (!mfs && disktype == NULL) + disktype = argv[1]; +#endif + if (debug) + lp = debug_readlabel(fsi); + else + lp = getdisklabel(special, fsi); + + if (isdigit(*cp)) + pp = &lp->d_partitions[0]; + else + pp = &lp->d_partitions[*cp - 'a']; + if (pp->p_size == 0) + fatal("%s: `%c' partition is unavailable", argv[0], *cp); + + /* If we're making a LFS, we break out here */ + exit(make_lfs(fso, lp, pp, minfree, bsize, segsize)); +} + +#ifdef COMPAT +char lmsg[] = "%s: can't read disk label; disk type must be specified"; +#else +char lmsg[] = "%s: can't read disk label"; +#endif + +static struct disklabel * +getdisklabel(s, fd) + char *s; + int fd; +{ + static struct disklabel lab; + + if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) { +#ifdef COMPAT + if (disktype) { + struct disklabel *lp, *getdiskbyname(); + + unlabeled++; + lp = getdiskbyname(disktype); + if (lp == NULL) + fatal("%s: unknown disk type", disktype); + return (lp); + } +#endif + (void)fprintf(stderr, + "%s: ioctl (GDINFO): %s\n", progname, strerror(errno)); + fatal(lmsg, s); + } + return (&lab); +} + + +static struct disklabel * +debug_readlabel(fd) + int fd; +{ + static struct disklabel lab; + int n; + + if ((n = read(fd, &lab, sizeof(struct disklabel))) < 0) + fatal("unable to read disk label: %s", strerror(errno)); + else if (n < sizeof(struct disklabel)) + fatal("short read of disklabel: %d of %d bytes", n, + sizeof(struct disklabel)); + return(&lab); +} + +static void +rewritelabel(s, fd, lp) + char *s; + int fd; + register struct disklabel *lp; +{ +#ifdef COMPAT + if (unlabeled) + return; +#endif + lp->d_checksum = 0; + lp->d_checksum = dkcksum(lp); + if (ioctl(fd, DIOCWDINFO, (char *)lp) < 0) { + (void)fprintf(stderr, + "%s: ioctl (WDINFO): %s\n", progname, strerror(errno)); + fatal("%s: can't rewrite disk label", s); + } +#if vax + if (lp->d_type == DTYPE_SMD && lp->d_flags & D_BADSECT) { + register i; + int cfd; + daddr_t alt; + char specname[64]; + char blk[1024]; + char *cp; + + /* + * Make name for 'c' partition. + */ + strcpy(specname, s); + cp = specname + strlen(specname) - 1; + if (!isdigit(*cp)) + *cp = 'c'; + cfd = open(specname, O_WRONLY); + if (cfd < 0) + fatal("%s: %s", specname, strerror(errno)); + bzero(blk, sizeof(blk)); + *(struct disklabel *)(blk + LABELOFFSET) = *lp; + alt = lp->d_ncylinders * lp->d_secpercyl - lp->d_nsectors; + for (i = 1; i < 11 && i < lp->d_nsectors; i += 2) { + if (lseek(cfd, (off_t)(alt + i) * lp->d_secsize, + L_SET) == -1) + fatal("lseek to badsector area: %s", + strerror(errno)); + if (write(cfd, blk, lp->d_secsize) < lp->d_secsize) + fprintf(stderr, + "%s: alternate label %d write: %s\n", + progname, i/2, strerror(errno)); + } + close(cfd); + } +#endif +} + +void +usage() +{ + if (mfs) { + fprintf(stderr, + "usage: mfs [ -fsoptions ] special-device mount-point\n"); + } else + fprintf(stderr, + "usage: newlfs [ -fsoptions ] special-device%s\n", +#ifdef COMPAT + " [device-type]"); +#else + ""); +#endif + fprintf(stderr, "where fsoptions are:\n"); + fprintf(stderr, "\t-B LFS segment size\n"); + fprintf(stderr, "\t-D debug\n"); + fprintf(stderr, "\t-F mount flags\n"); + fprintf(stderr, "\t-L create LFS file system\n"); + fprintf(stderr, + "\t-N do not create file system, just print out parameters\n"); + fprintf(stderr, "\t-S sector size\n"); +#ifdef COMPAT + fprintf(stderr, "\t-T disktype\n"); +#endif + fprintf(stderr, "\t-a maximum contiguous blocks\n"); + fprintf(stderr, "\t-b block size\n"); + fprintf(stderr, "\t-c cylinders/group\n"); + fprintf(stderr, "\t-d rotational delay between contiguous blocks\n"); + fprintf(stderr, "\t-e maximum blocks per file in a cylinder group\n"); + fprintf(stderr, "\t-f frag size\n"); + fprintf(stderr, "\t-i number of bytes per inode\n"); + fprintf(stderr, "\t-k sector 0 skew, per track\n"); + fprintf(stderr, "\t-l hardware sector interleave\n"); + fprintf(stderr, "\t-m minimum free space %%\n"); + fprintf(stderr, "\t-n number of distinguished rotational positions\n"); + fprintf(stderr, "\t-o optimization preference (`space' or `time')\n"); + fprintf(stderr, "\t-p spare sectors per track\n"); + fprintf(stderr, "\t-r revolutions/minute\n"); + fprintf(stderr, "\t-s file system size (sectors)\n"); + fprintf(stderr, "\t-t tracks/cylinder\n"); + fprintf(stderr, "\t-u sectors/track\n"); + fprintf(stderr, "\t-x spare sectors per cylinder\n"); + exit(1); +} diff --git a/sbin/newlfs/newlfs.8 b/sbin/newlfs/newlfs.8 new file mode 100644 index 0000000..92474e5 --- /dev/null +++ b/sbin/newlfs/newlfs.8 @@ -0,0 +1,95 @@ +.\" Copyright (c) 1993 +.\" The Regents of the University of California. All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgement: +.\" This product includes software developed by the University of +.\" California, Berkeley and its contributors. +.\" 4. Neither the name of the University nor the names of its contributors +.\" may be used to endorse or promote products derived from this software +.\" without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" @(#)newlfs.8 8.1 (Berkeley) 6/19/93 +.\" +.Dd June 19, 1993 +.Dt NEWLFS 8 +.Os BSD 4.4 +.Sh NAME +.Nm newlfs +.Nd construct a new LFS file system +.Sh SYNOPSIS +.Nm newlfs +.Fl L +.Op Ar newlfs-options +.Ar special +.Sh DESCRIPTION +.Nm Newlfs +builds a log-structured file system on the specified special +device basing its defaults on the information in the disk label. +(Before running +.Nm newlfs +the disk must be labeled using +.Xr disklabel 8 .) +.Pp +The following options define the general layout policies. +.Bl -tag -width Fl +.It Fl B +The logical segment size of the file system in bytes. +.It Fl b Ar block-size +The block size of the file system in bytes. +.It Fl L +Create a log-structured file system (LFS). +This flag is currently required. +.It Fl m Ar free space \&% +The percentage of space reserved from normal users; the minimum +free space threshold. The default value used is 10%. +See +.Xr tunefs 8 +for more details on how to set this option. +.It Fl s Ar size +The size of the file system in sectors. +.El +.Sh SEE ALSO +.Xr disktab 5 , +.Xr fs 5 , +.Xr dumplfs 8 , +.Xr disklabel 8 , +.Xr diskpart 8 , +.Xr tunefs 8 +.Rs +.%A M. McKusick +.%A W. Joy +.%A S. Leffler +.%A R. Fabry +.%T A Fast File System for UNIX , +.%J ACM Transactions on Computer Systems 2 +.%V 3 +.%P pp 181-197 +.%D August 1984 +.%O (reprinted in the BSD System Manager's Manual) +.Re +.Sh HISTORY +The +.Nm +command appeared in +.Bx 4.4 . -- cgit v1.1