2017-11-20 19:49:47 +00:00
|
|
|
/*-
|
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
2002-06-21 06:18:05 +00:00
|
|
|
* Copyright (c) 2002 Networks Associates Technology, Inc.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* This software was developed for the FreeBSD Project by Marshall
|
|
|
|
* Kirk McKusick and Network Associates Laboratories, the Security
|
|
|
|
* Research Division of Network Associates, Inc. under DARPA/SPAWAR
|
|
|
|
* contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
|
2003-02-14 21:08:14 +00:00
|
|
|
* research program.
|
2002-06-21 06:18:05 +00:00
|
|
|
*
|
1994-05-26 06:35:07 +00:00
|
|
|
* Copyright (c) 1980, 1989, 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.
|
2017-02-28 23:42:47 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-26 06:35:07 +00:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
1998-07-15 06:28:05 +00:00
|
|
|
#if 0
|
2003-05-03 18:41:59 +00:00
|
|
|
#ifndef lint
|
1997-03-11 12:48:17 +00:00
|
|
|
static char sccsid[] = "@(#)mkfs.c 8.11 (Berkeley) 5/3/95";
|
1994-05-26 06:35:07 +00:00
|
|
|
#endif /* not lint */
|
2003-05-03 18:41:59 +00:00
|
|
|
#endif
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2017-11-16 21:28:14 +00:00
|
|
|
#define IN_RTLD /* So we pickup the P_OSREL defines */
|
2011-01-24 06:17:05 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/disklabel.h>
|
|
|
|
#include <sys/file.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/resource.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/wait.h>
|
1998-07-15 06:28:05 +00:00
|
|
|
#include <err.h>
|
2003-11-04 07:34:32 +00:00
|
|
|
#include <grp.h>
|
2002-09-25 04:06:37 +00:00
|
|
|
#include <limits.h>
|
1998-07-15 06:28:05 +00:00
|
|
|
#include <signal.h>
|
2002-03-19 16:47:20 +00:00
|
|
|
#include <stdlib.h>
|
1998-07-15 06:28:05 +00:00
|
|
|
#include <string.h>
|
2002-07-11 17:49:41 +00:00
|
|
|
#include <stdint.h>
|
1998-07-15 06:28:05 +00:00
|
|
|
#include <stdio.h>
|
2011-01-24 06:17:05 +00:00
|
|
|
#include <time.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <ufs/ufs/dinode.h>
|
|
|
|
#include <ufs/ufs/dir.h>
|
|
|
|
#include <ufs/ffs/fs.h>
|
2002-03-19 20:01:38 +00:00
|
|
|
#include "newfs.h"
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* make file system for cylinder-group style file systems
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
|
|
|
#define UMASK 0755
|
|
|
|
#define POWEROF2(num) (((num) & ((num) - 1)) == 0)
|
|
|
|
|
2002-03-19 20:01:38 +00:00
|
|
|
static struct csum *fscs;
|
2003-02-11 03:06:45 +00:00
|
|
|
#define sblock disk.d_fs
|
|
|
|
#define acg disk.d_cg
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode {
|
|
|
|
struct ufs1_dinode dp1;
|
|
|
|
struct ufs2_dinode dp2;
|
|
|
|
};
|
|
|
|
#define DIP(dp, field) \
|
|
|
|
((sblock.fs_magic == FS_UFS1_MAGIC) ? \
|
|
|
|
(dp)->dp1.field : (dp)->dp2.field)
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2002-06-21 06:18:05 +00:00
|
|
|
static caddr_t iobuf;
|
|
|
|
static long iobufsize;
|
|
|
|
static ufs2_daddr_t alloc(int size, int mode);
|
2002-03-19 20:01:38 +00:00
|
|
|
static int charsperline(void);
|
2002-04-04 09:45:11 +00:00
|
|
|
static void clrblock(struct fs *, unsigned char *, int);
|
|
|
|
static void fsinit(time_t);
|
2002-03-19 17:39:01 +00:00
|
|
|
static int ilog2(int);
|
2002-04-04 09:45:11 +00:00
|
|
|
static void initcg(int, time_t);
|
|
|
|
static int isblock(struct fs *, unsigned char *, int);
|
2002-06-21 06:18:05 +00:00
|
|
|
static void iput(union dinode *, ino_t);
|
2002-04-04 09:45:11 +00:00
|
|
|
static int makedir(struct direct *, int);
|
|
|
|
static void setblock(struct fs *, unsigned char *, int);
|
2002-06-21 06:18:05 +00:00
|
|
|
static void wtfs(ufs2_daddr_t, int, char *);
|
2003-02-22 23:26:11 +00:00
|
|
|
static u_int32_t newfs_random(void);
|
1994-05-26 06:35:07 +00:00
|
|
|
|
1998-07-15 06:28:05 +00:00
|
|
|
void
|
2002-04-24 11:44:02 +00:00
|
|
|
mkfs(struct partition *pp, char *fsys)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-06-21 06:18:05 +00:00
|
|
|
int fragsperinode, optimalfpg, origdensity, minfpg, lastminfpg;
|
2010-02-11 18:14:53 +00:00
|
|
|
long i, j, csfrags;
|
|
|
|
uint cg;
|
1994-05-26 06:35:07 +00:00
|
|
|
time_t utime;
|
|
|
|
quad_t sizepb;
|
1996-01-30 23:14:34 +00:00
|
|
|
int width;
|
2010-02-10 20:17:46 +00:00
|
|
|
ino_t maxinum;
|
|
|
|
int minfragsperinode; /* minimum ratio of frags to inodes */
|
1996-01-30 23:14:34 +00:00
|
|
|
char tmpbuf[100]; /* XXX this will break in about 2,500 years */
|
2017-09-04 20:19:36 +00:00
|
|
|
struct fsrecovery *fsr;
|
|
|
|
char *fsrbuf;
|
2003-05-22 18:38:54 +00:00
|
|
|
union {
|
|
|
|
struct fs fdummy;
|
|
|
|
char cdummy[SBLOCKSIZE];
|
|
|
|
} dummy;
|
|
|
|
#define fsdummy dummy.fdummy
|
|
|
|
#define chdummy dummy.cdummy
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2003-02-11 03:06:45 +00:00
|
|
|
/*
|
|
|
|
* Our blocks == sector size, and the version of UFS we are using is
|
|
|
|
* specified by Oflag.
|
|
|
|
*/
|
|
|
|
disk.d_bsize = sectorsize;
|
|
|
|
disk.d_ufs = Oflag;
|
2013-10-29 17:34:15 +00:00
|
|
|
if (Rflag)
|
2002-03-19 21:05:29 +00:00
|
|
|
utime = 1000000000;
|
2013-10-29 17:34:15 +00:00
|
|
|
else
|
2002-03-19 21:05:29 +00:00
|
|
|
time(&utime);
|
2020-06-19 01:02:53 +00:00
|
|
|
if ((sblock.fs_si = malloc(sizeof(struct fs_summary_info))) == NULL) {
|
|
|
|
printf("Superblock summary info allocation failed.\n");
|
|
|
|
exit(18);
|
|
|
|
}
|
2002-11-27 02:18:58 +00:00
|
|
|
sblock.fs_old_flags = FS_FLAGS_UPDATED;
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_flags = 0;
|
2001-04-03 09:35:36 +00:00
|
|
|
if (Uflag)
|
2001-04-02 01:25:55 +00:00
|
|
|
sblock.fs_flags |= FS_DOSOFTDEP;
|
2003-02-01 04:17:10 +00:00
|
|
|
if (Lflag)
|
|
|
|
strlcpy(sblock.fs_volname, volumelabel, MAXVOLLEN);
|
2006-10-31 21:52:28 +00:00
|
|
|
if (Jflag)
|
|
|
|
sblock.fs_flags |= FS_GJOURNAL;
|
2004-02-26 01:14:27 +00:00
|
|
|
if (lflag)
|
|
|
|
sblock.fs_flags |= FS_MULTILABEL;
|
2010-12-29 12:31:18 +00:00
|
|
|
if (tflag)
|
|
|
|
sblock.fs_flags |= FS_TRIM;
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* Validate the given file system size.
|
1994-05-26 06:35:07 +00:00
|
|
|
* Verify that its last block can actually be accessed.
|
2002-08-21 18:11:48 +00:00
|
|
|
* Convert to file system fragment sized units.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
2002-06-21 06:18:05 +00:00
|
|
|
if (fssize <= 0) {
|
2002-07-11 17:49:41 +00:00
|
|
|
printf("preposterous size %jd\n", (intmax_t)fssize);
|
2002-06-21 06:18:05 +00:00
|
|
|
exit(13);
|
|
|
|
}
|
1996-12-01 11:25:38 +00:00
|
|
|
wtfs(fssize - (realsectorsize / DEV_BSIZE), realsectorsize,
|
2002-03-18 02:43:14 +00:00
|
|
|
(char *)&sblock);
|
Directory layout preference improvements from Grigoriy Orlov <gluk@ptci.ru>.
His description of the problem and solution follow. My own tests show
speedups on typical filesystem intensive workloads of 5% to 12% which
is very impressive considering the small amount of code change involved.
------
One day I noticed that some file operations run much faster on
small file systems then on big ones. I've looked at the ffs
algorithms, thought about them, and redesigned the dirpref algorithm.
First I want to describe the results of my tests. These results are old
and I have improved the algorithm after these tests were done. Nevertheless
they show how big the perfomance speedup may be. I have done two file/directory
intensive tests on a two OpenBSD systems with old and new dirpref algorithm.
The first test is "tar -xzf ports.tar.gz", the second is "rm -rf ports".
The ports.tar.gz file is the ports collection from the OpenBSD 2.8 release.
It contains 6596 directories and 13868 files. The test systems are:
1. Celeron-450, 128Mb, two IDE drives, the system at wd0, file system for
test is at wd1. Size of test file system is 8 Gb, number of cg=991,
size of cg is 8m, block size = 8k, fragment size = 1k OpenBSD-current
from Dec 2000 with BUFCACHEPERCENT=35
2. PIII-600, 128Mb, two IBM DTLA-307045 IDE drives at i815e, the system
at wd0, file system for test is at wd1. Size of test file system is 40 Gb,
number of cg=5324, size of cg is 8m, block size = 8k, fragment size = 1k
OpenBSD-current from Dec 2000 with BUFCACHEPERCENT=50
You can get more info about the test systems and methods at:
http://www.ptci.ru/gluk/dirpref/old/dirpref.html
Test Results
tar -xzf ports.tar.gz rm -rf ports
mode old dirpref new dirpref speedup old dirprefnew dirpref speedup
First system
normal 667 472 1.41 477 331 1.44
async 285 144 1.98 130 14 9.29
sync 768 616 1.25 477 334 1.43
softdep 413 252 1.64 241 38 6.34
Second system
normal 329 81 4.06 263.5 93.5 2.81
async 302 25.7 11.75 112 2.26 49.56
sync 281 57.0 4.93 263 90.5 2.9
softdep 341 40.6 8.4 284 4.76 59.66
"old dirpref" and "new dirpref" columns give a test time in seconds.
speedup - speed increasement in times, ie. old dirpref / new dirpref.
------
Algorithm description
The old dirpref algorithm is described in comments:
/*
* Find a cylinder to place a directory.
*
* The policy implemented by this algorithm is to select from
* among those cylinder groups with above the average number of
* free inodes, the one with the smallest number of directories.
*/
A new directory is allocated in a different cylinder groups than its
parent directory resulting in a directory tree that is spreaded across
all the cylinder groups. This spreading out results in a non-optimal
access to the directories and files. When we have a small filesystem
it is not a problem but when the filesystem is big then perfomance
degradation becomes very apparent.
What I mean by a big file system ?
1. A big filesystem is a filesystem which occupy 20-30 or more percent
of total drive space, i.e. first and last cylinder are physically
located relatively far from each other.
2. It has a relatively large number of cylinder groups, for example
more cylinder groups than 50% of the buffers in the buffer cache.
The first results in long access times, while the second results in
many buffers being used by metadata operations. Such operations use
cylinder group blocks and on-disk inode blocks. The cylinder group
block (fs->fs_cblkno) contains struct cg, inode and block bit maps.
It is 2k in size for the default filesystem parameters. If new and
parent directories are located in different cylinder groups then the
system performs more input/output operations and uses more buffers.
On filesystems with many cylinder groups, lots of cache buffers are
used for metadata operations.
My solution for this problem is very simple. I allocate many directories
in one cylinder group. I also do some things, so that the new allocation
method does not cause excessive fragmentation and all directory inodes
will not be located at a location far from its file's inodes and data.
The algorithm is:
/*
* Find a cylinder group to place a directory.
*
* The policy implemented by this algorithm is to allocate a
* directory inode in the same cylinder group as its parent
* directory, but also to reserve space for its files inodes
* and data. Restrict the number of directories which may be
* allocated one after another in the same cylinder group
* without intervening allocation of files.
*
* If we allocate a first level directory then force allocation
* in another cylinder group.
*/
My early versions of dirpref give me a good results for a wide range of
file operations and different filesystem capacities except one case:
those applications that create their entire directory structure first
and only later fill this structure with files.
My solution for such and similar cases is to limit a number of
directories which may be created one after another in the same cylinder
group without intervening file creations. For this purpose, I allocate
an array of counters at mount time. This array is linked to the superblock
fs->fs_contigdirs[cg]. Each time a directory is created the counter
increases and each time a file is created the counter decreases. A 60Gb
filesystem with 8mb/cg requires 10kb of memory for the counters array.
The maxcontigdirs is a maximum number of directories which may be created
without an intervening file creation. I found in my tests that the best
performance occurs when I restrict the number of directories in one cylinder
group such that all its files may be located in the same cylinder group.
There may be some deterioration in performance if all the file inodes
are in the same cylinder group as its containing directory, but their
data partially resides in a different cylinder group. The maxcontigdirs
value is calculated to try to prevent this condition. Since there is
no way to know how many files and directories will be allocated later
I added two optimization parameters in superblock/tunefs. They are:
int32_t fs_avgfilesize; /* expected average file size */
int32_t fs_avgfpdir; /* expected # of files per directory */
These parameters have reasonable defaults but may be tweeked for special
uses of a filesystem. They are only necessary in rare cases like better
tuning a filesystem being used to store a squid cache.
I have been using this algorithm for about 3 months. I have done
a lot of testing on filesystems with different capacities, average
filesize, average number of files per directory, and so on. I think
this algorithm has no negative impact on filesystem perfomance. It
works better than the default one in all cases. The new dirpref
will greatly improve untarring/removing/coping of big directories,
decrease load on cvs servers and much more. The new dirpref doesn't
speedup a compilation process, but also doesn't slow it down.
Obtained from: Grigoriy Orlov <gluk@ptci.ru>
2001-04-10 08:38:59 +00:00
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* collect and verify the file system density info
|
Directory layout preference improvements from Grigoriy Orlov <gluk@ptci.ru>.
His description of the problem and solution follow. My own tests show
speedups on typical filesystem intensive workloads of 5% to 12% which
is very impressive considering the small amount of code change involved.
------
One day I noticed that some file operations run much faster on
small file systems then on big ones. I've looked at the ffs
algorithms, thought about them, and redesigned the dirpref algorithm.
First I want to describe the results of my tests. These results are old
and I have improved the algorithm after these tests were done. Nevertheless
they show how big the perfomance speedup may be. I have done two file/directory
intensive tests on a two OpenBSD systems with old and new dirpref algorithm.
The first test is "tar -xzf ports.tar.gz", the second is "rm -rf ports".
The ports.tar.gz file is the ports collection from the OpenBSD 2.8 release.
It contains 6596 directories and 13868 files. The test systems are:
1. Celeron-450, 128Mb, two IDE drives, the system at wd0, file system for
test is at wd1. Size of test file system is 8 Gb, number of cg=991,
size of cg is 8m, block size = 8k, fragment size = 1k OpenBSD-current
from Dec 2000 with BUFCACHEPERCENT=35
2. PIII-600, 128Mb, two IBM DTLA-307045 IDE drives at i815e, the system
at wd0, file system for test is at wd1. Size of test file system is 40 Gb,
number of cg=5324, size of cg is 8m, block size = 8k, fragment size = 1k
OpenBSD-current from Dec 2000 with BUFCACHEPERCENT=50
You can get more info about the test systems and methods at:
http://www.ptci.ru/gluk/dirpref/old/dirpref.html
Test Results
tar -xzf ports.tar.gz rm -rf ports
mode old dirpref new dirpref speedup old dirprefnew dirpref speedup
First system
normal 667 472 1.41 477 331 1.44
async 285 144 1.98 130 14 9.29
sync 768 616 1.25 477 334 1.43
softdep 413 252 1.64 241 38 6.34
Second system
normal 329 81 4.06 263.5 93.5 2.81
async 302 25.7 11.75 112 2.26 49.56
sync 281 57.0 4.93 263 90.5 2.9
softdep 341 40.6 8.4 284 4.76 59.66
"old dirpref" and "new dirpref" columns give a test time in seconds.
speedup - speed increasement in times, ie. old dirpref / new dirpref.
------
Algorithm description
The old dirpref algorithm is described in comments:
/*
* Find a cylinder to place a directory.
*
* The policy implemented by this algorithm is to select from
* among those cylinder groups with above the average number of
* free inodes, the one with the smallest number of directories.
*/
A new directory is allocated in a different cylinder groups than its
parent directory resulting in a directory tree that is spreaded across
all the cylinder groups. This spreading out results in a non-optimal
access to the directories and files. When we have a small filesystem
it is not a problem but when the filesystem is big then perfomance
degradation becomes very apparent.
What I mean by a big file system ?
1. A big filesystem is a filesystem which occupy 20-30 or more percent
of total drive space, i.e. first and last cylinder are physically
located relatively far from each other.
2. It has a relatively large number of cylinder groups, for example
more cylinder groups than 50% of the buffers in the buffer cache.
The first results in long access times, while the second results in
many buffers being used by metadata operations. Such operations use
cylinder group blocks and on-disk inode blocks. The cylinder group
block (fs->fs_cblkno) contains struct cg, inode and block bit maps.
It is 2k in size for the default filesystem parameters. If new and
parent directories are located in different cylinder groups then the
system performs more input/output operations and uses more buffers.
On filesystems with many cylinder groups, lots of cache buffers are
used for metadata operations.
My solution for this problem is very simple. I allocate many directories
in one cylinder group. I also do some things, so that the new allocation
method does not cause excessive fragmentation and all directory inodes
will not be located at a location far from its file's inodes and data.
The algorithm is:
/*
* Find a cylinder group to place a directory.
*
* The policy implemented by this algorithm is to allocate a
* directory inode in the same cylinder group as its parent
* directory, but also to reserve space for its files inodes
* and data. Restrict the number of directories which may be
* allocated one after another in the same cylinder group
* without intervening allocation of files.
*
* If we allocate a first level directory then force allocation
* in another cylinder group.
*/
My early versions of dirpref give me a good results for a wide range of
file operations and different filesystem capacities except one case:
those applications that create their entire directory structure first
and only later fill this structure with files.
My solution for such and similar cases is to limit a number of
directories which may be created one after another in the same cylinder
group without intervening file creations. For this purpose, I allocate
an array of counters at mount time. This array is linked to the superblock
fs->fs_contigdirs[cg]. Each time a directory is created the counter
increases and each time a file is created the counter decreases. A 60Gb
filesystem with 8mb/cg requires 10kb of memory for the counters array.
The maxcontigdirs is a maximum number of directories which may be created
without an intervening file creation. I found in my tests that the best
performance occurs when I restrict the number of directories in one cylinder
group such that all its files may be located in the same cylinder group.
There may be some deterioration in performance if all the file inodes
are in the same cylinder group as its containing directory, but their
data partially resides in a different cylinder group. The maxcontigdirs
value is calculated to try to prevent this condition. Since there is
no way to know how many files and directories will be allocated later
I added two optimization parameters in superblock/tunefs. They are:
int32_t fs_avgfilesize; /* expected average file size */
int32_t fs_avgfpdir; /* expected # of files per directory */
These parameters have reasonable defaults but may be tweeked for special
uses of a filesystem. They are only necessary in rare cases like better
tuning a filesystem being used to store a squid cache.
I have been using this algorithm for about 3 months. I have done
a lot of testing on filesystems with different capacities, average
filesize, average number of files per directory, and so on. I think
this algorithm has no negative impact on filesystem perfomance. It
works better than the default one in all cases. The new dirpref
will greatly improve untarring/removing/coping of big directories,
decrease load on cvs servers and much more. The new dirpref doesn't
speedup a compilation process, but also doesn't slow it down.
Obtained from: Grigoriy Orlov <gluk@ptci.ru>
2001-04-10 08:38:59 +00:00
|
|
|
*/
|
|
|
|
sblock.fs_avgfilesize = avgfilesize;
|
|
|
|
sblock.fs_avgfpdir = avgfilesperdir;
|
|
|
|
if (sblock.fs_avgfilesize <= 0)
|
|
|
|
printf("illegal expected average file size %d\n",
|
|
|
|
sblock.fs_avgfilesize), exit(14);
|
|
|
|
if (sblock.fs_avgfpdir <= 0)
|
|
|
|
printf("illegal expected number of files per directory %d\n",
|
|
|
|
sblock.fs_avgfpdir), exit(15);
|
2010-02-10 20:17:46 +00:00
|
|
|
|
|
|
|
restart:
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* collect and verify the block and fragment sizes
|
|
|
|
*/
|
|
|
|
sblock.fs_bsize = bsize;
|
|
|
|
sblock.fs_fsize = fsize;
|
|
|
|
if (!POWEROF2(sblock.fs_bsize)) {
|
|
|
|
printf("block size must be a power of 2, not %d\n",
|
|
|
|
sblock.fs_bsize);
|
|
|
|
exit(16);
|
|
|
|
}
|
|
|
|
if (!POWEROF2(sblock.fs_fsize)) {
|
|
|
|
printf("fragment size must be a power of 2, not %d\n",
|
|
|
|
sblock.fs_fsize);
|
|
|
|
exit(17);
|
|
|
|
}
|
|
|
|
if (sblock.fs_fsize < sectorsize) {
|
2010-03-09 19:31:08 +00:00
|
|
|
printf("increasing fragment size from %d to sector size (%d)\n",
|
|
|
|
sblock.fs_fsize, sectorsize);
|
2002-04-03 20:48:05 +00:00
|
|
|
sblock.fs_fsize = sectorsize;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2002-11-30 18:28:26 +00:00
|
|
|
if (sblock.fs_bsize > MAXBSIZE) {
|
|
|
|
printf("decreasing block size from %d to maximum (%d)\n",
|
|
|
|
sblock.fs_bsize, MAXBSIZE);
|
|
|
|
sblock.fs_bsize = MAXBSIZE;
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
if (sblock.fs_bsize < MINBSIZE) {
|
2002-04-03 20:48:05 +00:00
|
|
|
printf("increasing block size from %d to minimum (%d)\n",
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_bsize, MINBSIZE);
|
2002-04-03 20:48:05 +00:00
|
|
|
sblock.fs_bsize = MINBSIZE;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2002-11-30 18:28:26 +00:00
|
|
|
if (sblock.fs_fsize > MAXBSIZE) {
|
|
|
|
printf("decreasing fragment size from %d to maximum (%d)\n",
|
|
|
|
sblock.fs_fsize, MAXBSIZE);
|
|
|
|
sblock.fs_fsize = MAXBSIZE;
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
if (sblock.fs_bsize < sblock.fs_fsize) {
|
2002-04-04 09:45:11 +00:00
|
|
|
printf("increasing block size from %d to fragment size (%d)\n",
|
2002-03-18 02:43:14 +00:00
|
|
|
sblock.fs_bsize, sblock.fs_fsize);
|
2002-04-03 20:48:05 +00:00
|
|
|
sblock.fs_bsize = sblock.fs_fsize;
|
|
|
|
}
|
|
|
|
if (sblock.fs_fsize * MAXFRAG < sblock.fs_bsize) {
|
2002-04-04 09:45:11 +00:00
|
|
|
printf(
|
|
|
|
"increasing fragment size from %d to block size / %d (%d)\n",
|
2002-04-03 20:48:05 +00:00
|
|
|
sblock.fs_fsize, MAXFRAG, sblock.fs_bsize / MAXFRAG);
|
|
|
|
sblock.fs_fsize = sblock.fs_bsize / MAXFRAG;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2010-02-10 20:17:46 +00:00
|
|
|
if (maxbsize == 0)
|
|
|
|
maxbsize = bsize;
|
2002-06-21 06:18:05 +00:00
|
|
|
if (maxbsize < bsize || !POWEROF2(maxbsize)) {
|
|
|
|
sblock.fs_maxbsize = sblock.fs_bsize;
|
|
|
|
printf("Extent size set to %d\n", sblock.fs_maxbsize);
|
2022-03-08 13:52:17 +00:00
|
|
|
} else if (maxbsize > FS_MAXCONTIG * sblock.fs_bsize) {
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_maxbsize = FS_MAXCONTIG * sblock.fs_bsize;
|
|
|
|
printf("Extent size reduced to %d\n", sblock.fs_maxbsize);
|
|
|
|
} else {
|
|
|
|
sblock.fs_maxbsize = maxbsize;
|
|
|
|
}
|
2010-02-10 20:17:46 +00:00
|
|
|
/*
|
|
|
|
* Maxcontig sets the default for the maximum number of blocks
|
|
|
|
* that may be allocated sequentially. With file system clustering
|
|
|
|
* it is possible to allocate contiguous blocks up to the maximum
|
|
|
|
* transfer size permitted by the controller or buffering.
|
|
|
|
*/
|
|
|
|
if (maxcontig == 0)
|
|
|
|
maxcontig = MAX(1, MAXPHYS / bsize);
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_maxcontig = maxcontig;
|
|
|
|
if (sblock.fs_maxcontig < sblock.fs_maxbsize / sblock.fs_bsize) {
|
|
|
|
sblock.fs_maxcontig = sblock.fs_maxbsize / sblock.fs_bsize;
|
|
|
|
printf("Maxcontig raised to %d\n", sblock.fs_maxbsize);
|
|
|
|
}
|
|
|
|
if (sblock.fs_maxcontig > 1)
|
|
|
|
sblock.fs_contigsumsize = MIN(sblock.fs_maxcontig,FS_MAXCONTIG);
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_bmask = ~(sblock.fs_bsize - 1);
|
|
|
|
sblock.fs_fmask = ~(sblock.fs_fsize - 1);
|
|
|
|
sblock.fs_qbmask = ~sblock.fs_bmask;
|
|
|
|
sblock.fs_qfmask = ~sblock.fs_fmask;
|
2002-03-19 17:39:01 +00:00
|
|
|
sblock.fs_bshift = ilog2(sblock.fs_bsize);
|
|
|
|
sblock.fs_fshift = ilog2(sblock.fs_fsize);
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
|
2002-03-19 17:39:01 +00:00
|
|
|
sblock.fs_fragshift = ilog2(sblock.fs_frag);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (sblock.fs_frag > MAXFRAG) {
|
2002-04-04 09:45:11 +00:00
|
|
|
printf("fragment size %d is still too small (can't happen)\n",
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_bsize / MAXFRAG);
|
|
|
|
exit(21);
|
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_fsbtodb = ilog2(sblock.fs_fsize / sectorsize);
|
|
|
|
sblock.fs_size = fssize = dbtofsb(&sblock, fssize);
|
2012-10-30 21:32:10 +00:00
|
|
|
sblock.fs_providersize = dbtofsb(&sblock, mediasize / sectorsize);
|
2004-08-19 11:09:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Before the filesystem is finally initialized, mark it
|
|
|
|
* as incompletely initialized.
|
|
|
|
*/
|
|
|
|
sblock.fs_magic = FS_BAD_MAGIC;
|
|
|
|
|
2002-06-21 06:18:05 +00:00
|
|
|
if (Oflag == 1) {
|
2002-11-27 02:18:58 +00:00
|
|
|
sblock.fs_sblockloc = SBLOCK_UFS1;
|
2018-01-26 00:58:32 +00:00
|
|
|
sblock.fs_sblockactualloc = SBLOCK_UFS1;
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs1_daddr_t);
|
|
|
|
sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);
|
2017-02-15 19:50:26 +00:00
|
|
|
sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *
|
2002-06-21 06:18:05 +00:00
|
|
|
sizeof(ufs1_daddr_t));
|
|
|
|
sblock.fs_old_inodefmt = FS_44INODEFMT;
|
|
|
|
sblock.fs_old_cgoffset = 0;
|
|
|
|
sblock.fs_old_cgmask = 0xffffffff;
|
|
|
|
sblock.fs_old_size = sblock.fs_size;
|
|
|
|
sblock.fs_old_rotdelay = 0;
|
|
|
|
sblock.fs_old_rps = 60;
|
|
|
|
sblock.fs_old_nspf = sblock.fs_fsize / sectorsize;
|
|
|
|
sblock.fs_old_cpg = 1;
|
|
|
|
sblock.fs_old_interleave = 1;
|
|
|
|
sblock.fs_old_trackskew = 0;
|
|
|
|
sblock.fs_old_cpc = 0;
|
|
|
|
sblock.fs_old_postblformat = 1;
|
|
|
|
sblock.fs_old_nrpos = 1;
|
|
|
|
} else {
|
2002-11-27 02:18:58 +00:00
|
|
|
sblock.fs_sblockloc = SBLOCK_UFS2;
|
2018-01-26 00:58:32 +00:00
|
|
|
sblock.fs_sblockactualloc = SBLOCK_UFS2;
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_nindir = sblock.fs_bsize / sizeof(ufs2_daddr_t);
|
|
|
|
sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode);
|
2017-02-15 19:50:26 +00:00
|
|
|
sblock.fs_maxsymlinklen = ((UFS_NDADDR + UFS_NIADDR) *
|
2002-06-21 06:18:05 +00:00
|
|
|
sizeof(ufs2_daddr_t));
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_sblkno =
|
2002-11-27 02:18:58 +00:00
|
|
|
roundup(howmany(sblock.fs_sblockloc + SBLOCKSIZE, sblock.fs_fsize),
|
|
|
|
sblock.fs_frag);
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_cblkno = sblock.fs_sblkno +
|
|
|
|
roundup(howmany(SBLOCKSIZE, sblock.fs_fsize), sblock.fs_frag);
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
|
2017-02-15 19:50:26 +00:00
|
|
|
sblock.fs_maxfilesize = sblock.fs_bsize * UFS_NDADDR - 1;
|
|
|
|
for (sizepb = sblock.fs_bsize, i = 0; i < UFS_NIADDR; i++) {
|
1994-05-26 06:35:07 +00:00
|
|
|
sizepb *= NINDIR(&sblock);
|
|
|
|
sblock.fs_maxfilesize += sizepb;
|
|
|
|
}
|
2005-02-20 06:33:18 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It's impossible to create a snapshot in case that fs_maxfilesize
|
|
|
|
* is smaller than the fssize.
|
|
|
|
*/
|
|
|
|
if (sblock.fs_maxfilesize < (u_quad_t)fssize) {
|
|
|
|
warnx("WARNING: You will be unable to create snapshots on this "
|
|
|
|
"file system. Correct by using a larger blocksize.");
|
|
|
|
}
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
2002-06-21 06:18:05 +00:00
|
|
|
* Calculate the number of blocks to put into each cylinder group.
|
|
|
|
*
|
|
|
|
* This algorithm selects the number of blocks per cylinder
|
|
|
|
* group. The first goal is to have at least enough data blocks
|
|
|
|
* in each cylinder group to meet the density requirement. Once
|
|
|
|
* this goal is achieved we try to expand to have at least
|
|
|
|
* MINCYLGRPS cylinder groups. Once this goal is achieved, we
|
|
|
|
* pack as many blocks into each cylinder group map as will fit.
|
|
|
|
*
|
|
|
|
* We start by calculating the smallest number of blocks that we
|
|
|
|
* can put into each cylinder group. If this is too big, we reduce
|
|
|
|
* the density until it fits.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
2010-02-10 20:17:46 +00:00
|
|
|
maxinum = (((int64_t)(1)) << 32) - INOPB(&sblock);
|
|
|
|
minfragsperinode = 1 + fssize / maxinum;
|
|
|
|
if (density == 0) {
|
|
|
|
density = MAX(NFPI, minfragsperinode) * fsize;
|
|
|
|
} else if (density < minfragsperinode * fsize) {
|
|
|
|
origdensity = density;
|
|
|
|
density = minfragsperinode * fsize;
|
2010-03-09 19:31:08 +00:00
|
|
|
fprintf(stderr, "density increased from %d to %d\n",
|
|
|
|
origdensity, density);
|
2010-02-10 20:17:46 +00:00
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
origdensity = density;
|
|
|
|
for (;;) {
|
2002-11-30 18:28:26 +00:00
|
|
|
fragsperinode = MAX(numfrags(&sblock, density), 1);
|
2010-02-10 20:17:46 +00:00
|
|
|
if (fragsperinode < minfragsperinode) {
|
|
|
|
bsize <<= 1;
|
|
|
|
fsize <<= 1;
|
2010-03-09 19:31:08 +00:00
|
|
|
printf("Block size too small for a file system %s %d\n",
|
|
|
|
"of this size. Increasing blocksize to", bsize);
|
2010-02-10 20:17:46 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
minfpg = fragsperinode * INOPB(&sblock);
|
|
|
|
if (minfpg > sblock.fs_size)
|
|
|
|
minfpg = sblock.fs_size;
|
|
|
|
sblock.fs_ipg = INOPB(&sblock);
|
|
|
|
sblock.fs_fpg = roundup(sblock.fs_iblkno +
|
|
|
|
sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);
|
|
|
|
if (sblock.fs_fpg < minfpg)
|
|
|
|
sblock.fs_fpg = minfpg;
|
|
|
|
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
|
|
|
|
INOPB(&sblock));
|
|
|
|
sblock.fs_fpg = roundup(sblock.fs_iblkno +
|
|
|
|
sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);
|
|
|
|
if (sblock.fs_fpg < minfpg)
|
|
|
|
sblock.fs_fpg = minfpg;
|
|
|
|
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
|
|
|
|
INOPB(&sblock));
|
|
|
|
if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize)
|
|
|
|
break;
|
|
|
|
density -= sblock.fs_fsize;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
if (density != origdensity)
|
2010-03-09 19:31:08 +00:00
|
|
|
printf("density reduced from %d to %d\n", origdensity, density);
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
2002-06-21 06:18:05 +00:00
|
|
|
* Start packing more blocks into the cylinder group until
|
|
|
|
* it cannot grow any larger, the number of cylinder groups
|
|
|
|
* drops below MINCYLGRPS, or we reach the size requested.
|
2010-09-24 19:08:56 +00:00
|
|
|
* For UFS1 inodes per cylinder group are stored in an int16_t
|
|
|
|
* so fs_ipg is limited to 2^15 - 1.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
2002-06-21 06:18:05 +00:00
|
|
|
for ( ; sblock.fs_fpg < maxblkspercg; sblock.fs_fpg += sblock.fs_frag) {
|
|
|
|
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
|
|
|
|
INOPB(&sblock));
|
2010-09-24 19:08:56 +00:00
|
|
|
if (Oflag > 1 || (Oflag == 1 && sblock.fs_ipg <= 0x7fff)) {
|
|
|
|
if (sblock.fs_size / sblock.fs_fpg < MINCYLGRPS)
|
|
|
|
break;
|
|
|
|
if (CGSIZE(&sblock) < (unsigned long)sblock.fs_bsize)
|
|
|
|
continue;
|
|
|
|
if (CGSIZE(&sblock) == (unsigned long)sblock.fs_bsize)
|
|
|
|
break;
|
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_fpg -= sblock.fs_frag;
|
|
|
|
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
|
|
|
|
INOPB(&sblock));
|
|
|
|
break;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
1995-05-30 06:12:45 +00:00
|
|
|
/*
|
2002-06-21 06:18:05 +00:00
|
|
|
* Check to be sure that the last cylinder group has enough blocks
|
|
|
|
* to be viable. If it is too small, reduce the number of blocks
|
|
|
|
* per cylinder group which will have the effect of moving more
|
|
|
|
* blocks into the last cylinder group.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
2002-06-21 06:18:05 +00:00
|
|
|
optimalfpg = sblock.fs_fpg;
|
|
|
|
for (;;) {
|
|
|
|
sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);
|
|
|
|
lastminfpg = roundup(sblock.fs_iblkno +
|
|
|
|
sblock.fs_ipg / INOPF(&sblock), sblock.fs_frag);
|
|
|
|
if (sblock.fs_size < lastminfpg) {
|
2002-07-11 17:49:41 +00:00
|
|
|
printf("Filesystem size %jd < minimum size of %d\n",
|
|
|
|
(intmax_t)sblock.fs_size, lastminfpg);
|
2002-06-21 06:18:05 +00:00
|
|
|
exit(28);
|
|
|
|
}
|
|
|
|
if (sblock.fs_size % sblock.fs_fpg >= lastminfpg ||
|
|
|
|
sblock.fs_size % sblock.fs_fpg == 0)
|
|
|
|
break;
|
|
|
|
sblock.fs_fpg -= sblock.fs_frag;
|
|
|
|
sblock.fs_ipg = roundup(howmany(sblock.fs_fpg, fragsperinode),
|
|
|
|
INOPB(&sblock));
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
if (optimalfpg != sblock.fs_fpg)
|
|
|
|
printf("Reduced frags per cylinder group from %d to %d %s\n",
|
|
|
|
optimalfpg, sblock.fs_fpg, "to enlarge last cyl group");
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));
|
|
|
|
sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
|
2002-06-21 06:18:05 +00:00
|
|
|
if (Oflag == 1) {
|
|
|
|
sblock.fs_old_spc = sblock.fs_fpg * sblock.fs_old_nspf;
|
|
|
|
sblock.fs_old_nsect = sblock.fs_old_spc;
|
|
|
|
sblock.fs_old_npsect = sblock.fs_old_spc;
|
|
|
|
sblock.fs_old_ncyl = sblock.fs_ncg;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* fill in remaining fields of the super block
|
|
|
|
*/
|
|
|
|
sblock.fs_csaddr = cgdmin(&sblock, 0);
|
|
|
|
sblock.fs_cssize =
|
|
|
|
fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
|
|
|
|
fscs = (struct csum *)calloc(1, sblock.fs_cssize);
|
1998-07-15 06:28:05 +00:00
|
|
|
if (fscs == NULL)
|
|
|
|
errx(31, "calloc failed");
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_sbsize = fragroundup(&sblock, sizeof(struct fs));
|
2002-10-18 23:17:30 +00:00
|
|
|
if (sblock.fs_sbsize > SBLOCKSIZE)
|
|
|
|
sblock.fs_sbsize = SBLOCKSIZE;
|
2017-09-04 20:19:36 +00:00
|
|
|
if (sblock.fs_sbsize < realsectorsize)
|
|
|
|
sblock.fs_sbsize = realsectorsize;
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_minfree = minfree;
|
2013-03-22 21:45:28 +00:00
|
|
|
if (metaspace > 0 && metaspace < sblock.fs_fpg / 2)
|
|
|
|
sblock.fs_metaspace = blknum(&sblock, metaspace);
|
|
|
|
else if (metaspace != -1)
|
|
|
|
/* reserve half of minfree for metadata blocks */
|
|
|
|
sblock.fs_metaspace = blknum(&sblock,
|
|
|
|
(sblock.fs_fpg * minfree) / 200);
|
2010-02-10 20:17:46 +00:00
|
|
|
if (maxbpg == 0)
|
|
|
|
sblock.fs_maxbpg = MAXBLKPG(sblock.fs_bsize);
|
|
|
|
else
|
|
|
|
sblock.fs_maxbpg = maxbpg;
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_optim = opt;
|
|
|
|
sblock.fs_cgrotor = 0;
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_pendingblocks = 0;
|
|
|
|
sblock.fs_pendinginodes = 0;
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_fmod = 0;
|
|
|
|
sblock.fs_ronly = 0;
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_state = 0;
|
1994-08-26 10:41:13 +00:00
|
|
|
sblock.fs_clean = 1;
|
1997-03-23 20:08:22 +00:00
|
|
|
sblock.fs_id[0] = (long)utime;
|
2003-02-22 23:26:11 +00:00
|
|
|
sblock.fs_id[1] = newfs_random();
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_fsmnt[0] = '\0';
|
|
|
|
csfrags = howmany(sblock.fs_cssize, sblock.fs_fsize);
|
|
|
|
sblock.fs_dsize = sblock.fs_size - sblock.fs_sblkno -
|
|
|
|
sblock.fs_ncg * (sblock.fs_dblkno - sblock.fs_sblkno);
|
|
|
|
sblock.fs_cstotal.cs_nbfree =
|
|
|
|
fragstoblks(&sblock, sblock.fs_dsize) -
|
|
|
|
howmany(csfrags, sblock.fs_frag);
|
|
|
|
sblock.fs_cstotal.cs_nffree =
|
|
|
|
fragnum(&sblock, sblock.fs_size) +
|
2002-12-02 19:31:53 +00:00
|
|
|
(fragnum(&sblock, csfrags) > 0 ?
|
|
|
|
sblock.fs_frag - fragnum(&sblock, csfrags) : 0);
|
2017-02-15 19:50:26 +00:00
|
|
|
sblock.fs_cstotal.cs_nifree =
|
|
|
|
sblock.fs_ncg * sblock.fs_ipg - UFS_ROOTINO;
|
2002-06-21 06:18:05 +00:00
|
|
|
sblock.fs_cstotal.cs_ndir = 0;
|
|
|
|
sblock.fs_dsize -= csfrags;
|
|
|
|
sblock.fs_time = utime;
|
|
|
|
if (Oflag == 1) {
|
|
|
|
sblock.fs_old_time = utime;
|
|
|
|
sblock.fs_old_dsize = sblock.fs_dsize;
|
|
|
|
sblock.fs_old_csaddr = sblock.fs_csaddr;
|
|
|
|
sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;
|
|
|
|
sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;
|
|
|
|
sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;
|
|
|
|
sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;
|
|
|
|
}
|
2017-09-22 12:45:15 +00:00
|
|
|
/*
|
|
|
|
* Set flags for metadata that is being check-hashed.
|
The goal of this change is to prevent accidental foot shooting by
folks running filesystems created on check-hash enabled kernels
(which I will call "new") on a non-check-hash enabled kernels (which
I will call "old). The idea here is to detect when a filesystem is
run on an old kernel and flag the filesystem so that when it gets
moved back to a new kernel, it will not start getting a slew of
check-hash errors.
Back when the UFS version 2 filesystem was created, it added a file
flag FS_INDEXDIRS that was to be set on any filesystem that kept
some sort of on-disk indexing for directories. The idea was precisely
to solve the issue we have today. Specifically that a newer kernel
that supported indexing would be able to tell that the filesystem
had been run on an older non-indexing kernel and that the indexes
should not be used until they had been rebuilt. Since we have never
implemented on-disk directory indicies, the FS_INDEXDIRS flag is
cleared every time any UFS version 2 filesystem ever created is
mounted for writing.
This commit repurposes the FS_INDEXDIRS flag as the FS_METACKHASH
flag. Thus, the FS_METACKHASH is definitively known to have always
been cleared. The FS_INDEXDIRS flag has been moved to a new block
of flags that will always be cleared starting with this commit
(until they get used to implement some future feature which needs
to detect that the filesystem was mounted on a kernel that predates
the new feature).
If a filesystem with check-hashes enabled is mounted on an old
kernel the FS_METACKHASH flag is cleared. When that filesystem is
mounted on a new kernel it will see that the FS_METACKHASH has been
cleared and clears all of the fs_metackhash flags. To get them
re-enabled the user must run fsck (in interactive mode without the
-y flag) which will ask for each supported check hash whether it
should be rebuilt and enabled. When fsck is run in its default preen
mode, it will just ignore the check hashes so they will remain
disabled.
The kernel has always disabled any check hash functions that it
does not support, so as more types of check hashes are added, we
will get a non-surprising result. Specifically if filesystems get
moved to kernels supporting fewer of the check hashes, those that
are not supported will be disabled. If the filesystem is moved back
to a kernel with more of the check-hashes available and fsck is run
interactively to rebuild them, then their checking will resume.
Otherwise just the smaller subset will be checked.
A side effect of this commit is that filesystems running with
cylinder-group check hashes will stop having them checked until
fsck is run to re-enable them (since none of them currently have
the FS_METACKHASH flag set). So, if you want check hashes enabled
on your filesystems after booting a kernel with these changes, you
need to run fsck to enable them. Any newly created filesystems will
have check hashes enabled. If in doubt as to whether you have check
hashes emabled, run dumpfs and look at the list of enabled flags
at the end of the superblock details.
2018-02-08 23:06:58 +00:00
|
|
|
*
|
|
|
|
* Metadata check hashes are not supported in the UFS version 1
|
|
|
|
* filesystem to keep it as small and simple as possible.
|
2017-09-22 12:45:15 +00:00
|
|
|
*/
|
The goal of this change is to prevent accidental foot shooting by
folks running filesystems created on check-hash enabled kernels
(which I will call "new") on a non-check-hash enabled kernels (which
I will call "old). The idea here is to detect when a filesystem is
run on an old kernel and flag the filesystem so that when it gets
moved back to a new kernel, it will not start getting a slew of
check-hash errors.
Back when the UFS version 2 filesystem was created, it added a file
flag FS_INDEXDIRS that was to be set on any filesystem that kept
some sort of on-disk indexing for directories. The idea was precisely
to solve the issue we have today. Specifically that a newer kernel
that supported indexing would be able to tell that the filesystem
had been run on an older non-indexing kernel and that the indexes
should not be used until they had been rebuilt. Since we have never
implemented on-disk directory indicies, the FS_INDEXDIRS flag is
cleared every time any UFS version 2 filesystem ever created is
mounted for writing.
This commit repurposes the FS_INDEXDIRS flag as the FS_METACKHASH
flag. Thus, the FS_METACKHASH is definitively known to have always
been cleared. The FS_INDEXDIRS flag has been moved to a new block
of flags that will always be cleared starting with this commit
(until they get used to implement some future feature which needs
to detect that the filesystem was mounted on a kernel that predates
the new feature).
If a filesystem with check-hashes enabled is mounted on an old
kernel the FS_METACKHASH flag is cleared. When that filesystem is
mounted on a new kernel it will see that the FS_METACKHASH has been
cleared and clears all of the fs_metackhash flags. To get them
re-enabled the user must run fsck (in interactive mode without the
-y flag) which will ask for each supported check hash whether it
should be rebuilt and enabled. When fsck is run in its default preen
mode, it will just ignore the check hashes so they will remain
disabled.
The kernel has always disabled any check hash functions that it
does not support, so as more types of check hashes are added, we
will get a non-surprising result. Specifically if filesystems get
moved to kernels supporting fewer of the check hashes, those that
are not supported will be disabled. If the filesystem is moved back
to a kernel with more of the check-hashes available and fsck is run
interactively to rebuild them, then their checking will resume.
Otherwise just the smaller subset will be checked.
A side effect of this commit is that filesystems running with
cylinder-group check hashes will stop having them checked until
fsck is run to re-enable them (since none of them currently have
the FS_METACKHASH flag set). So, if you want check hashes enabled
on your filesystems after booting a kernel with these changes, you
need to run fsck to enable them. Any newly created filesystems will
have check hashes enabled. If in doubt as to whether you have check
hashes emabled, run dumpfs and look at the list of enabled flags
at the end of the superblock details.
2018-02-08 23:06:58 +00:00
|
|
|
if (Oflag > 1) {
|
|
|
|
sblock.fs_flags |= FS_METACKHASH;
|
|
|
|
if (getosreldate() >= P_OSREL_CK_CYLGRP)
|
2018-10-23 21:10:06 +00:00
|
|
|
sblock.fs_metackhash |= CK_CYLGRP;
|
|
|
|
if (getosreldate() >= P_OSREL_CK_SUPERBLOCK)
|
|
|
|
sblock.fs_metackhash |= CK_SUPERBLOCK;
|
2018-12-11 22:14:37 +00:00
|
|
|
if (getosreldate() >= P_OSREL_CK_INODE)
|
|
|
|
sblock.fs_metackhash |= CK_INODE;
|
The goal of this change is to prevent accidental foot shooting by
folks running filesystems created on check-hash enabled kernels
(which I will call "new") on a non-check-hash enabled kernels (which
I will call "old). The idea here is to detect when a filesystem is
run on an old kernel and flag the filesystem so that when it gets
moved back to a new kernel, it will not start getting a slew of
check-hash errors.
Back when the UFS version 2 filesystem was created, it added a file
flag FS_INDEXDIRS that was to be set on any filesystem that kept
some sort of on-disk indexing for directories. The idea was precisely
to solve the issue we have today. Specifically that a newer kernel
that supported indexing would be able to tell that the filesystem
had been run on an older non-indexing kernel and that the indexes
should not be used until they had been rebuilt. Since we have never
implemented on-disk directory indicies, the FS_INDEXDIRS flag is
cleared every time any UFS version 2 filesystem ever created is
mounted for writing.
This commit repurposes the FS_INDEXDIRS flag as the FS_METACKHASH
flag. Thus, the FS_METACKHASH is definitively known to have always
been cleared. The FS_INDEXDIRS flag has been moved to a new block
of flags that will always be cleared starting with this commit
(until they get used to implement some future feature which needs
to detect that the filesystem was mounted on a kernel that predates
the new feature).
If a filesystem with check-hashes enabled is mounted on an old
kernel the FS_METACKHASH flag is cleared. When that filesystem is
mounted on a new kernel it will see that the FS_METACKHASH has been
cleared and clears all of the fs_metackhash flags. To get them
re-enabled the user must run fsck (in interactive mode without the
-y flag) which will ask for each supported check hash whether it
should be rebuilt and enabled. When fsck is run in its default preen
mode, it will just ignore the check hashes so they will remain
disabled.
The kernel has always disabled any check hash functions that it
does not support, so as more types of check hashes are added, we
will get a non-surprising result. Specifically if filesystems get
moved to kernels supporting fewer of the check hashes, those that
are not supported will be disabled. If the filesystem is moved back
to a kernel with more of the check-hashes available and fsck is run
interactively to rebuild them, then their checking will resume.
Otherwise just the smaller subset will be checked.
A side effect of this commit is that filesystems running with
cylinder-group check hashes will stop having them checked until
fsck is run to re-enable them (since none of them currently have
the FS_METACKHASH flag set). So, if you want check hashes enabled
on your filesystems after booting a kernel with these changes, you
need to run fsck to enable them. Any newly created filesystems will
have check hashes enabled. If in doubt as to whether you have check
hashes emabled, run dumpfs and look at the list of enabled flags
at the end of the superblock details.
2018-02-08 23:06:58 +00:00
|
|
|
}
|
1997-03-23 20:08:22 +00:00
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* Dump out summary information about file system.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
2002-06-21 06:18:05 +00:00
|
|
|
# define B2MBFACTOR (1 / (1024.0 * 1024.0))
|
2002-07-11 17:49:41 +00:00
|
|
|
printf("%s: %.1fMB (%jd sectors) block size %d, fragment size %d\n",
|
2002-06-21 06:18:05 +00:00
|
|
|
fsys, (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
|
2002-07-11 17:49:41 +00:00
|
|
|
(intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,
|
|
|
|
sblock.fs_fsize);
|
2002-06-21 06:18:05 +00:00
|
|
|
printf("\tusing %d cylinder groups of %.2fMB, %d blks, %d inodes.\n",
|
|
|
|
sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
|
|
|
|
sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
|
|
|
|
if (sblock.fs_flags & FS_DOSOFTDEP)
|
|
|
|
printf("\twith soft updates\n");
|
|
|
|
# undef B2MBFACTOR
|
2003-05-22 18:38:54 +00:00
|
|
|
|
2007-12-16 19:41:31 +00:00
|
|
|
if (Eflag && !Nflag) {
|
2007-12-16 20:19:55 +00:00
|
|
|
printf("Erasing sectors [%jd...%jd]\n",
|
2007-12-16 19:41:31 +00:00
|
|
|
sblock.fs_sblockloc / disk.d_bsize,
|
2007-12-16 20:19:55 +00:00
|
|
|
fsbtodb(&sblock, sblock.fs_size) - 1);
|
2007-12-16 19:41:31 +00:00
|
|
|
berase(&disk, sblock.fs_sblockloc / disk.d_bsize,
|
|
|
|
sblock.fs_size * sblock.fs_fsize - sblock.fs_sblockloc);
|
|
|
|
}
|
2003-05-22 18:38:54 +00:00
|
|
|
/*
|
|
|
|
* Wipe out old UFS1 superblock(s) if necessary.
|
|
|
|
*/
|
2017-09-04 20:19:36 +00:00
|
|
|
if (!Nflag && Oflag != 1 && realsectorsize <= SBLOCK_UFS1) {
|
2018-02-02 23:26:52 +00:00
|
|
|
i = bread(&disk, part_ofs + SBLOCK_UFS1 / disk.d_bsize, chdummy,
|
|
|
|
SBLOCKSIZE);
|
2003-05-22 18:38:54 +00:00
|
|
|
if (i == -1)
|
2018-02-02 23:26:52 +00:00
|
|
|
err(1, "can't read old UFS1 superblock: %s",
|
|
|
|
disk.d_error);
|
2003-05-22 18:38:54 +00:00
|
|
|
|
|
|
|
if (fsdummy.fs_magic == FS_UFS1_MAGIC) {
|
|
|
|
fsdummy.fs_magic = 0;
|
2009-02-12 15:28:15 +00:00
|
|
|
bwrite(&disk, part_ofs + SBLOCK_UFS1 / disk.d_bsize,
|
|
|
|
chdummy, SBLOCKSIZE);
|
2011-04-26 02:06:31 +00:00
|
|
|
for (cg = 0; cg < fsdummy.fs_ncg; cg++) {
|
2018-02-02 23:26:52 +00:00
|
|
|
if (fsbtodb(&fsdummy, cgsblock(&fsdummy, cg)) >
|
|
|
|
fssize)
|
2011-04-26 02:06:31 +00:00
|
|
|
break;
|
2009-02-12 15:28:15 +00:00
|
|
|
bwrite(&disk, part_ofs + fsbtodb(&fsdummy,
|
2010-02-11 18:14:53 +00:00
|
|
|
cgsblock(&fsdummy, cg)), chdummy, SBLOCKSIZE);
|
2011-04-26 02:06:31 +00:00
|
|
|
}
|
2003-05-22 18:38:54 +00:00
|
|
|
}
|
|
|
|
}
|
2020-06-19 01:02:53 +00:00
|
|
|
/*
|
|
|
|
* Reference the summary information so it will also be written.
|
|
|
|
*/
|
|
|
|
sblock.fs_csp = fscs;
|
2020-09-13 22:57:50 +00:00
|
|
|
if (!Nflag && sbwrite(&disk, 0) != 0)
|
|
|
|
err(1, "sbwrite: %s", disk.d_error);
|
2007-12-16 19:41:31 +00:00
|
|
|
if (Xflag == 1) {
|
|
|
|
printf("** Exiting on Xflag 1\n");
|
2003-11-16 07:17:30 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
2007-12-16 19:41:31 +00:00
|
|
|
if (Xflag == 2)
|
|
|
|
printf("** Leaving BAD MAGIC on Xflag 2\n");
|
2004-08-19 11:09:13 +00:00
|
|
|
else
|
|
|
|
sblock.fs_magic = (Oflag != 1) ? FS_UFS2_MAGIC : FS_UFS1_MAGIC;
|
2003-05-22 18:38:54 +00:00
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* Now build the cylinders group blocks and
|
|
|
|
* then print out indices of cylinder groups.
|
|
|
|
*/
|
2014-02-09 14:28:47 +00:00
|
|
|
printf("super-block backups (for fsck_ffs -b #) at:\n");
|
1996-01-30 23:14:34 +00:00
|
|
|
i = 0;
|
|
|
|
width = charsperline();
|
2002-11-30 18:28:26 +00:00
|
|
|
/*
|
2018-02-02 23:26:52 +00:00
|
|
|
* Allocate space for two sets of inode blocks.
|
2002-11-30 18:28:26 +00:00
|
|
|
*/
|
2018-02-02 23:26:52 +00:00
|
|
|
iobufsize = 2 * sblock.fs_bsize;
|
2008-03-05 23:17:19 +00:00
|
|
|
if ((iobuf = calloc(1, iobufsize)) == 0) {
|
2002-11-30 18:28:26 +00:00
|
|
|
printf("Cannot allocate I/O buffer\n");
|
|
|
|
exit(38);
|
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
/*
|
2018-01-26 00:58:32 +00:00
|
|
|
* Write out all the cylinder groups and backup superblocks.
|
2002-06-21 06:18:05 +00:00
|
|
|
*/
|
2010-02-11 18:14:53 +00:00
|
|
|
for (cg = 0; cg < sblock.fs_ncg; cg++) {
|
2018-01-26 00:58:32 +00:00
|
|
|
if (!Nflag)
|
|
|
|
initcg(cg, utime);
|
2002-07-11 17:49:41 +00:00
|
|
|
j = snprintf(tmpbuf, sizeof(tmpbuf), " %jd%s",
|
2010-02-11 18:14:53 +00:00
|
|
|
(intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cg)),
|
|
|
|
cg < (sblock.fs_ncg-1) ? "," : "");
|
2001-08-20 14:53:05 +00:00
|
|
|
if (j < 0)
|
|
|
|
tmpbuf[j = 0] = '\0';
|
1998-06-28 20:11:23 +00:00
|
|
|
if (i + j >= width) {
|
1994-05-26 06:35:07 +00:00
|
|
|
printf("\n");
|
1996-01-30 23:14:34 +00:00
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
i += j;
|
|
|
|
printf("%s", tmpbuf);
|
1995-05-02 07:45:39 +00:00
|
|
|
fflush(stdout);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2001-05-29 19:40:39 +00:00
|
|
|
printf("\n");
|
|
|
|
if (Nflag)
|
1994-05-26 06:35:07 +00:00
|
|
|
exit(0);
|
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* Now construct the initial file system,
|
1994-05-26 06:35:07 +00:00
|
|
|
* then write out the super-block.
|
|
|
|
*/
|
|
|
|
fsinit(utime);
|
2002-06-21 06:18:05 +00:00
|
|
|
if (Oflag == 1) {
|
|
|
|
sblock.fs_old_cstotal.cs_ndir = sblock.fs_cstotal.cs_ndir;
|
|
|
|
sblock.fs_old_cstotal.cs_nbfree = sblock.fs_cstotal.cs_nbfree;
|
|
|
|
sblock.fs_old_cstotal.cs_nifree = sblock.fs_cstotal.cs_nifree;
|
|
|
|
sblock.fs_old_cstotal.cs_nffree = sblock.fs_cstotal.cs_nffree;
|
|
|
|
}
|
2007-12-16 19:41:31 +00:00
|
|
|
if (Xflag == 3) {
|
|
|
|
printf("** Exiting on Xflag 3\n");
|
2003-11-16 07:17:30 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
2020-09-13 22:57:50 +00:00
|
|
|
if (sbwrite(&disk, 0) != 0)
|
|
|
|
err(1, "sbwrite: %s", disk.d_error);
|
2018-01-26 00:58:32 +00:00
|
|
|
/*
|
|
|
|
* For UFS1 filesystems with a blocksize of 64K, the first
|
|
|
|
* alternate superblock resides at the location used for
|
|
|
|
* the default UFS2 superblock. As there is a valid
|
|
|
|
* superblock at this location, the boot code will use
|
|
|
|
* it as its first choice. Thus we have to ensure that
|
|
|
|
* all of its statistcs on usage are correct.
|
|
|
|
*/
|
|
|
|
if (Oflag == 1 && sblock.fs_bsize == 65536)
|
|
|
|
wtfs(fsbtodb(&sblock, cgsblock(&sblock, 0)),
|
|
|
|
sblock.fs_bsize, (char *)&sblock);
|
2017-08-09 05:17:21 +00:00
|
|
|
/*
|
|
|
|
* Read the last sector of the boot block, replace the last
|
|
|
|
* 20 bytes with the recovery information, then write it back.
|
|
|
|
* The recovery information only works for UFS2 filesystems.
|
2022-07-21 05:45:18 +00:00
|
|
|
* For UFS1, zero out the area to ensure that an old UFS2
|
|
|
|
* recovery block is not accidentally found.
|
2017-08-09 05:17:21 +00:00
|
|
|
*/
|
2022-07-21 05:45:18 +00:00
|
|
|
if ((fsrbuf = malloc(realsectorsize)) == NULL || bread(&disk,
|
|
|
|
part_ofs + (SBLOCK_UFS2 - realsectorsize) / disk.d_bsize,
|
|
|
|
fsrbuf, realsectorsize) == -1)
|
|
|
|
err(1, "can't read recovery area: %s", disk.d_error);
|
|
|
|
fsr = (struct fsrecovery *)&fsrbuf[realsectorsize - sizeof *fsr];
|
|
|
|
if (sblock.fs_magic != FS_UFS2_MAGIC) {
|
|
|
|
memset(fsr, 0, sizeof *fsr);
|
|
|
|
} else {
|
2017-09-04 20:19:36 +00:00
|
|
|
fsr->fsr_magic = sblock.fs_magic;
|
|
|
|
fsr->fsr_fpg = sblock.fs_fpg;
|
|
|
|
fsr->fsr_fsbtodb = sblock.fs_fsbtodb;
|
|
|
|
fsr->fsr_sblkno = sblock.fs_sblkno;
|
|
|
|
fsr->fsr_ncg = sblock.fs_ncg;
|
2017-08-09 05:17:21 +00:00
|
|
|
}
|
2022-07-21 05:45:18 +00:00
|
|
|
wtfs((SBLOCK_UFS2 - realsectorsize) / disk.d_bsize,
|
|
|
|
realsectorsize, fsrbuf);
|
|
|
|
free(fsrbuf);
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
2010-01-02 17:32:40 +00:00
|
|
|
* Update information about this partition in pack
|
1994-05-26 06:35:07 +00:00
|
|
|
* label, to that it may be updated on disk.
|
|
|
|
*/
|
2002-04-24 11:44:02 +00:00
|
|
|
if (pp != NULL) {
|
|
|
|
pp->p_fstype = FS_BSDFFS;
|
|
|
|
pp->p_fsize = sblock.fs_fsize;
|
|
|
|
pp->p_frag = sblock.fs_frag;
|
2002-06-21 06:18:05 +00:00
|
|
|
pp->p_cpg = sblock.fs_fpg;
|
2002-04-24 11:44:02 +00:00
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize a cylinder group.
|
|
|
|
*/
|
1998-07-15 06:28:05 +00:00
|
|
|
void
|
2002-03-19 17:20:02 +00:00
|
|
|
initcg(int cylno, time_t utime)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2010-02-11 18:14:53 +00:00
|
|
|
long blkno, start;
|
2018-01-26 00:58:32 +00:00
|
|
|
off_t savedactualloc;
|
2010-02-11 18:14:53 +00:00
|
|
|
uint i, j, d, dlower, dupper;
|
2002-06-21 06:18:05 +00:00
|
|
|
ufs2_daddr_t cbase, dmax;
|
|
|
|
struct ufs1_dinode *dp1;
|
|
|
|
struct ufs2_dinode *dp2;
|
2002-03-17 09:01:41 +00:00
|
|
|
struct csum *cs;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine block bounds for cylinder group.
|
|
|
|
* Allow space for super block summary information in first
|
|
|
|
* cylinder group.
|
|
|
|
*/
|
|
|
|
cbase = cgbase(&sblock, cylno);
|
|
|
|
dmax = cbase + sblock.fs_fpg;
|
|
|
|
if (dmax > sblock.fs_size)
|
|
|
|
dmax = sblock.fs_size;
|
|
|
|
dlower = cgsblock(&sblock, cylno) - cbase;
|
|
|
|
dupper = cgdmin(&sblock, cylno) - cbase;
|
|
|
|
if (cylno == 0)
|
|
|
|
dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
|
2002-06-21 06:18:05 +00:00
|
|
|
cs = &fscs[cylno];
|
1997-03-11 12:48:17 +00:00
|
|
|
memset(&acg, 0, sblock.fs_cgsize);
|
1994-05-26 06:35:07 +00:00
|
|
|
acg.cg_time = utime;
|
|
|
|
acg.cg_magic = CG_MAGIC;
|
|
|
|
acg.cg_cgx = cylno;
|
|
|
|
acg.cg_niblk = sblock.fs_ipg;
|
2016-05-02 00:45:46 +00:00
|
|
|
acg.cg_initediblk = MIN(sblock.fs_ipg, 2 * INOPB(&sblock));
|
1994-05-26 06:35:07 +00:00
|
|
|
acg.cg_ndblk = dmax - cbase;
|
|
|
|
if (sblock.fs_contigsumsize > 0)
|
|
|
|
acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
|
2002-06-21 06:18:05 +00:00
|
|
|
start = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield);
|
|
|
|
if (Oflag == 2) {
|
|
|
|
acg.cg_iusedoff = start;
|
1994-05-26 06:35:07 +00:00
|
|
|
} else {
|
2002-06-21 06:18:05 +00:00
|
|
|
acg.cg_old_ncyl = sblock.fs_old_cpg;
|
|
|
|
acg.cg_old_time = acg.cg_time;
|
|
|
|
acg.cg_time = 0;
|
|
|
|
acg.cg_old_niblk = acg.cg_niblk;
|
|
|
|
acg.cg_niblk = 0;
|
|
|
|
acg.cg_initediblk = 0;
|
|
|
|
acg.cg_old_btotoff = start;
|
|
|
|
acg.cg_old_boff = acg.cg_old_btotoff +
|
|
|
|
sblock.fs_old_cpg * sizeof(int32_t);
|
|
|
|
acg.cg_iusedoff = acg.cg_old_boff +
|
|
|
|
sblock.fs_old_cpg * sizeof(u_int16_t);
|
|
|
|
}
|
2002-09-25 04:06:37 +00:00
|
|
|
acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
|
|
|
|
acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
|
2002-06-21 06:18:05 +00:00
|
|
|
if (sblock.fs_contigsumsize > 0) {
|
1994-05-26 06:35:07 +00:00
|
|
|
acg.cg_clustersumoff =
|
2002-06-21 06:18:05 +00:00
|
|
|
roundup(acg.cg_nextfreeoff, sizeof(u_int32_t));
|
|
|
|
acg.cg_clustersumoff -= sizeof(u_int32_t);
|
1994-05-26 06:35:07 +00:00
|
|
|
acg.cg_clusteroff = acg.cg_clustersumoff +
|
1998-08-27 07:38:33 +00:00
|
|
|
(sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
|
2002-06-21 06:18:05 +00:00
|
|
|
acg.cg_nextfreeoff = acg.cg_clusteroff +
|
2002-09-25 04:06:37 +00:00
|
|
|
howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2010-02-11 18:14:53 +00:00
|
|
|
if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {
|
1994-05-26 06:35:07 +00:00
|
|
|
printf("Panic: cylinder group too big\n");
|
|
|
|
exit(37);
|
|
|
|
}
|
|
|
|
acg.cg_cs.cs_nifree += sblock.fs_ipg;
|
|
|
|
if (cylno == 0)
|
2017-02-15 19:50:26 +00:00
|
|
|
for (i = 0; i < (long)UFS_ROOTINO; i++) {
|
1994-05-26 06:35:07 +00:00
|
|
|
setbit(cg_inosused(&acg), i);
|
|
|
|
acg.cg_cs.cs_nifree--;
|
|
|
|
}
|
|
|
|
if (cylno > 0) {
|
|
|
|
/*
|
|
|
|
* In cylno 0, beginning space is reserved
|
|
|
|
* for boot and super blocks.
|
|
|
|
*/
|
|
|
|
for (d = 0; d < dlower; d += sblock.fs_frag) {
|
|
|
|
blkno = d / sblock.fs_frag;
|
|
|
|
setblock(&sblock, cg_blksfree(&acg), blkno);
|
|
|
|
if (sblock.fs_contigsumsize > 0)
|
|
|
|
setbit(cg_clustersfree(&acg), blkno);
|
|
|
|
acg.cg_cs.cs_nbfree++;
|
|
|
|
}
|
|
|
|
}
|
1998-07-15 06:28:05 +00:00
|
|
|
if ((i = dupper % sblock.fs_frag)) {
|
1994-05-26 06:35:07 +00:00
|
|
|
acg.cg_frsum[sblock.fs_frag - i]++;
|
|
|
|
for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
|
|
|
|
setbit(cg_blksfree(&acg), dupper);
|
|
|
|
acg.cg_cs.cs_nffree++;
|
|
|
|
}
|
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
for (d = dupper; d + sblock.fs_frag <= acg.cg_ndblk;
|
|
|
|
d += sblock.fs_frag) {
|
1994-05-26 06:35:07 +00:00
|
|
|
blkno = d / sblock.fs_frag;
|
|
|
|
setblock(&sblock, cg_blksfree(&acg), blkno);
|
|
|
|
if (sblock.fs_contigsumsize > 0)
|
|
|
|
setbit(cg_clustersfree(&acg), blkno);
|
|
|
|
acg.cg_cs.cs_nbfree++;
|
2002-06-21 06:18:05 +00:00
|
|
|
}
|
|
|
|
if (d < acg.cg_ndblk) {
|
|
|
|
acg.cg_frsum[acg.cg_ndblk - d]++;
|
|
|
|
for (; d < acg.cg_ndblk; d++) {
|
1994-05-26 06:35:07 +00:00
|
|
|
setbit(cg_blksfree(&acg), d);
|
|
|
|
acg.cg_cs.cs_nffree++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sblock.fs_contigsumsize > 0) {
|
1997-03-11 12:48:17 +00:00
|
|
|
int32_t *sump = cg_clustersum(&acg);
|
1994-05-26 06:35:07 +00:00
|
|
|
u_char *mapp = cg_clustersfree(&acg);
|
|
|
|
int map = *mapp++;
|
|
|
|
int bit = 1;
|
|
|
|
int run = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < acg.cg_nclusterblks; i++) {
|
2001-11-02 09:23:34 +00:00
|
|
|
if ((map & bit) != 0)
|
1994-05-26 06:35:07 +00:00
|
|
|
run++;
|
2001-11-02 09:23:34 +00:00
|
|
|
else if (run != 0) {
|
1994-05-26 06:35:07 +00:00
|
|
|
if (run > sblock.fs_contigsumsize)
|
|
|
|
run = sblock.fs_contigsumsize;
|
|
|
|
sump[run]++;
|
|
|
|
run = 0;
|
|
|
|
}
|
2002-09-25 04:06:37 +00:00
|
|
|
if ((i & (CHAR_BIT - 1)) != CHAR_BIT - 1)
|
1994-05-26 06:35:07 +00:00
|
|
|
bit <<= 1;
|
2001-11-02 09:23:34 +00:00
|
|
|
else {
|
1994-05-26 06:35:07 +00:00
|
|
|
map = *mapp++;
|
|
|
|
bit = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (run != 0) {
|
|
|
|
if (run > sblock.fs_contigsumsize)
|
|
|
|
run = sblock.fs_contigsumsize;
|
|
|
|
sump[run]++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*cs = acg.cg_cs;
|
2002-06-21 06:18:05 +00:00
|
|
|
/*
|
2018-01-26 00:58:32 +00:00
|
|
|
* Write out the duplicate super block. Then write the cylinder
|
|
|
|
* group map and two blocks worth of inodes in a single write.
|
2002-06-21 06:18:05 +00:00
|
|
|
*/
|
2018-01-26 00:58:32 +00:00
|
|
|
savedactualloc = sblock.fs_sblockactualloc;
|
|
|
|
sblock.fs_sblockactualloc =
|
|
|
|
dbtob(fsbtodb(&sblock, cgsblock(&sblock, cylno)));
|
2020-09-13 22:57:50 +00:00
|
|
|
if (sbwrite(&disk, 0) != 0)
|
|
|
|
err(1, "sbwrite: %s", disk.d_error);
|
2018-01-26 00:58:32 +00:00
|
|
|
sblock.fs_sblockactualloc = savedactualloc;
|
2020-09-13 22:57:50 +00:00
|
|
|
if (cgwrite(&disk) != 0)
|
|
|
|
err(1, "initcg: cgwrite: %s", disk.d_error);
|
2018-01-26 00:58:32 +00:00
|
|
|
start = 0;
|
2002-06-21 06:18:05 +00:00
|
|
|
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
|
|
|
|
dp2 = (struct ufs2_dinode *)(&iobuf[start]);
|
|
|
|
for (i = 0; i < acg.cg_initediblk; i++) {
|
|
|
|
if (sblock.fs_magic == FS_UFS1_MAGIC) {
|
2003-02-22 23:26:11 +00:00
|
|
|
dp1->di_gen = newfs_random();
|
2002-06-21 06:18:05 +00:00
|
|
|
dp1++;
|
|
|
|
} else {
|
2003-02-22 23:26:11 +00:00
|
|
|
dp2->di_gen = newfs_random();
|
2002-06-21 06:18:05 +00:00
|
|
|
dp2++;
|
|
|
|
}
|
|
|
|
}
|
2018-02-02 23:26:52 +00:00
|
|
|
wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno)), iobufsize, iobuf);
|
2002-06-21 06:18:05 +00:00
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* For the old file system, we have to initialize all the inodes.
|
2002-06-21 06:18:05 +00:00
|
|
|
*/
|
|
|
|
if (Oflag == 1) {
|
|
|
|
for (i = 2 * sblock.fs_frag;
|
|
|
|
i < sblock.fs_ipg / INOPF(&sblock);
|
|
|
|
i += sblock.fs_frag) {
|
|
|
|
dp1 = (struct ufs1_dinode *)(&iobuf[start]);
|
|
|
|
for (j = 0; j < INOPB(&sblock); j++) {
|
2003-02-22 23:26:11 +00:00
|
|
|
dp1->di_gen = newfs_random();
|
2002-06-21 06:18:05 +00:00
|
|
|
dp1++;
|
|
|
|
}
|
|
|
|
wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
|
|
|
|
sblock.fs_bsize, &iobuf[start]);
|
|
|
|
}
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* initialize the file system
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
2003-11-04 07:34:32 +00:00
|
|
|
#define ROOTLINKCNT 3
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2011-11-04 13:36:02 +00:00
|
|
|
static struct direct root_dir[] = {
|
2017-02-15 19:50:26 +00:00
|
|
|
{ UFS_ROOTINO, sizeof(struct direct), DT_DIR, 1, "." },
|
|
|
|
{ UFS_ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
|
|
|
|
{ UFS_ROOTINO + 1, sizeof(struct direct), DT_DIR, 5, ".snap" },
|
2003-11-04 07:34:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define SNAPLINKCNT 2
|
|
|
|
|
2011-11-04 13:36:02 +00:00
|
|
|
static struct direct snap_dir[] = {
|
2017-02-15 19:50:26 +00:00
|
|
|
{ UFS_ROOTINO + 1, sizeof(struct direct), DT_DIR, 1, "." },
|
|
|
|
{ UFS_ROOTINO, sizeof(struct direct), DT_DIR, 2, ".." },
|
1994-05-26 06:35:07 +00:00
|
|
|
};
|
|
|
|
|
1998-07-15 06:28:05 +00:00
|
|
|
void
|
2002-03-19 17:20:02 +00:00
|
|
|
fsinit(time_t utime)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode node;
|
2003-11-04 07:34:32 +00:00
|
|
|
struct group *grp;
|
2005-08-14 17:07:04 +00:00
|
|
|
gid_t gid;
|
2005-01-21 22:20:25 +00:00
|
|
|
int entries;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2002-06-21 06:18:05 +00:00
|
|
|
memset(&node, 0, sizeof node);
|
2005-08-14 17:07:04 +00:00
|
|
|
if ((grp = getgrnam("operator")) != NULL) {
|
|
|
|
gid = grp->gr_gid;
|
|
|
|
} else {
|
2006-09-27 05:49:21 +00:00
|
|
|
warnx("Cannot retrieve operator gid, using gid 0.");
|
2005-08-14 17:07:04 +00:00
|
|
|
gid = 0;
|
|
|
|
}
|
2005-01-21 22:20:25 +00:00
|
|
|
entries = (nflag) ? ROOTLINKCNT - 1: ROOTLINKCNT;
|
2002-06-21 06:18:05 +00:00
|
|
|
if (sblock.fs_magic == FS_UFS1_MAGIC) {
|
|
|
|
/*
|
|
|
|
* initialize the node
|
|
|
|
*/
|
|
|
|
node.dp1.di_atime = utime;
|
|
|
|
node.dp1.di_mtime = utime;
|
|
|
|
node.dp1.di_ctime = utime;
|
|
|
|
/*
|
|
|
|
* create the root directory
|
|
|
|
*/
|
2018-03-17 12:59:55 +00:00
|
|
|
node.dp1.di_mode = IFDIR | UMASK;
|
2005-01-21 22:20:25 +00:00
|
|
|
node.dp1.di_nlink = entries;
|
|
|
|
node.dp1.di_size = makedir(root_dir, entries);
|
2003-11-04 07:34:32 +00:00
|
|
|
node.dp1.di_db[0] = alloc(sblock.fs_fsize, node.dp1.di_mode);
|
|
|
|
node.dp1.di_blocks =
|
|
|
|
btodb(fragroundup(&sblock, node.dp1.di_size));
|
|
|
|
wtfs(fsbtodb(&sblock, node.dp1.di_db[0]), sblock.fs_fsize,
|
|
|
|
iobuf);
|
2017-02-15 19:50:26 +00:00
|
|
|
iput(&node, UFS_ROOTINO);
|
2005-01-21 22:20:25 +00:00
|
|
|
if (!nflag) {
|
|
|
|
/*
|
|
|
|
* create the .snap directory
|
|
|
|
*/
|
|
|
|
node.dp1.di_mode |= 020;
|
2005-08-14 17:07:04 +00:00
|
|
|
node.dp1.di_gid = gid;
|
2005-01-21 22:20:25 +00:00
|
|
|
node.dp1.di_nlink = SNAPLINKCNT;
|
|
|
|
node.dp1.di_size = makedir(snap_dir, SNAPLINKCNT);
|
|
|
|
node.dp1.di_db[0] =
|
|
|
|
alloc(sblock.fs_fsize, node.dp1.di_mode);
|
|
|
|
node.dp1.di_blocks =
|
|
|
|
btodb(fragroundup(&sblock, node.dp1.di_size));
|
|
|
|
wtfs(fsbtodb(&sblock, node.dp1.di_db[0]),
|
|
|
|
sblock.fs_fsize, iobuf);
|
2017-02-15 19:50:26 +00:00
|
|
|
iput(&node, UFS_ROOTINO + 1);
|
2005-01-21 22:20:25 +00:00
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* initialize the node
|
|
|
|
*/
|
|
|
|
node.dp2.di_atime = utime;
|
|
|
|
node.dp2.di_mtime = utime;
|
|
|
|
node.dp2.di_ctime = utime;
|
2002-07-17 10:31:38 +00:00
|
|
|
node.dp2.di_birthtime = utime;
|
2002-06-21 06:18:05 +00:00
|
|
|
/*
|
|
|
|
* create the root directory
|
|
|
|
*/
|
2018-03-17 12:59:55 +00:00
|
|
|
node.dp2.di_mode = IFDIR | UMASK;
|
2005-01-21 22:20:25 +00:00
|
|
|
node.dp2.di_nlink = entries;
|
|
|
|
node.dp2.di_size = makedir(root_dir, entries);
|
2003-11-04 07:34:32 +00:00
|
|
|
node.dp2.di_db[0] = alloc(sblock.fs_fsize, node.dp2.di_mode);
|
|
|
|
node.dp2.di_blocks =
|
|
|
|
btodb(fragroundup(&sblock, node.dp2.di_size));
|
|
|
|
wtfs(fsbtodb(&sblock, node.dp2.di_db[0]), sblock.fs_fsize,
|
|
|
|
iobuf);
|
2017-02-15 19:50:26 +00:00
|
|
|
iput(&node, UFS_ROOTINO);
|
2005-01-21 22:20:25 +00:00
|
|
|
if (!nflag) {
|
|
|
|
/*
|
|
|
|
* create the .snap directory
|
|
|
|
*/
|
|
|
|
node.dp2.di_mode |= 020;
|
2005-08-14 17:07:04 +00:00
|
|
|
node.dp2.di_gid = gid;
|
2005-01-21 22:20:25 +00:00
|
|
|
node.dp2.di_nlink = SNAPLINKCNT;
|
|
|
|
node.dp2.di_size = makedir(snap_dir, SNAPLINKCNT);
|
|
|
|
node.dp2.di_db[0] =
|
|
|
|
alloc(sblock.fs_fsize, node.dp2.di_mode);
|
|
|
|
node.dp2.di_blocks =
|
|
|
|
btodb(fragroundup(&sblock, node.dp2.di_size));
|
|
|
|
wtfs(fsbtodb(&sblock, node.dp2.di_db[0]),
|
|
|
|
sblock.fs_fsize, iobuf);
|
2017-02-15 19:50:26 +00:00
|
|
|
iput(&node, UFS_ROOTINO + 1);
|
2005-01-21 22:20:25 +00:00
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-06-21 06:18:05 +00:00
|
|
|
* construct a set of directory entries in "iobuf".
|
1994-05-26 06:35:07 +00:00
|
|
|
* return size of directory.
|
|
|
|
*/
|
1998-07-15 06:28:05 +00:00
|
|
|
int
|
2002-03-19 17:20:02 +00:00
|
|
|
makedir(struct direct *protodir, int entries)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
char *cp;
|
|
|
|
int i, spcleft;
|
|
|
|
|
|
|
|
spcleft = DIRBLKSIZ;
|
2002-06-21 06:18:05 +00:00
|
|
|
memset(iobuf, 0, DIRBLKSIZ);
|
|
|
|
for (cp = iobuf, i = 0; i < entries - 1; i++) {
|
1994-05-26 06:35:07 +00:00
|
|
|
protodir[i].d_reclen = DIRSIZ(0, &protodir[i]);
|
1997-03-11 12:48:17 +00:00
|
|
|
memmove(cp, &protodir[i], protodir[i].d_reclen);
|
1994-05-26 06:35:07 +00:00
|
|
|
cp += protodir[i].d_reclen;
|
|
|
|
spcleft -= protodir[i].d_reclen;
|
|
|
|
}
|
|
|
|
protodir[i].d_reclen = spcleft;
|
1997-03-11 12:48:17 +00:00
|
|
|
memmove(cp, &protodir[i], DIRSIZ(0, &protodir[i]));
|
1994-05-26 06:35:07 +00:00
|
|
|
return (DIRBLKSIZ);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate a block or frag
|
|
|
|
*/
|
2002-06-21 06:18:05 +00:00
|
|
|
ufs2_daddr_t
|
2002-03-19 17:20:02 +00:00
|
|
|
alloc(int size, int mode)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2010-02-11 18:14:53 +00:00
|
|
|
int i, blkno, frag;
|
|
|
|
uint d;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
Enable operation of newfs on plain files, which is useful when you
want to prepare disk images for emulators (though 'makefs' in port
can do something similar).
This relies on:
+ minor changes to pass the consistency checks even when working on a file;
+ an additional option, '-p partition' , to specify the disk partition to
initialize;
+ some changes on the I/O routines to deal with partition offsets.
The latter was a bit tricky to implement, see the details in newfs.h:
in newfs, I/O is done through libufs which assumes that the file
descriptor refers to the whole partition. Introducing support for
the offset in libufs would require a non-backward compatible change
in the library, to be dealt with a version bump or with symbol
versioning.
I felt both approaches to be overkill for this specific application,
especially because there might be other changes to libufs that might
become necessary in the near future.
So I used the following trick:
- read access is always done by calling bread() directly, so we just add
the offset in the (few) places that call bread();
- write access is done through bwrite() and sbwrite(), which in turn
calls bwrite(). To avoid rewriting sbwrite(), we supply our own version
of bwrite() here, which takes precedence over the version in libufs.
MFC after: 4 weeks
2008-12-03 18:36:59 +00:00
|
|
|
bread(&disk, part_ofs + fsbtodb(&sblock, cgtod(&sblock, 0)), (char *)&acg,
|
2003-02-11 03:06:45 +00:00
|
|
|
sblock.fs_cgsize);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (acg.cg_magic != CG_MAGIC) {
|
|
|
|
printf("cg 0: bad magic number\n");
|
2003-08-05 13:35:17 +00:00
|
|
|
exit(38);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
if (acg.cg_cs.cs_nbfree == 0) {
|
|
|
|
printf("first cylinder group ran out of space\n");
|
2003-08-05 13:35:17 +00:00
|
|
|
exit(39);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
|
|
|
|
if (isblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag))
|
|
|
|
goto goth;
|
|
|
|
printf("internal error: can't find block in cyl 0\n");
|
2003-08-05 13:35:17 +00:00
|
|
|
exit(40);
|
1994-05-26 06:35:07 +00:00
|
|
|
goth:
|
|
|
|
blkno = fragstoblks(&sblock, d);
|
|
|
|
clrblock(&sblock, cg_blksfree(&acg), blkno);
|
1997-03-11 12:48:17 +00:00
|
|
|
if (sblock.fs_contigsumsize > 0)
|
|
|
|
clrbit(cg_clustersfree(&acg), blkno);
|
1994-05-26 06:35:07 +00:00
|
|
|
acg.cg_cs.cs_nbfree--;
|
|
|
|
sblock.fs_cstotal.cs_nbfree--;
|
|
|
|
fscs[0].cs_nbfree--;
|
2018-03-17 12:59:55 +00:00
|
|
|
if (mode & IFDIR) {
|
1994-05-26 06:35:07 +00:00
|
|
|
acg.cg_cs.cs_ndir++;
|
|
|
|
sblock.fs_cstotal.cs_ndir++;
|
|
|
|
fscs[0].cs_ndir++;
|
|
|
|
}
|
|
|
|
if (size != sblock.fs_bsize) {
|
|
|
|
frag = howmany(size, sblock.fs_fsize);
|
|
|
|
fscs[0].cs_nffree += sblock.fs_frag - frag;
|
|
|
|
sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;
|
|
|
|
acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
|
|
|
|
acg.cg_frsum[sblock.fs_frag - frag]++;
|
|
|
|
for (i = frag; i < sblock.fs_frag; i++)
|
|
|
|
setbit(cg_blksfree(&acg), d + i);
|
|
|
|
}
|
2020-09-13 22:57:50 +00:00
|
|
|
if (cgwrite(&disk) != 0)
|
|
|
|
err(1, "alloc: cgwrite: %s", disk.d_error);
|
2002-06-21 06:18:05 +00:00
|
|
|
return ((ufs2_daddr_t)d);
|
1997-03-11 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* Allocate an inode on the disk
|
|
|
|
*/
|
1998-07-15 06:28:05 +00:00
|
|
|
void
|
2002-06-21 06:18:05 +00:00
|
|
|
iput(union dinode *ip, ino_t ino)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2018-11-13 21:40:56 +00:00
|
|
|
union dinodep dp;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
Enable operation of newfs on plain files, which is useful when you
want to prepare disk images for emulators (though 'makefs' in port
can do something similar).
This relies on:
+ minor changes to pass the consistency checks even when working on a file;
+ an additional option, '-p partition' , to specify the disk partition to
initialize;
+ some changes on the I/O routines to deal with partition offsets.
The latter was a bit tricky to implement, see the details in newfs.h:
in newfs, I/O is done through libufs which assumes that the file
descriptor refers to the whole partition. Introducing support for
the offset in libufs would require a non-backward compatible change
in the library, to be dealt with a version bump or with symbol
versioning.
I felt both approaches to be overkill for this specific application,
especially because there might be other changes to libufs that might
become necessary in the near future.
So I used the following trick:
- read access is always done by calling bread() directly, so we just add
the offset in the (few) places that call bread();
- write access is done through bwrite() and sbwrite(), which in turn
calls bwrite(). To avoid rewriting sbwrite(), we supply our own version
of bwrite() here, which takes precedence over the version in libufs.
MFC after: 4 weeks
2008-12-03 18:36:59 +00:00
|
|
|
bread(&disk, part_ofs + fsbtodb(&sblock, cgtod(&sblock, 0)), (char *)&acg,
|
2003-02-11 03:06:45 +00:00
|
|
|
sblock.fs_cgsize);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (acg.cg_magic != CG_MAGIC) {
|
|
|
|
printf("cg 0: bad magic number\n");
|
|
|
|
exit(31);
|
|
|
|
}
|
|
|
|
acg.cg_cs.cs_nifree--;
|
|
|
|
setbit(cg_inosused(&acg), ino);
|
2020-09-13 22:57:50 +00:00
|
|
|
if (cgwrite(&disk) != 0)
|
|
|
|
err(1, "iput: cgwrite: %s", disk.d_error);
|
1994-05-26 06:35:07 +00:00
|
|
|
sblock.fs_cstotal.cs_nifree--;
|
|
|
|
fscs[0].cs_nifree--;
|
2018-11-13 21:40:56 +00:00
|
|
|
if (getinode(&disk, &dp, ino) == -1) {
|
|
|
|
printf("iput: %s\n", disk.d_error);
|
1994-05-26 06:35:07 +00:00
|
|
|
exit(32);
|
|
|
|
}
|
2002-06-21 06:18:05 +00:00
|
|
|
if (sblock.fs_magic == FS_UFS1_MAGIC)
|
2018-11-13 21:40:56 +00:00
|
|
|
*dp.dp1 = ip->dp1;
|
2002-06-21 06:18:05 +00:00
|
|
|
else
|
2018-11-13 21:40:56 +00:00
|
|
|
*dp.dp2 = ip->dp2;
|
|
|
|
putinode(&disk);
|
2003-01-29 22:52:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2003-02-11 03:06:45 +00:00
|
|
|
* possibly write to disk
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
2002-04-03 20:48:05 +00:00
|
|
|
static void
|
2002-06-21 06:18:05 +00:00
|
|
|
wtfs(ufs2_daddr_t bno, int size, char *bf)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
if (Nflag)
|
|
|
|
return;
|
2009-02-12 15:28:15 +00:00
|
|
|
if (bwrite(&disk, part_ofs + bno, bf, size) < 0)
|
2003-05-10 18:58:17 +00:00
|
|
|
err(36, "wtfs: %d bytes at sector %jd", size, (intmax_t)bno);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check if a block is available
|
|
|
|
*/
|
2002-04-03 20:48:05 +00:00
|
|
|
static int
|
2002-03-19 17:20:02 +00:00
|
|
|
isblock(struct fs *fs, unsigned char *cp, int h)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
unsigned char mask;
|
|
|
|
|
|
|
|
switch (fs->fs_frag) {
|
|
|
|
case 8:
|
|
|
|
return (cp[h] == 0xff);
|
|
|
|
case 4:
|
|
|
|
mask = 0x0f << ((h & 0x1) << 2);
|
|
|
|
return ((cp[h >> 1] & mask) == mask);
|
|
|
|
case 2:
|
|
|
|
mask = 0x03 << ((h & 0x3) << 1);
|
|
|
|
return ((cp[h >> 2] & mask) == mask);
|
|
|
|
case 1:
|
|
|
|
mask = 0x01 << (h & 0x7);
|
|
|
|
return ((cp[h >> 3] & mask) == mask);
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* take a block out of the map
|
|
|
|
*/
|
2002-04-03 20:48:05 +00:00
|
|
|
static void
|
2002-03-19 17:20:02 +00:00
|
|
|
clrblock(struct fs *fs, unsigned char *cp, int h)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
switch ((fs)->fs_frag) {
|
|
|
|
case 8:
|
|
|
|
cp[h] = 0;
|
|
|
|
return;
|
|
|
|
case 4:
|
|
|
|
cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
|
|
|
|
return;
|
|
|
|
case 2:
|
|
|
|
cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
|
|
|
|
return;
|
|
|
|
case 1:
|
|
|
|
cp[h >> 3] &= ~(0x01 << (h & 0x7));
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* put a block into the map
|
|
|
|
*/
|
2002-04-03 20:48:05 +00:00
|
|
|
static void
|
2002-03-19 17:20:02 +00:00
|
|
|
setblock(struct fs *fs, unsigned char *cp, int h)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
switch (fs->fs_frag) {
|
|
|
|
case 8:
|
|
|
|
cp[h] = 0xff;
|
|
|
|
return;
|
|
|
|
case 4:
|
|
|
|
cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
|
|
|
|
return;
|
|
|
|
case 2:
|
|
|
|
cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
|
|
|
|
return;
|
|
|
|
case 1:
|
|
|
|
cp[h >> 3] |= (0x01 << (h & 0x7));
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
1996-01-25 23:44:32 +00:00
|
|
|
|
|
|
|
/*
|
1996-01-30 23:14:34 +00:00
|
|
|
* Determine the number of characters in a
|
1996-01-25 23:44:32 +00:00
|
|
|
* single line.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2002-03-19 20:01:38 +00:00
|
|
|
charsperline(void)
|
1996-01-25 23:44:32 +00:00
|
|
|
{
|
1996-01-30 23:14:34 +00:00
|
|
|
int columns;
|
1996-01-25 23:44:32 +00:00
|
|
|
char *cp;
|
|
|
|
struct winsize ws;
|
|
|
|
|
|
|
|
columns = 0;
|
|
|
|
if (ioctl(0, TIOCGWINSZ, &ws) != -1)
|
|
|
|
columns = ws.ws_col;
|
|
|
|
if (columns == 0 && (cp = getenv("COLUMNS")))
|
|
|
|
columns = atoi(cp);
|
|
|
|
if (columns == 0)
|
|
|
|
columns = 80; /* last resort */
|
2001-11-02 09:23:34 +00:00
|
|
|
return (columns);
|
1996-01-25 23:44:32 +00:00
|
|
|
}
|
2002-03-19 17:39:01 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
ilog2(int val)
|
|
|
|
{
|
2002-03-20 07:16:15 +00:00
|
|
|
u_int n;
|
2002-03-19 17:39:01 +00:00
|
|
|
|
2002-09-25 04:06:37 +00:00
|
|
|
for (n = 0; n < sizeof(n) * CHAR_BIT; n++)
|
2002-03-19 17:39:01 +00:00
|
|
|
if (1 << n == val)
|
|
|
|
return (n);
|
|
|
|
errx(1, "ilog2: %d is not a power of 2\n", val);
|
|
|
|
}
|
2003-02-22 23:26:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For the regression test, return predictable random values.
|
|
|
|
* Otherwise use a true random number generator.
|
|
|
|
*/
|
|
|
|
static u_int32_t
|
|
|
|
newfs_random(void)
|
|
|
|
{
|
|
|
|
static int nextnum = 1;
|
|
|
|
|
|
|
|
if (Rflag)
|
|
|
|
return (nextnum++);
|
|
|
|
return (arc4random());
|
|
|
|
}
|