2001-11-01 10:44:05 +03:00
|
|
|
/* $NetBSD: newfs.c,v 1.8 2001/11/01 07:44:05 lukem Exp $ */
|
1995-03-18 17:54:19 +03:00
|
|
|
|
1994-06-08 23:27:32 +04:00
|
|
|
/*-
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
1997-09-15 10:55:39 +04:00
|
|
|
#include <sys/cdefs.h>
|
1994-06-08 23:27:32 +04:00
|
|
|
#ifndef lint
|
1997-09-15 10:55:39 +04:00
|
|
|
__COPYRIGHT("@(#) Copyright (c) 1989, 1992, 1993\n\
|
|
|
|
The Regents of the University of California. All rights reserved.\n");
|
1994-06-08 23:27:32 +04:00
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#ifndef lint
|
1995-03-18 17:54:19 +03:00
|
|
|
#if 0
|
1998-03-01 05:20:01 +03:00
|
|
|
static char sccsid[] = "@(#)newfs.c 8.5 (Berkeley) 5/24/95";
|
1995-03-18 17:54:19 +03:00
|
|
|
#else
|
2001-11-01 10:44:05 +03:00
|
|
|
__RCSID("$NetBSD: newfs.c,v 1.8 2001/11/01 07:44:05 lukem Exp $");
|
1995-03-18 17:54:19 +03:00
|
|
|
#endif
|
1994-06-08 23:27:32 +04:00
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* newfs: friendly front end to mkfs
|
|
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/ucred.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/disklabel.h>
|
|
|
|
#include <sys/file.h>
|
|
|
|
#include <sys/mount.h>
|
1995-06-28 06:21:02 +04:00
|
|
|
#include <sys/sysctl.h>
|
2000-12-05 22:51:14 +03:00
|
|
|
#include <sys/time.h>
|
1994-06-08 23:27:32 +04:00
|
|
|
|
|
|
|
#include <ufs/ufs/dir.h>
|
|
|
|
#include <ufs/ufs/dinode.h>
|
2000-12-05 22:51:14 +03:00
|
|
|
#include <ufs/lfs/lfs.h>
|
1994-06-08 23:27:32 +04:00
|
|
|
|
1999-01-20 01:23:36 +03:00
|
|
|
#include <disktab.h>
|
1994-06-08 23:27:32 +04:00
|
|
|
#include <errno.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <paths.h>
|
1996-05-16 11:13:01 +04:00
|
|
|
#include <util.h>
|
1994-06-08 23:27:32 +04:00
|
|
|
#include "config.h"
|
|
|
|
#include "extern.h"
|
|
|
|
|
|
|
|
#define COMPAT /* allow non-labeled disks */
|
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
int Nflag = 0; /* run without writing file system */
|
1994-06-08 23:27:32 +04:00
|
|
|
int fssize; /* file system size */
|
|
|
|
int sectorsize; /* bytes/sector */
|
|
|
|
int fsize = 0; /* fragment size */
|
|
|
|
int bsize = 0; /* block size */
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
int ibsize = 0; /* inode block size */
|
|
|
|
int interleave = 0; /* segment interleave */
|
1994-06-08 23:27:32 +04:00
|
|
|
int minfree = MINFREE; /* free space threshold */
|
2000-07-05 02:35:04 +04:00
|
|
|
int minfreeseg = 0; /* free segments reserved for the cleaner */
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
u_int32_t roll_id = 0; /* roll-forward id */
|
1994-06-08 23:27:32 +04:00
|
|
|
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;
|
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
static struct disklabel *getdisklabel(char *, int);
|
|
|
|
static struct disklabel *debug_readlabel(int);
|
1997-08-01 10:18:29 +04:00
|
|
|
#ifdef notdef
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
static void rewritelabel(char *, int, struct disklabel *);
|
1997-08-01 10:18:29 +04:00
|
|
|
#endif
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
static void usage(void);
|
1994-06-08 23:27:32 +04:00
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
/* CHUNKSIZE should be larger than MAXPHYS */
|
|
|
|
#define CHUNKSIZE (1024 * 1024)
|
2000-12-05 22:51:14 +03:00
|
|
|
|
|
|
|
static size_t
|
|
|
|
auto_segsize(int fd, off_t len, int version)
|
|
|
|
{
|
|
|
|
off_t off, bw;
|
|
|
|
time_t start, finish;
|
|
|
|
char buf[CHUNKSIZE];
|
|
|
|
long seeks;
|
|
|
|
size_t final;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* First, get sequential access bandwidth */
|
|
|
|
time(&start);
|
|
|
|
finish = start;
|
|
|
|
for (off = 0; finish - start < 10; off += CHUNKSIZE) {
|
|
|
|
if (pread(fd, buf, CHUNKSIZE, off) < 0)
|
|
|
|
break;
|
|
|
|
time(&finish);
|
|
|
|
}
|
|
|
|
/* Bandwidth = bytes / sec */
|
|
|
|
/* printf("%ld bytes in %ld seconds\n", (long)off, (long)(finish - start)); */
|
|
|
|
bw = off / (finish - start);
|
|
|
|
|
|
|
|
/* Second, seek time */
|
|
|
|
time(&start);
|
|
|
|
finish = start; /* structure copy */
|
|
|
|
for (seeks = 0; finish - start < 10; ) {
|
|
|
|
off = (((double)rand()) * len) / (off_t)RAND_MAX;
|
|
|
|
if (pread(fd, buf, dbtob(1), off) < 0)
|
|
|
|
break;
|
|
|
|
time(&finish);
|
|
|
|
++seeks;
|
|
|
|
}
|
|
|
|
/* printf("%ld seeks in %ld seconds\n", (long)seeks, (long)(finish - start)); */
|
|
|
|
/* Seek time in units/sec */
|
|
|
|
seeks /= (finish - start);
|
|
|
|
if (seeks == 0)
|
|
|
|
seeks = 1;
|
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
printf("bw = %ld B/s, seek time %ld ms (%ld seeks/s)\n",
|
2000-12-05 22:51:14 +03:00
|
|
|
(long)bw, 1000/seeks, seeks);
|
|
|
|
final = dbtob(btodb(4 * bw / seeks));
|
|
|
|
if (version == 1) {
|
|
|
|
for (i = 0; final; final >>= 1, i++)
|
|
|
|
;
|
|
|
|
final = 1 << i;
|
|
|
|
}
|
|
|
|
printf("using initial segment size %ld\n", (long)final);
|
|
|
|
return final;
|
|
|
|
}
|
|
|
|
|
1994-06-08 23:27:32 +04:00
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
main(int argc, char **argv)
|
1994-06-08 23:27:32 +04:00
|
|
|
{
|
2001-11-01 10:44:05 +03:00
|
|
|
int version, ch;
|
1997-09-15 15:40:28 +04:00
|
|
|
struct partition *pp;
|
|
|
|
struct disklabel *lp;
|
1994-06-08 23:27:32 +04:00
|
|
|
struct stat st;
|
2000-12-05 22:51:14 +03:00
|
|
|
int debug, force, fsi, fso, segsize, maxpartitions;
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
daddr_t start;
|
1994-06-08 23:27:32 +04:00
|
|
|
char *cp, *opstring;
|
|
|
|
|
2001-11-01 10:44:05 +03:00
|
|
|
version = DFL_VERSION; /* what version of lfs to make */
|
|
|
|
|
1997-08-01 10:18:29 +04:00
|
|
|
if ((progname = strrchr(*argv, '/')) != NULL)
|
1994-06-08 23:27:32 +04:00
|
|
|
++progname;
|
|
|
|
else
|
|
|
|
progname = *argv;
|
|
|
|
|
1995-06-28 06:21:02 +04:00
|
|
|
maxpartitions = getmaxpartitions();
|
|
|
|
if (maxpartitions > 26)
|
|
|
|
fatal("insane maxpartitions value %d", maxpartitions);
|
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
opstring = "AB:b:DFf:I:i:LM:m:NO:r:s:v:";
|
1994-06-08 23:27:32 +04:00
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
debug = force = segsize = start = 0;
|
1997-09-15 10:55:39 +04:00
|
|
|
while ((ch = getopt(argc, argv, opstring)) != -1)
|
1994-06-08 23:27:32 +04:00
|
|
|
switch(ch) {
|
2000-12-05 22:51:14 +03:00
|
|
|
case 'A': /* Adaptively configure segment size */
|
|
|
|
segsize = -1;
|
|
|
|
break;
|
1994-06-08 23:27:32 +04:00
|
|
|
case 'B': /* LFS segment size */
|
|
|
|
if ((segsize = atoi(optarg)) < LFS_MINSEGSIZE)
|
|
|
|
fatal("%s: bad segment size", optarg);
|
|
|
|
break;
|
|
|
|
case 'D':
|
|
|
|
debug = 1;
|
|
|
|
break;
|
2000-02-13 02:58:09 +03:00
|
|
|
case 'F':
|
|
|
|
force = 1;
|
|
|
|
break;
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
case 'I':
|
|
|
|
interleave = atoi(optarg);
|
|
|
|
break;
|
2000-12-05 22:51:14 +03:00
|
|
|
case 'L': /* Compatibility only */
|
1994-06-08 23:27:32 +04:00
|
|
|
break;
|
2000-07-05 02:35:04 +04:00
|
|
|
case 'M':
|
|
|
|
minfreeseg = atoi(optarg);
|
|
|
|
break;
|
1994-06-08 23:27:32 +04:00
|
|
|
case 'N':
|
|
|
|
Nflag++;
|
|
|
|
break;
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
case 'O':
|
|
|
|
start = atoi(optarg);
|
|
|
|
break;
|
1994-06-08 23:27:32 +04:00
|
|
|
#ifdef COMPAT
|
|
|
|
case 'T':
|
|
|
|
disktype = optarg;
|
1999-07-15 23:09:40 +04:00
|
|
|
break;
|
|
|
|
#endif
|
2000-12-05 22:51:14 +03:00
|
|
|
case 'b':
|
1994-06-08 23:27:32 +04:00
|
|
|
if ((bsize = atoi(optarg)) < LFS_MINBLOCKSIZE)
|
|
|
|
fatal("%s: bad block size", optarg);
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
if ((fsize = atoi(optarg)) <= 0)
|
|
|
|
fatal("%s: bad frag size", optarg);
|
|
|
|
break;
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
case 'i':
|
|
|
|
if ((ibsize = atoi(optarg)) <= 0)
|
|
|
|
fatal("%s: bad inode block size", optarg);
|
|
|
|
break;
|
1999-07-15 23:09:40 +04:00
|
|
|
case 'm':
|
1994-06-08 23:27:32 +04:00
|
|
|
if ((minfree = atoi(optarg)) < 0 || minfree > 99)
|
|
|
|
fatal("%s: bad free space %%\n", optarg);
|
|
|
|
break;
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
case 'r':
|
|
|
|
if ((roll_id = strtoul(optarg, NULL, 0)) == 0)
|
|
|
|
fatal("%s: bad roll-forward id\n", optarg);
|
|
|
|
break;
|
1999-07-15 23:09:40 +04:00
|
|
|
case 's':
|
1994-06-08 23:27:32 +04:00
|
|
|
if ((fssize = atoi(optarg)) <= 0)
|
|
|
|
fatal("%s: bad file system size", optarg);
|
|
|
|
break;
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
case 'v':
|
|
|
|
version = atoi(optarg);
|
|
|
|
if (version <= 0 || version > LFS_VERSION)
|
|
|
|
fatal("%s: bad version", optarg);
|
|
|
|
break;
|
1994-06-08 23:27:32 +04:00
|
|
|
case '?':
|
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
|
|
|
|
1999-07-15 23:09:40 +04:00
|
|
|
if (argc != 2 && argc != 1)
|
1994-06-08 23:27:32 +04:00
|
|
|
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];
|
1994-09-23 18:26:58 +04:00
|
|
|
if (strchr(special, '/') == NULL) {
|
1998-07-28 23:22:54 +04:00
|
|
|
(void)snprintf(device, sizeof(device), "%sr%s", _PATH_DEV,
|
|
|
|
special);
|
1994-06-08 23:27:32 +04:00
|
|
|
if (stat(device, &st) == -1)
|
1998-07-28 23:22:54 +04:00
|
|
|
(void)snprintf(device, sizeof(device), "%s%s",
|
|
|
|
_PATH_DEV, special);
|
1994-06-08 23:27:32 +04:00
|
|
|
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));
|
|
|
|
|
2000-12-05 22:51:14 +03:00
|
|
|
|
1999-07-15 23:09:40 +04:00
|
|
|
if (!debug && !S_ISCHR(st.st_mode))
|
1994-06-08 23:27:32 +04:00
|
|
|
(void)printf("%s: %s: not a character-special device\n",
|
|
|
|
progname, special);
|
1994-09-23 18:26:58 +04:00
|
|
|
cp = strchr(argv[0], '\0') - 1;
|
1997-08-01 10:18:29 +04:00
|
|
|
if (!debug
|
|
|
|
&& (cp == 0 || ((*cp < 'a' || *cp > ('a' + maxpartitions - 1))
|
|
|
|
&& !isdigit(*cp))))
|
1994-06-08 23:27:32 +04:00
|
|
|
fatal("%s: can't figure out file system partition", argv[0]);
|
|
|
|
|
|
|
|
#ifdef COMPAT
|
1999-07-15 23:09:40 +04:00
|
|
|
if (disktype == NULL)
|
1994-06-08 23:27:32 +04:00
|
|
|
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);
|
|
|
|
|
2000-02-13 02:58:09 +03:00
|
|
|
/* If force, make the partition look like an LFS */
|
|
|
|
if(force) {
|
|
|
|
pp->p_fstype = FS_BSDLFS;
|
|
|
|
/* 0 means to use defaults */
|
|
|
|
pp->p_fsize = 0;
|
|
|
|
pp->p_frag = 0;
|
|
|
|
pp->p_sgs = 0;
|
|
|
|
}
|
|
|
|
|
2000-12-05 22:51:14 +03:00
|
|
|
/* Try autoconfiguring segment size, if asked to */
|
|
|
|
if (segsize == -1)
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
segsize = auto_segsize(fsi, dbtob(pp->p_size), version);
|
2000-12-05 22:51:14 +03:00
|
|
|
|
1994-06-08 23:27:32 +04:00
|
|
|
/* If we're making a LFS, we break out here */
|
2000-07-05 02:35:04 +04:00
|
|
|
exit(make_lfs(fso, lp, pp, minfree, bsize, fsize, segsize,
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
minfreeseg, version, start, ibsize, interleave,
|
|
|
|
roll_id));
|
1994-06-08 23:27:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#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 *
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
getdisklabel(char *s, int fd)
|
1994-06-08 23:27:32 +04:00
|
|
|
{
|
|
|
|
static struct disklabel lab;
|
|
|
|
|
|
|
|
if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
|
|
|
|
#ifdef COMPAT
|
|
|
|
if (disktype) {
|
1997-08-01 10:18:29 +04:00
|
|
|
struct disklabel *lp;
|
1994-06-08 23:27:32 +04:00
|
|
|
|
|
|
|
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 *
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
debug_readlabel(int fd)
|
1994-06-08 23:27:32 +04:00
|
|
|
{
|
|
|
|
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))
|
2000-10-12 01:08:54 +04:00
|
|
|
fatal("short read of disklabel: %d of %ld bytes", n,
|
|
|
|
(u_long) sizeof(struct disklabel));
|
1994-06-08 23:27:32 +04:00
|
|
|
return(&lab);
|
|
|
|
}
|
|
|
|
|
1997-08-01 10:18:29 +04:00
|
|
|
#ifdef notdef
|
1994-06-08 23:27:32 +04:00
|
|
|
static void
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
rewritelabel(char *s, int fd, struct disklabel *lp)
|
1994-06-08 23:27:32 +04:00
|
|
|
{
|
|
|
|
#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);
|
|
|
|
}
|
1998-10-20 05:48:14 +04:00
|
|
|
#if __vax__
|
1994-06-08 23:27:32 +04:00
|
|
|
if (lp->d_type == DTYPE_SMD && lp->d_flags & D_BADSECT) {
|
1997-09-15 15:40:28 +04:00
|
|
|
int i;
|
1994-06-08 23:27:32 +04:00
|
|
|
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));
|
1994-09-23 18:26:58 +04:00
|
|
|
memset(blk, 0, sizeof(blk));
|
1994-06-08 23:27:32 +04:00
|
|
|
*(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) {
|
1997-08-25 23:31:43 +04:00
|
|
|
if (lseek(cfd, (off_t)((alt + i) * lp->d_secsize),
|
|
|
|
SEEK_SET) == -1)
|
1994-06-08 23:27:32 +04:00
|
|
|
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);
|
|
|
|
}
|
1997-08-01 10:18:29 +04:00
|
|
|
#endif /* vax */
|
1994-06-08 23:27:32 +04:00
|
|
|
}
|
1997-08-01 10:18:29 +04:00
|
|
|
#endif /* notdef */
|
1994-06-08 23:27:32 +04:00
|
|
|
|
|
|
|
void
|
|
|
|
usage()
|
|
|
|
{
|
1999-07-15 23:09:40 +04:00
|
|
|
fprintf(stderr, "usage: newfs_lfs [ -fsoptions ] special-device\n");
|
1994-06-08 23:27:32 +04:00
|
|
|
fprintf(stderr, "where fsoptions are:\n");
|
2000-12-05 22:51:14 +03:00
|
|
|
fprintf(stderr, "\t-A (autoconfigure segment size)\n");
|
|
|
|
fprintf(stderr, "\t-B segment size in bytes\n");
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
fprintf(stderr, "\t-D (debug)\n");
|
1994-06-08 23:27:32 +04:00
|
|
|
fprintf(stderr,
|
2000-12-05 22:51:14 +03:00
|
|
|
"\t-N (do not create file system, just print out parameters)\n");
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
fprintf(stderr, "\t-O first segment offset in sectors\n");
|
2000-12-05 22:51:14 +03:00
|
|
|
fprintf(stderr, "\t-b block size in bytes\n");
|
|
|
|
fprintf(stderr, "\t-f frag size in bytes\n");
|
1994-06-08 23:27:32 +04:00
|
|
|
fprintf(stderr, "\t-m minimum free space %%\n");
|
2000-12-05 22:51:14 +03:00
|
|
|
fprintf(stderr, "\t-s file system size in sectors\n");
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
fprintf(stderr, "\t-v version\n");
|
1994-06-08 23:27:32 +04:00
|
|
|
exit(1);
|
|
|
|
}
|