2017-11-20 19:49:47 +00:00
|
|
|
/*-
|
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-26 06:35:07 +00:00
|
|
|
* Copyright (c) 1980, 1986, 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-12-03 02:41:11 +00:00
|
|
|
#if 0
|
2003-05-03 18:41:59 +00:00
|
|
|
#ifndef lint
|
1997-03-11 12:20:21 +00:00
|
|
|
static const char sccsid[] = "@(#)dir.c 8.8 (Berkeley) 4/28/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
|
|
|
|
|
|
|
#include <sys/param.h>
|
1998-12-03 02:27:35 +00:00
|
|
|
#include <sys/time.h>
|
2014-11-25 11:23:12 +00:00
|
|
|
#include <sys/types.h>
|
2001-03-21 09:48:03 +00:00
|
|
|
#include <sys/sysctl.h>
|
1997-03-11 12:20:21 +00:00
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <ufs/ufs/dinode.h>
|
|
|
|
#include <ufs/ufs/dir.h>
|
|
|
|
#include <ufs/ffs/fs.h>
|
1997-03-12 16:49:28 +00:00
|
|
|
|
1997-03-11 12:20:21 +00:00
|
|
|
#include <err.h>
|
1994-05-26 06:35:07 +00:00
|
|
|
#include <string.h>
|
1997-03-11 12:20:21 +00:00
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
#include "fsck.h"
|
|
|
|
|
2013-12-30 01:16:08 +00:00
|
|
|
static struct dirtemplate emptydir = {
|
2001-03-21 09:48:03 +00:00
|
|
|
0, DIRBLKSIZ, DT_UNKNOWN, 0, "",
|
|
|
|
0, 0, DT_UNKNOWN, 0, ""
|
|
|
|
};
|
2013-12-30 01:16:08 +00:00
|
|
|
static struct dirtemplate dirhead = {
|
1994-05-26 06:35:07 +00:00
|
|
|
0, 12, DT_DIR, 1, ".",
|
|
|
|
0, DIRBLKSIZ - 12, DT_DIR, 2, ".."
|
|
|
|
};
|
|
|
|
|
2002-03-20 22:57:10 +00:00
|
|
|
static int chgino(struct inodesc *);
|
2019-05-21 22:24:38 +00:00
|
|
|
static int dircheck(struct inodesc *, struct bufarea *, struct direct *);
|
2021-01-07 01:37:08 +00:00
|
|
|
static int expanddir(struct inode *ip, char *name);
|
2002-03-20 22:57:10 +00:00
|
|
|
static struct direct *fsck_readdir(struct inodesc *);
|
2002-06-21 06:18:05 +00:00
|
|
|
static struct bufarea *getdirblk(ufs2_daddr_t blkno, long size);
|
2002-03-20 22:57:10 +00:00
|
|
|
static int lftempname(char *bufp, ino_t ino);
|
|
|
|
static int mkentry(struct inodesc *);
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Propagate connected state through the tree.
|
|
|
|
*/
|
1995-04-02 14:52:29 +00:00
|
|
|
void
|
2002-03-20 22:57:10 +00:00
|
|
|
propagate(void)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-03-20 17:55:10 +00:00
|
|
|
struct inoinfo **inpp, *inp;
|
1994-05-26 06:35:07 +00:00
|
|
|
struct inoinfo **inpend;
|
|
|
|
long change;
|
|
|
|
|
|
|
|
inpend = &inpsort[inplast];
|
|
|
|
do {
|
|
|
|
change = 0;
|
|
|
|
for (inpp = inpsort; inpp < inpend; inpp++) {
|
|
|
|
inp = *inpp;
|
|
|
|
if (inp->i_parent == 0)
|
|
|
|
continue;
|
1998-12-03 02:27:35 +00:00
|
|
|
if (inoinfo(inp->i_parent)->ino_state == DFOUND &&
|
2004-10-08 20:44:47 +00:00
|
|
|
INO_IS_DUNFOUND(inp->i_number)) {
|
1998-12-03 02:27:35 +00:00
|
|
|
inoinfo(inp->i_number)->ino_state = DFOUND;
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
check_dirdepth(inp);
|
1994-05-26 06:35:07 +00:00
|
|
|
change++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (change > 0);
|
|
|
|
}
|
|
|
|
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
/*
|
|
|
|
* Check that the recorded depth of the directory is correct.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
check_dirdepth(struct inoinfo *inp)
|
|
|
|
{
|
|
|
|
struct inoinfo *parentinp;
|
|
|
|
struct inode ip;
|
|
|
|
union dinode *dp;
|
|
|
|
int saveresolved;
|
|
|
|
static int updateasked, dirdepthupdate;
|
|
|
|
|
|
|
|
if ((parentinp = getinoinfo(inp->i_parent)) == NULL) {
|
|
|
|
pfatal("check_dirdepth: UNKNOWN PARENT DIR");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If depth is correct, nothing to do.
|
|
|
|
*/
|
|
|
|
if (parentinp->i_depth + 1 == inp->i_depth)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Only the root inode should have depth of 0, so if any other
|
|
|
|
* directory has a depth of 0 then this is an old filesystem
|
|
|
|
* that has not been tracking directory depth. Ask just once
|
|
|
|
* whether it should start tracking directory depth.
|
|
|
|
*/
|
|
|
|
if (inp->i_depth == 0 && updateasked == 0) {
|
|
|
|
updateasked = 1;
|
|
|
|
if (preen) {
|
|
|
|
pwarn("UPDATING FILESYSTEM TO TRACK DIRECTORY DEPTH");
|
|
|
|
dirdepthupdate = 1;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The file system can be marked clean even if
|
|
|
|
* a directory does not have the right depth.
|
|
|
|
* Hence, resolved should not be cleared when
|
|
|
|
* the filesystem does not update directory depths.
|
|
|
|
*/
|
|
|
|
saveresolved = resolved;
|
|
|
|
dirdepthupdate =
|
|
|
|
reply("UPDATE FILESYSTEM TO TRACK DIRECTORY DEPTH");
|
|
|
|
resolved = saveresolved;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we are not converting, nothing more to do.
|
|
|
|
*/
|
|
|
|
if (inp->i_depth == 0 && dirdepthupdate == 0)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Individual directory at wrong depth. Report it and correct if
|
|
|
|
* in preen mode or ask if in interactive mode. Note that if a
|
|
|
|
* directory is renamed to a new location that is at a different
|
|
|
|
* level in the tree, its depth will be recalculated, but none of
|
|
|
|
* the directories that it contains will be updated. Thus it is
|
|
|
|
* not unexpected to find directories with incorrect depths. No
|
|
|
|
* operational harm will come from this though new directory
|
|
|
|
* placement in the subtree may not be as optimal until the depths
|
|
|
|
* of the affected directories are corrected.
|
|
|
|
*
|
|
|
|
* To avoid much spurious output on otherwise clean filesystems
|
|
|
|
* we only generate detailed output when the debug flag is given.
|
|
|
|
*/
|
|
|
|
ginode(inp->i_number, &ip);
|
|
|
|
dp = ip.i_dp;
|
|
|
|
if (inp->i_depth != 0 && debug) {
|
|
|
|
pwarn("DIRECTORY");
|
|
|
|
prtinode(&ip);
|
|
|
|
printf(" DEPTH %d SHOULD BE %d", inp->i_depth,
|
|
|
|
parentinp->i_depth + 1);
|
|
|
|
if (preen == 0 && reply("ADJUST") == 0) {
|
|
|
|
irelse(&ip);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (preen)
|
|
|
|
printf(" (ADJUSTED)\n");
|
|
|
|
}
|
|
|
|
inp->i_depth = parentinp->i_depth + 1;
|
|
|
|
DIP_SET(dp, di_dirdepth, inp->i_depth);
|
|
|
|
inodirty(&ip);
|
|
|
|
irelse(&ip);
|
|
|
|
}
|
|
|
|
|
1994-05-26 06:35:07 +00:00
|
|
|
/*
|
|
|
|
* Scan each entry in a directory block.
|
|
|
|
*/
|
1995-04-02 14:52:29 +00:00
|
|
|
int
|
2002-03-20 22:57:10 +00:00
|
|
|
dirscan(struct inodesc *idesc)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-03-20 17:55:10 +00:00
|
|
|
struct direct *dp;
|
|
|
|
struct bufarea *bp;
|
2001-03-21 09:48:03 +00:00
|
|
|
u_int dsize, n;
|
1994-05-26 06:35:07 +00:00
|
|
|
long blksiz;
|
|
|
|
char dbuf[DIRBLKSIZ];
|
|
|
|
|
|
|
|
if (idesc->id_type != DATA)
|
1997-03-11 12:20:21 +00:00
|
|
|
errx(EEXIT, "wrong type to dirscan %d", idesc->id_type);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (idesc->id_entryno == 0 &&
|
|
|
|
(idesc->id_filesize & (DIRBLKSIZ - 1)) != 0)
|
|
|
|
idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ);
|
|
|
|
blksiz = idesc->id_numfrags * sblock.fs_fsize;
|
|
|
|
if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
|
|
|
|
idesc->id_filesize -= blksiz;
|
|
|
|
return (SKIP);
|
|
|
|
}
|
|
|
|
idesc->id_loc = 0;
|
|
|
|
for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
|
|
|
|
dsize = dp->d_reclen;
|
1998-12-03 02:27:35 +00:00
|
|
|
if (dsize > sizeof(dbuf))
|
|
|
|
dsize = sizeof(dbuf);
|
1997-03-11 12:20:21 +00:00
|
|
|
memmove(dbuf, dp, (size_t)dsize);
|
1994-05-26 06:35:07 +00:00
|
|
|
idesc->id_dirp = (struct direct *)dbuf;
|
|
|
|
if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
|
|
|
|
bp = getdirblk(idesc->id_blkno, blksiz);
|
2021-01-07 01:37:08 +00:00
|
|
|
if (bp->b_errs != 0)
|
|
|
|
return (STOP);
|
1997-03-11 12:20:21 +00:00
|
|
|
memmove(bp->b_un.b_buf + idesc->id_loc - dsize, dbuf,
|
1994-05-26 06:35:07 +00:00
|
|
|
(size_t)dsize);
|
|
|
|
dirty(bp);
|
|
|
|
sbdirty();
|
|
|
|
}
|
1995-05-30 06:12:45 +00:00
|
|
|
if (n & STOP)
|
1994-05-26 06:35:07 +00:00
|
|
|
return (n);
|
|
|
|
}
|
|
|
|
return (idesc->id_filesize > 0 ? KEEPON : STOP);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2019-05-21 22:24:38 +00:00
|
|
|
* Get and verify the next entry in a directory.
|
|
|
|
* We also verify that if there is another entry in the block that it is
|
|
|
|
* valid, so if it is not valid it can be subsumed into the current entry.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
1997-03-11 12:20:21 +00:00
|
|
|
static struct direct *
|
2002-03-20 22:57:10 +00:00
|
|
|
fsck_readdir(struct inodesc *idesc)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-03-20 17:55:10 +00:00
|
|
|
struct direct *dp, *ndp;
|
|
|
|
struct bufarea *bp;
|
2019-05-21 22:24:38 +00:00
|
|
|
long size, blksiz, subsume_ndp;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2019-05-21 22:24:38 +00:00
|
|
|
subsume_ndp = 0;
|
1994-05-26 06:35:07 +00:00
|
|
|
blksiz = idesc->id_numfrags * sblock.fs_fsize;
|
2019-05-21 22:24:38 +00:00
|
|
|
if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
|
|
|
|
return (NULL);
|
1994-05-26 06:35:07 +00:00
|
|
|
bp = getdirblk(idesc->id_blkno, blksiz);
|
2021-01-07 01:37:08 +00:00
|
|
|
if (bp->b_errs != 0)
|
|
|
|
return (NULL);
|
2019-05-21 22:24:38 +00:00
|
|
|
dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
|
|
|
|
/*
|
|
|
|
* Only need to check current entry if it is the first in the
|
|
|
|
* the block, as later entries will have been checked in the
|
|
|
|
* previous call to this function.
|
|
|
|
*/
|
|
|
|
if (idesc->id_loc % DIRBLKSIZ != 0 || dircheck(idesc, bp, dp) != 0) {
|
|
|
|
/*
|
|
|
|
* Current entry is good, update to point at next.
|
|
|
|
*/
|
|
|
|
idesc->id_loc += dp->d_reclen;
|
|
|
|
idesc->id_filesize -= dp->d_reclen;
|
|
|
|
/*
|
|
|
|
* If at end of directory block, just return this entry.
|
|
|
|
*/
|
|
|
|
if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz ||
|
|
|
|
idesc->id_loc % DIRBLKSIZ == 0)
|
|
|
|
return (dp);
|
|
|
|
/*
|
|
|
|
* If the next entry good, return this entry.
|
|
|
|
*/
|
|
|
|
ndp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
|
|
|
|
if (dircheck(idesc, bp, ndp) != 0)
|
|
|
|
return (dp);
|
|
|
|
/*
|
|
|
|
* The next entry is bad, so subsume it and the remainder
|
|
|
|
* of this directory block into this entry.
|
|
|
|
*/
|
|
|
|
subsume_ndp = 1;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2019-05-21 22:24:38 +00:00
|
|
|
/*
|
|
|
|
* Current or next entry is bad. Zap current entry or
|
|
|
|
* subsume next entry into current entry as appropriate.
|
|
|
|
*/
|
|
|
|
size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
|
|
|
|
idesc->id_loc += size;
|
|
|
|
idesc->id_filesize -= size;
|
|
|
|
if (idesc->id_fix == IGNORE)
|
|
|
|
return (NULL);
|
|
|
|
if (subsume_ndp) {
|
|
|
|
memset(ndp, 0, size);
|
|
|
|
dp->d_reclen += size;
|
|
|
|
} else {
|
|
|
|
memset(dp, 0, size);
|
|
|
|
dp->d_reclen = size;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2019-05-21 22:24:38 +00:00
|
|
|
if (dofix(idesc, "DIRECTORY CORRUPTED"))
|
|
|
|
dirty(bp);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (dp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify that a directory entry is valid.
|
|
|
|
* This is a superset of the checks made in the kernel.
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
* Also optionally clears padding and unused directory space.
|
|
|
|
*
|
2019-05-21 22:24:38 +00:00
|
|
|
* Returns 0 if the entry is bad, 1 if the entry is good.
|
1994-05-26 06:35:07 +00:00
|
|
|
*/
|
1997-03-11 12:20:21 +00:00
|
|
|
static int
|
2019-05-21 22:24:38 +00:00
|
|
|
dircheck(struct inodesc *idesc, struct bufarea *bp, struct direct *dp)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2003-05-03 18:41:59 +00:00
|
|
|
size_t size;
|
2002-03-20 17:55:10 +00:00
|
|
|
char *cp;
|
2011-09-02 17:05:34 +00:00
|
|
|
u_int8_t namlen;
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
int spaceleft, modified, unused;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
|
2019-05-21 22:24:38 +00:00
|
|
|
size = DIRSIZ(0, dp);
|
1998-12-03 02:27:35 +00:00
|
|
|
if (dp->d_reclen == 0 ||
|
1997-03-11 12:20:21 +00:00
|
|
|
dp->d_reclen > spaceleft ||
|
2019-05-21 22:24:38 +00:00
|
|
|
dp->d_reclen < size ||
|
|
|
|
idesc->id_filesize < size ||
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
(dp->d_reclen & (DIR_ROUNDUP - 1)) != 0)
|
2000-07-06 02:03:11 +00:00
|
|
|
goto bad;
|
2019-05-21 22:24:38 +00:00
|
|
|
modified = 0;
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
if (dp->d_ino == 0) {
|
2019-05-21 22:24:38 +00:00
|
|
|
if (!zflag || fswritefd < 0)
|
|
|
|
return (1);
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
/*
|
2019-05-21 22:24:38 +00:00
|
|
|
* Special case of an unused directory entry. Normally only
|
|
|
|
* occurs at the beginning of a directory block when the block
|
|
|
|
* contains no entries. Other than the first entry in a
|
|
|
|
* directory block, the kernel coalesces unused space with
|
|
|
|
* the previous entry by extending its d_reclen. However,
|
|
|
|
* when cleaning up a directory, fsck may set d_ino to zero
|
|
|
|
* in the middle of a directory block. If we're clearing out
|
|
|
|
* directory cruft (-z flag), then make sure that all directory
|
|
|
|
* space in entries with d_ino == 0 gets fully cleared.
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
*/
|
2019-05-21 22:24:38 +00:00
|
|
|
if (dp->d_type != 0) {
|
|
|
|
dp->d_type = 0;
|
|
|
|
modified = 1;
|
|
|
|
}
|
|
|
|
if (dp->d_namlen != 0) {
|
|
|
|
dp->d_namlen = 0;
|
|
|
|
modified = 1;
|
|
|
|
}
|
|
|
|
unused = dp->d_reclen - __offsetof(struct direct, d_name);
|
|
|
|
for (cp = dp->d_name; unused > 0; unused--, cp++) {
|
|
|
|
if (*cp != '\0') {
|
|
|
|
*cp = '\0';
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
modified = 1;
|
|
|
|
}
|
|
|
|
}
|
2019-05-21 22:24:38 +00:00
|
|
|
if (modified)
|
|
|
|
dirty(bp);
|
|
|
|
return (1);
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
}
|
2019-05-21 22:24:38 +00:00
|
|
|
/*
|
|
|
|
* The d_type field should not be tested here. A bad type is an error
|
|
|
|
* in the entry itself but is not a corruption of the directory
|
|
|
|
* structure itself. So blowing away all the remaining entries in the
|
|
|
|
* directory block is inappropriate. Rather the type error should be
|
|
|
|
* checked in pass1 and fixed there.
|
|
|
|
*
|
|
|
|
* The name validation should also be done in pass1 although the
|
|
|
|
* check to see if the name is longer than fits in the space
|
|
|
|
* allocated for it (i.e., the *cp != '\0' fails after exiting the
|
|
|
|
* loop below) then it really is a structural error that requires
|
|
|
|
* the stronger action taken here.
|
|
|
|
*/
|
2002-05-12 23:44:15 +00:00
|
|
|
namlen = dp->d_namlen;
|
2019-05-21 22:24:38 +00:00
|
|
|
if (namlen == 0 || dp->d_type > 15)
|
2000-07-06 02:03:11 +00:00
|
|
|
goto bad;
|
2019-05-21 22:24:38 +00:00
|
|
|
for (cp = dp->d_name, size = 0; size < namlen; size++) {
|
|
|
|
if (*cp == '\0' || *cp++ == '/')
|
2000-07-06 02:03:11 +00:00
|
|
|
goto bad;
|
2019-05-21 22:24:38 +00:00
|
|
|
}
|
1997-03-11 12:20:21 +00:00
|
|
|
if (*cp != '\0')
|
2000-07-06 02:03:11 +00:00
|
|
|
goto bad;
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
if (zflag && fswritefd >= 0) {
|
|
|
|
/*
|
|
|
|
* Clear unused directory entry space, including the d_name
|
|
|
|
* padding.
|
|
|
|
*/
|
|
|
|
/* First figure the number of pad bytes. */
|
|
|
|
unused = roundup2(namlen + 1, DIR_ROUNDUP) - (namlen + 1);
|
|
|
|
|
|
|
|
/* Add in the free space to the end of the record. */
|
|
|
|
unused += dp->d_reclen - DIRSIZ(0, dp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now clear out the unused space, keeping track if we actually
|
|
|
|
* changed anything.
|
|
|
|
*/
|
|
|
|
for (cp = &dp->d_name[namlen + 1]; unused > 0; unused--, cp++) {
|
|
|
|
if (*cp != '\0') {
|
|
|
|
*cp = '\0';
|
|
|
|
modified = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-21 22:24:38 +00:00
|
|
|
if (modified)
|
|
|
|
dirty(bp);
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
}
|
1997-03-11 12:20:21 +00:00
|
|
|
return (1);
|
This update eliminates a kernel stack disclosure bug in UFS/FFS
directory entries that is caused by uninitialized directory entry
padding written to the disk. It can be viewed by any user with read
access to that directory. Up to 3 bytes of kernel stack are disclosed
per file entry, depending on the the amount of padding the kernel
needs to pad out the entry to a 32 bit boundry. The offset in the
kernel stack that is disclosed is a function of the filename size.
Furthermore, if the user can create files in a directory, this 3
byte window can be expanded 3 bytes at a time to a 254 byte window
with 75% of the data in that window exposed. The additional exposure
is done by removing the entry, creating a new entry with a 4-byte
longer name, extracting 3 more bytes by reading the directory, and
repeating until a 252 byte name is created.
This exploit works in part because the area of the kernel stack
that is being disclosed is in an area that typically doesn't change
that often (perhaps a few times a second on a lightly loaded system),
and these file creates and unlinks themselves don't overwrite the
area of kernel stack being disclosed.
It appears that this bug originated with the creation of the Fast
File System in 4.1b-BSD (Circa 1982, more than 36 years ago!), and
is likely present in every Unix or Unix-like system that uses
UFS/FFS. Amazingly, nobody noticed until now.
This update also adds the -z flag to fsck_ffs to have it scrub
the leaked information in the name padding of existing directories.
It only needs to be run once on each UFS/FFS filesystem after a
patched kernel is installed and running.
Submitted by: David G. Lawrence <dg@dglawrence.com>
Reviewed by: kib
MFC after: 1 week
2019-05-03 21:54:14 +00:00
|
|
|
|
2000-07-06 02:03:11 +00:00
|
|
|
bad:
|
|
|
|
if (debug)
|
|
|
|
printf("Bad dir: ino %d reclen %d namlen %d type %d name %s\n",
|
|
|
|
dp->d_ino, dp->d_reclen, dp->d_namlen, dp->d_type,
|
|
|
|
dp->d_name);
|
|
|
|
return (0);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
1995-04-02 14:52:29 +00:00
|
|
|
void
|
2002-07-30 13:01:25 +00:00
|
|
|
direrror(ino_t ino, const char *errmesg)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
fileerror(ino, ino, errmesg);
|
|
|
|
}
|
|
|
|
|
1995-04-02 14:52:29 +00:00
|
|
|
void
|
2002-07-30 13:01:25 +00:00
|
|
|
fileerror(ino_t cwd, ino_t ino, const char *errmesg)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2021-01-07 01:37:08 +00:00
|
|
|
struct inode ip;
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode *dp;
|
1994-05-26 06:35:07 +00:00
|
|
|
char pathbuf[MAXPATHLEN + 1];
|
|
|
|
|
|
|
|
pwarn("%s ", errmesg);
|
2017-02-15 19:50:26 +00:00
|
|
|
if (ino < UFS_ROOTINO || ino > maxino) {
|
2018-11-13 21:40:56 +00:00
|
|
|
pfatal("out-of-range inode number %ju", (uintmax_t)ino);
|
1994-05-26 06:35:07 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(ino, &ip);
|
|
|
|
dp = ip.i_dp;
|
|
|
|
prtinode(&ip);
|
2018-11-13 21:40:56 +00:00
|
|
|
printf("\n");
|
|
|
|
getpathname(pathbuf, cwd, ino);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (ftypeok(dp))
|
|
|
|
pfatal("%s=%s\n",
|
2018-03-17 12:59:55 +00:00
|
|
|
(DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE",
|
2002-06-21 06:18:05 +00:00
|
|
|
pathbuf);
|
1994-05-26 06:35:07 +00:00
|
|
|
else
|
|
|
|
pfatal("NAME=%s\n", pathbuf);
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
1995-04-02 14:52:29 +00:00
|
|
|
void
|
2002-03-20 22:57:10 +00:00
|
|
|
adjust(struct inodesc *idesc, int lcnt)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2021-01-07 01:37:08 +00:00
|
|
|
struct inode ip;
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode *dp;
|
1998-12-03 02:27:35 +00:00
|
|
|
int saveresolved;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(idesc->id_number, &ip);
|
|
|
|
dp = ip.i_dp;
|
2002-06-21 06:18:05 +00:00
|
|
|
if (DIP(dp, di_nlink) == lcnt) {
|
1998-12-03 02:27:35 +00:00
|
|
|
/*
|
|
|
|
* If we have not hit any unresolved problems, are running
|
2002-08-21 18:11:48 +00:00
|
|
|
* in preen mode, and are on a file system using soft updates,
|
1998-12-03 02:27:35 +00:00
|
|
|
* then just toss any partially allocated files.
|
|
|
|
*/
|
2001-03-21 09:48:03 +00:00
|
|
|
if (resolved && (preen || bkgrdflag) && usedsoftdep) {
|
1998-12-03 02:27:35 +00:00
|
|
|
clri(idesc, "UNREF", 1);
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1998-12-03 02:27:35 +00:00
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
/*
|
2002-08-21 18:11:48 +00:00
|
|
|
* The file system can be marked clean even if
|
1998-12-03 02:27:35 +00:00
|
|
|
* a file is not linked up, but is cleared.
|
|
|
|
* Hence, resolved should not be cleared when
|
|
|
|
* linkup is answered no, but clri is answered yes.
|
|
|
|
*/
|
|
|
|
saveresolved = resolved;
|
|
|
|
if (linkup(idesc->id_number, (ino_t)0, NULL) == 0) {
|
|
|
|
resolved = saveresolved;
|
|
|
|
clri(idesc, "UNREF", 0);
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1998-12-03 02:27:35 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Account for the new reference created by linkup().
|
|
|
|
*/
|
|
|
|
lcnt--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (lcnt != 0) {
|
1994-05-26 06:35:07 +00:00
|
|
|
pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname :
|
2018-03-17 12:59:55 +00:00
|
|
|
((DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE"));
|
2021-01-07 01:37:08 +00:00
|
|
|
prtinode(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
printf(" COUNT %d SHOULD BE %d",
|
2002-06-21 06:18:05 +00:00
|
|
|
DIP(dp, di_nlink), DIP(dp, di_nlink) - lcnt);
|
1998-03-08 09:59:44 +00:00
|
|
|
if (preen || usedsoftdep) {
|
1994-05-26 06:35:07 +00:00
|
|
|
if (lcnt < 0) {
|
|
|
|
printf("\n");
|
|
|
|
pfatal("LINK COUNT INCREASING");
|
|
|
|
}
|
1998-03-08 09:59:44 +00:00
|
|
|
if (preen)
|
|
|
|
printf(" (ADJUSTED)\n");
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
if (preen || reply("ADJUST") == 1) {
|
2001-03-21 09:48:03 +00:00
|
|
|
if (bkgrdflag == 0) {
|
2004-09-01 05:48:06 +00:00
|
|
|
DIP_SET(dp, di_nlink, DIP(dp, di_nlink) - lcnt);
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(&ip);
|
2001-03-21 09:48:03 +00:00
|
|
|
} else {
|
|
|
|
cmd.value = idesc->id_number;
|
|
|
|
cmd.size = -lcnt;
|
|
|
|
if (debug)
|
2002-07-30 13:01:25 +00:00
|
|
|
printf("adjrefcnt ino %ld amt %lld\n",
|
|
|
|
(long)cmd.value,
|
|
|
|
(long long)cmd.size);
|
2001-03-21 09:48:03 +00:00
|
|
|
if (sysctl(adjrefcnt, MIBSIZE, 0, 0,
|
|
|
|
&cmd, sizeof cmd) == -1)
|
|
|
|
rwerror("ADJUST INODE", cmd.value);
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
1997-03-11 12:20:21 +00:00
|
|
|
static int
|
2002-03-20 22:57:10 +00:00
|
|
|
mkentry(struct inodesc *idesc)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-03-20 17:55:10 +00:00
|
|
|
struct direct *dirp = idesc->id_dirp;
|
1994-05-26 06:35:07 +00:00
|
|
|
struct direct newent;
|
|
|
|
int newlen, oldlen;
|
|
|
|
|
|
|
|
newent.d_namlen = strlen(idesc->id_name);
|
|
|
|
newlen = DIRSIZ(0, &newent);
|
|
|
|
if (dirp->d_ino != 0)
|
|
|
|
oldlen = DIRSIZ(0, dirp);
|
|
|
|
else
|
|
|
|
oldlen = 0;
|
|
|
|
if (dirp->d_reclen - oldlen < newlen)
|
|
|
|
return (KEEPON);
|
|
|
|
newent.d_reclen = dirp->d_reclen - oldlen;
|
|
|
|
dirp->d_reclen = oldlen;
|
|
|
|
dirp = (struct direct *)(((char *)dirp) + oldlen);
|
|
|
|
dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
|
|
|
|
dirp->d_reclen = newent.d_reclen;
|
2002-05-12 23:44:15 +00:00
|
|
|
dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
|
1997-03-11 12:20:21 +00:00
|
|
|
dirp->d_namlen = newent.d_namlen;
|
|
|
|
memmove(dirp->d_name, idesc->id_name, (size_t)newent.d_namlen + 1);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (ALTERED|STOP);
|
|
|
|
}
|
|
|
|
|
1997-03-11 12:20:21 +00:00
|
|
|
static int
|
2002-03-20 22:57:10 +00:00
|
|
|
chgino(struct inodesc *idesc)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-03-20 17:55:10 +00:00
|
|
|
struct direct *dirp = idesc->id_dirp;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
1997-03-11 12:20:21 +00:00
|
|
|
if (memcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
|
1994-05-26 06:35:07 +00:00
|
|
|
return (KEEPON);
|
|
|
|
dirp->d_ino = idesc->id_parent;
|
2002-05-12 23:44:15 +00:00
|
|
|
dirp->d_type = inoinfo(idesc->id_parent)->ino_type;
|
1994-05-26 06:35:07 +00:00
|
|
|
return (ALTERED|STOP);
|
|
|
|
}
|
|
|
|
|
1995-04-02 14:52:29 +00:00
|
|
|
int
|
2002-03-20 22:57:10 +00:00
|
|
|
linkup(ino_t orphan, ino_t parentdir, char *name)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2021-01-07 01:37:08 +00:00
|
|
|
struct inode ip;
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode *dp;
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
int lostdir, depth;
|
1994-05-26 06:35:07 +00:00
|
|
|
ino_t oldlfdir;
|
2022-09-03 21:46:50 +00:00
|
|
|
struct inoinfo *inp;
|
1994-05-26 06:35:07 +00:00
|
|
|
struct inodesc idesc;
|
|
|
|
char tempname[BUFSIZ];
|
|
|
|
|
1997-03-11 12:20:21 +00:00
|
|
|
memset(&idesc, 0, sizeof(struct inodesc));
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(orphan, &ip);
|
|
|
|
dp = ip.i_dp;
|
2018-03-17 12:59:55 +00:00
|
|
|
lostdir = (DIP(dp, di_mode) & IFMT) == IFDIR;
|
1994-05-26 06:35:07 +00:00
|
|
|
pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
|
2021-01-07 01:37:08 +00:00
|
|
|
prtinode(&ip);
|
2018-11-13 21:40:56 +00:00
|
|
|
printf("\n");
|
2021-01-07 01:37:08 +00:00
|
|
|
if (preen && DIP(dp, di_size) == 0) {
|
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
2021-01-07 01:37:08 +00:00
|
|
|
}
|
|
|
|
irelse(&ip);
|
2001-03-21 09:48:03 +00:00
|
|
|
if (cursnapshot != 0) {
|
|
|
|
pfatal("FILE LINKUP IN SNAPSHOT");
|
|
|
|
return (0);
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
if (preen)
|
|
|
|
printf(" (RECONNECTED)\n");
|
2021-01-07 01:37:08 +00:00
|
|
|
else if (reply("RECONNECT") == 0)
|
|
|
|
return (0);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (lfdir == 0) {
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(UFS_ROOTINO, &ip);
|
2002-07-30 13:01:25 +00:00
|
|
|
idesc.id_name = strdup(lfname);
|
1994-05-26 06:35:07 +00:00
|
|
|
idesc.id_type = DATA;
|
|
|
|
idesc.id_func = findino;
|
2017-02-15 19:50:26 +00:00
|
|
|
idesc.id_number = UFS_ROOTINO;
|
2021-01-07 01:37:08 +00:00
|
|
|
if ((ckinode(ip.i_dp, &idesc) & FOUND) != 0) {
|
1994-05-26 06:35:07 +00:00
|
|
|
lfdir = idesc.id_parent;
|
|
|
|
} else {
|
|
|
|
pwarn("NO lost+found DIRECTORY");
|
|
|
|
if (preen || reply("CREATE")) {
|
2017-02-15 19:50:26 +00:00
|
|
|
lfdir = allocdir(UFS_ROOTINO, (ino_t)0, lfmode);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (lfdir != 0) {
|
2017-02-15 19:50:26 +00:00
|
|
|
if (makeentry(UFS_ROOTINO, lfdir,
|
|
|
|
lfname) != 0) {
|
1998-12-03 02:27:35 +00:00
|
|
|
numdirs++;
|
1994-05-26 06:35:07 +00:00
|
|
|
if (preen)
|
|
|
|
printf(" (CREATED)\n");
|
|
|
|
} else {
|
2023-03-07 23:12:37 +00:00
|
|
|
freedirino(lfdir, UFS_ROOTINO);
|
1994-05-26 06:35:07 +00:00
|
|
|
lfdir = 0;
|
|
|
|
if (preen)
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
2023-03-22 22:57:26 +00:00
|
|
|
free(idesc.id_name);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (lfdir == 0) {
|
|
|
|
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY");
|
|
|
|
printf("\n\n");
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(lfdir, &ip);
|
|
|
|
dp = ip.i_dp;
|
2018-03-17 12:59:55 +00:00
|
|
|
if ((DIP(dp, di_mode) & IFMT) != IFDIR) {
|
1994-05-26 06:35:07 +00:00
|
|
|
pfatal("lost+found IS NOT A DIRECTORY");
|
2021-01-07 01:37:08 +00:00
|
|
|
if (reply("REALLOCATE") == 0) {
|
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
2021-01-07 01:37:08 +00:00
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
oldlfdir = lfdir;
|
2017-02-15 19:50:26 +00:00
|
|
|
if ((lfdir = allocdir(UFS_ROOTINO, (ino_t)0, lfmode)) == 0) {
|
1994-05-26 06:35:07 +00:00
|
|
|
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
|
|
|
}
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
if ((changeino(UFS_ROOTINO, lfname, lfdir, 1) & ALTERED) == 0) {
|
1994-05-26 06:35:07 +00:00
|
|
|
pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n");
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
idesc.id_type = inoinfo(oldlfdir)->ino_idtype;
|
2020-12-18 23:28:27 +00:00
|
|
|
idesc.id_func = freeblock;
|
1994-05-26 06:35:07 +00:00
|
|
|
idesc.id_number = oldlfdir;
|
1998-12-03 02:27:35 +00:00
|
|
|
adjust(&idesc, inoinfo(oldlfdir)->ino_linkcnt + 1);
|
|
|
|
inoinfo(oldlfdir)->ino_linkcnt = 0;
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(&ip);
|
|
|
|
irelse(&ip);
|
|
|
|
ginode(lfdir, &ip);
|
|
|
|
dp = ip.i_dp;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
1998-12-03 02:27:35 +00:00
|
|
|
if (inoinfo(lfdir)->ino_state != DFOUND) {
|
1994-05-26 06:35:07 +00:00
|
|
|
pfatal("SORRY. NO lost+found DIRECTORY\n\n");
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
(void)lftempname(tempname, orphan);
|
1998-12-03 02:27:35 +00:00
|
|
|
if (makeentry(lfdir, orphan, (name ? name : tempname)) == 0) {
|
1994-05-26 06:35:07 +00:00
|
|
|
pfatal("SORRY. NO SPACE IN lost+found DIRECTORY");
|
|
|
|
printf("\n\n");
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
|
|
|
}
|
1998-12-03 02:27:35 +00:00
|
|
|
inoinfo(orphan)->ino_linkcnt--;
|
1994-05-26 06:35:07 +00:00
|
|
|
if (lostdir) {
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
depth = DIP(dp, di_dirdepth) + 1;
|
|
|
|
if ((changeino(orphan, "..", lfdir, depth) & ALTERED) == 0 &&
|
1994-05-26 06:35:07 +00:00
|
|
|
parentdir != (ino_t)-1)
|
|
|
|
(void)makeentry(orphan, lfdir, "..");
|
2004-09-01 05:48:06 +00:00
|
|
|
DIP_SET(dp, di_nlink, DIP(dp, di_nlink) + 1);
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(&ip);
|
1998-12-03 02:27:35 +00:00
|
|
|
inoinfo(lfdir)->ino_linkcnt++;
|
2001-11-17 23:48:21 +00:00
|
|
|
pwarn("DIR I=%lu CONNECTED. ", (u_long)orphan);
|
2022-09-03 21:46:50 +00:00
|
|
|
inp = getinoinfo(parentdir);
|
2023-03-07 23:12:37 +00:00
|
|
|
if (parentdir != (ino_t)-1 && inp != NULL) {
|
1998-06-28 19:23:03 +00:00
|
|
|
printf("PARENT WAS I=%lu\n", (u_long)parentdir);
|
1998-12-03 02:41:11 +00:00
|
|
|
/*
|
2022-09-03 21:46:50 +00:00
|
|
|
* If the parent directory did not have to
|
|
|
|
* be replaced then because of the ordering
|
1998-12-03 02:41:11 +00:00
|
|
|
* guarantees, has had the link count incremented
|
|
|
|
* for the child, but no entry was made. This
|
|
|
|
* fixes the parent link count so that fsck does
|
|
|
|
* not need to be rerun.
|
|
|
|
*/
|
2023-03-07 23:12:37 +00:00
|
|
|
if ((inp->i_flags & INFO_NEW) != 0)
|
|
|
|
inoinfo(parentdir)->ino_linkcnt++;
|
1996-05-09 16:38:27 +00:00
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
if (preen == 0)
|
|
|
|
printf("\n");
|
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fix an entry in a directory.
|
|
|
|
*/
|
1995-04-02 14:52:29 +00:00
|
|
|
int
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
changeino(ino_t dir, const char *name, ino_t newnum, int depth)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
struct inodesc idesc;
|
2021-01-07 01:37:08 +00:00
|
|
|
struct inode ip;
|
|
|
|
int error;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
1997-03-11 12:20:21 +00:00
|
|
|
memset(&idesc, 0, sizeof(struct inodesc));
|
1994-05-26 06:35:07 +00:00
|
|
|
idesc.id_type = DATA;
|
|
|
|
idesc.id_func = chgino;
|
|
|
|
idesc.id_number = dir;
|
|
|
|
idesc.id_fix = DONTKNOW;
|
2002-07-30 13:01:25 +00:00
|
|
|
idesc.id_name = strdup(name);
|
1994-05-26 06:35:07 +00:00
|
|
|
idesc.id_parent = newnum; /* new value for name */
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(dir, &ip);
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
if (((error = ckinode(ip.i_dp, &idesc)) & ALTERED) && newnum != 0) {
|
|
|
|
DIP_SET(ip.i_dp, di_dirdepth, depth);
|
|
|
|
getinoinfo(dir)->i_depth = depth;
|
|
|
|
}
|
2023-03-22 22:57:26 +00:00
|
|
|
free(idesc.id_name);
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
|
|
|
return (error);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* make an entry in a directory
|
|
|
|
*/
|
1995-04-02 14:52:29 +00:00
|
|
|
int
|
2002-07-30 13:01:25 +00:00
|
|
|
makeentry(ino_t parent, ino_t ino, const char *name)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2021-01-07 01:37:08 +00:00
|
|
|
struct inode ip;
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode *dp;
|
1994-05-26 06:35:07 +00:00
|
|
|
struct inodesc idesc;
|
2021-01-07 01:37:08 +00:00
|
|
|
int retval;
|
1994-05-26 06:35:07 +00:00
|
|
|
char pathbuf[MAXPATHLEN + 1];
|
1995-05-30 06:12:45 +00:00
|
|
|
|
2017-02-15 19:50:26 +00:00
|
|
|
if (parent < UFS_ROOTINO || parent >= maxino ||
|
|
|
|
ino < UFS_ROOTINO || ino >= maxino)
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
1997-03-11 12:20:21 +00:00
|
|
|
memset(&idesc, 0, sizeof(struct inodesc));
|
1994-05-26 06:35:07 +00:00
|
|
|
idesc.id_type = DATA;
|
|
|
|
idesc.id_func = mkentry;
|
|
|
|
idesc.id_number = parent;
|
|
|
|
idesc.id_parent = ino; /* this is the inode to enter */
|
|
|
|
idesc.id_fix = DONTKNOW;
|
2002-07-30 13:01:25 +00:00
|
|
|
idesc.id_name = strdup(name);
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(parent, &ip);
|
|
|
|
dp = ip.i_dp;
|
2002-06-21 06:18:05 +00:00
|
|
|
if (DIP(dp, di_size) % DIRBLKSIZ) {
|
2004-09-01 05:48:06 +00:00
|
|
|
DIP_SET(dp, di_size, roundup(DIP(dp, di_size), DIRBLKSIZ));
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
if ((ckinode(dp, &idesc) & ALTERED) != 0) {
|
|
|
|
irelse(&ip);
|
2023-03-22 22:57:26 +00:00
|
|
|
free(idesc.id_name);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (1);
|
2021-01-07 01:37:08 +00:00
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
getpathname(pathbuf, parent, parent);
|
2021-01-07 01:37:08 +00:00
|
|
|
if (expanddir(&ip, pathbuf) == 0) {
|
|
|
|
irelse(&ip);
|
2023-03-22 22:57:26 +00:00
|
|
|
free(idesc.id_name);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
2021-01-07 01:37:08 +00:00
|
|
|
}
|
|
|
|
retval = ckinode(dp, &idesc) & ALTERED;
|
|
|
|
irelse(&ip);
|
2023-03-22 22:57:26 +00:00
|
|
|
free(idesc.id_name);
|
2021-01-07 01:37:08 +00:00
|
|
|
return (retval);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to expand the size of a directory
|
|
|
|
*/
|
1997-03-11 12:20:21 +00:00
|
|
|
static int
|
2021-01-07 01:37:08 +00:00
|
|
|
expanddir(struct inode *ip, char *name)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2021-01-03 06:31:55 +00:00
|
|
|
ufs2_daddr_t lastlbn, oldblk, newblk, indirblk;
|
|
|
|
size_t filesize, lastlbnsize;
|
|
|
|
struct bufarea *bp, *nbp;
|
2020-12-18 23:28:27 +00:00
|
|
|
struct inodesc idesc;
|
2021-01-07 01:37:08 +00:00
|
|
|
union dinode *dp;
|
2022-11-09 18:44:03 +00:00
|
|
|
long cg, indiralloced;
|
2021-01-03 06:31:55 +00:00
|
|
|
char *cp;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2021-01-03 06:31:55 +00:00
|
|
|
nbp = NULL;
|
|
|
|
indiralloced = newblk = indirblk = 0;
|
2022-11-09 18:44:03 +00:00
|
|
|
memset(&idesc, 0, sizeof(struct inodesc));
|
|
|
|
idesc.id_type = ADDR;
|
2021-01-03 06:31:55 +00:00
|
|
|
pwarn("NO SPACE LEFT IN %s", name);
|
|
|
|
if (!preen && reply("EXPAND") == 0)
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
2022-11-09 18:44:03 +00:00
|
|
|
cg = ino_to_cg(&sblock, ip->i_number);
|
2021-01-07 01:37:08 +00:00
|
|
|
dp = ip->i_dp;
|
2021-01-03 06:31:55 +00:00
|
|
|
filesize = DIP(dp, di_size);
|
|
|
|
lastlbn = lblkno(&sblock, filesize);
|
|
|
|
/*
|
|
|
|
* We only expand lost+found to a single indirect block.
|
|
|
|
*/
|
|
|
|
if ((DIP(dp, di_mode) & IFMT) != IFDIR || filesize == 0 ||
|
|
|
|
lastlbn >= UFS_NDADDR + NINDIR(&sblock))
|
|
|
|
goto bad;
|
|
|
|
/*
|
|
|
|
* If last block is a fragment, expand it to a full size block.
|
|
|
|
*/
|
|
|
|
lastlbnsize = sblksize(&sblock, filesize, lastlbn);
|
2021-01-07 00:31:33 +00:00
|
|
|
if (lastlbnsize > 0 && lastlbnsize < sblock.fs_bsize) {
|
2021-01-03 06:31:55 +00:00
|
|
|
oldblk = DIP(dp, di_db[lastlbn]);
|
|
|
|
bp = getdirblk(oldblk, lastlbnsize);
|
|
|
|
if (bp->b_errs)
|
|
|
|
goto bad;
|
2022-11-09 18:44:03 +00:00
|
|
|
newblk = allocblk(cg, sblock.fs_frag, std_checkblkavail);
|
|
|
|
if (newblk == 0)
|
2021-01-03 06:31:55 +00:00
|
|
|
goto bad;
|
|
|
|
nbp = getdatablk(newblk, sblock.fs_bsize, BT_DIRDATA);
|
|
|
|
if (nbp->b_errs)
|
|
|
|
goto bad;
|
|
|
|
DIP_SET(dp, di_db[lastlbn], newblk);
|
|
|
|
DIP_SET(dp, di_size, filesize + sblock.fs_bsize - lastlbnsize);
|
|
|
|
DIP_SET(dp, di_blocks, DIP(dp, di_blocks) +
|
|
|
|
btodb(sblock.fs_bsize - lastlbnsize));
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(ip);
|
2021-01-03 06:31:55 +00:00
|
|
|
memmove(nbp->b_un.b_buf, bp->b_un.b_buf, lastlbnsize);
|
|
|
|
memset(&nbp->b_un.b_buf[lastlbnsize], 0,
|
|
|
|
sblock.fs_bsize - lastlbnsize);
|
|
|
|
for (cp = &nbp->b_un.b_buf[lastlbnsize];
|
|
|
|
cp < &nbp->b_un.b_buf[sblock.fs_bsize];
|
|
|
|
cp += DIRBLKSIZ)
|
|
|
|
memmove(cp, &emptydir, sizeof emptydir);
|
|
|
|
dirty(nbp);
|
2021-01-07 01:37:08 +00:00
|
|
|
brelse(nbp);
|
2022-11-09 18:44:03 +00:00
|
|
|
binval(bp);
|
2021-01-03 06:31:55 +00:00
|
|
|
idesc.id_blkno = oldblk;
|
|
|
|
idesc.id_numfrags = numfrags(&sblock, lastlbnsize);
|
|
|
|
(void)freeblock(&idesc);
|
2021-01-07 01:37:08 +00:00
|
|
|
if (preen)
|
|
|
|
printf(" (EXPANDED)\n");
|
2021-01-03 06:31:55 +00:00
|
|
|
return (1);
|
|
|
|
}
|
2022-11-09 18:44:03 +00:00
|
|
|
if ((newblk = allocblk(cg, sblock.fs_frag, std_checkblkavail)) == 0)
|
1994-05-26 06:35:07 +00:00
|
|
|
goto bad;
|
|
|
|
bp = getdirblk(newblk, sblock.fs_bsize);
|
|
|
|
if (bp->b_errs)
|
|
|
|
goto bad;
|
2021-01-03 06:31:55 +00:00
|
|
|
memset(bp->b_un.b_buf, 0, sblock.fs_bsize);
|
|
|
|
for (cp = bp->b_un.b_buf;
|
1994-05-26 06:35:07 +00:00
|
|
|
cp < &bp->b_un.b_buf[sblock.fs_bsize];
|
|
|
|
cp += DIRBLKSIZ)
|
1997-03-11 12:20:21 +00:00
|
|
|
memmove(cp, &emptydir, sizeof emptydir);
|
1994-05-26 06:35:07 +00:00
|
|
|
dirty(bp);
|
2021-01-03 06:31:55 +00:00
|
|
|
if (lastlbn < UFS_NDADDR) {
|
|
|
|
DIP_SET(dp, di_db[lastlbn], newblk);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Allocate indirect block if needed.
|
|
|
|
*/
|
|
|
|
if ((indirblk = DIP(dp, di_ib[0])) == 0) {
|
2022-11-09 18:44:03 +00:00
|
|
|
indirblk = allocblk(cg, sblock.fs_frag,
|
|
|
|
std_checkblkavail);
|
|
|
|
if (indirblk == 0) {
|
|
|
|
binval(bp);
|
2021-01-03 06:31:55 +00:00
|
|
|
goto bad;
|
2022-11-09 18:44:03 +00:00
|
|
|
}
|
2021-01-03 06:31:55 +00:00
|
|
|
indiralloced = 1;
|
|
|
|
}
|
|
|
|
nbp = getdatablk(indirblk, sblock.fs_bsize, BT_LEVEL1);
|
|
|
|
if (nbp->b_errs)
|
|
|
|
goto bad;
|
|
|
|
if (indiralloced) {
|
|
|
|
memset(nbp->b_un.b_buf, 0, sblock.fs_bsize);
|
|
|
|
DIP_SET(dp, di_ib[0], indirblk);
|
|
|
|
DIP_SET(dp, di_blocks,
|
|
|
|
DIP(dp, di_blocks) + btodb(sblock.fs_bsize));
|
|
|
|
}
|
|
|
|
IBLK_SET(nbp, lastlbn - UFS_NDADDR, newblk);
|
|
|
|
dirty(nbp);
|
2021-01-07 01:37:08 +00:00
|
|
|
brelse(nbp);
|
2021-01-03 06:31:55 +00:00
|
|
|
}
|
|
|
|
DIP_SET(dp, di_size, filesize + sblock.fs_bsize);
|
|
|
|
DIP_SET(dp, di_blocks, DIP(dp, di_blocks) + btodb(sblock.fs_bsize));
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (preen)
|
|
|
|
printf(" (EXPANDED)\n");
|
|
|
|
return (1);
|
|
|
|
bad:
|
2021-01-03 06:31:55 +00:00
|
|
|
pfatal(" (EXPANSION FAILED)\n");
|
2022-11-09 18:44:03 +00:00
|
|
|
if (nbp != NULL) {
|
|
|
|
binval(bp);
|
2021-01-07 01:37:08 +00:00
|
|
|
brelse(nbp);
|
2022-11-09 18:44:03 +00:00
|
|
|
}
|
2021-01-03 06:31:55 +00:00
|
|
|
if (newblk != 0) {
|
|
|
|
idesc.id_blkno = newblk;
|
|
|
|
idesc.id_numfrags = sblock.fs_frag;
|
|
|
|
(void)freeblock(&idesc);
|
|
|
|
}
|
|
|
|
if (indiralloced) {
|
|
|
|
idesc.id_blkno = indirblk;
|
|
|
|
idesc.id_numfrags = sblock.fs_frag;
|
|
|
|
(void)freeblock(&idesc);
|
|
|
|
}
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate a new directory
|
|
|
|
*/
|
1995-04-02 15:25:19 +00:00
|
|
|
ino_t
|
2002-03-20 22:57:10 +00:00
|
|
|
allocdir(ino_t parent, ino_t request, int mode)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
ino_t ino;
|
|
|
|
char *cp;
|
2021-01-07 01:37:08 +00:00
|
|
|
struct inode ip;
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode *dp;
|
2000-07-24 19:50:20 +00:00
|
|
|
struct bufarea *bp;
|
1994-05-26 06:35:07 +00:00
|
|
|
struct dirtemplate *dirp;
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
struct inoinfo *inp, *parentinp;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
2018-03-17 12:59:55 +00:00
|
|
|
ino = allocino(request, IFDIR|mode);
|
2021-04-26 23:47:27 +00:00
|
|
|
if (ino == 0)
|
|
|
|
return (0);
|
2002-05-12 23:44:15 +00:00
|
|
|
dirp = &dirhead;
|
1994-05-26 06:35:07 +00:00
|
|
|
dirp->dot_ino = ino;
|
|
|
|
dirp->dotdot_ino = parent;
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(ino, &ip);
|
|
|
|
dp = ip.i_dp;
|
2002-06-21 06:18:05 +00:00
|
|
|
bp = getdirblk(DIP(dp, di_db[0]), sblock.fs_fsize);
|
1994-05-26 06:35:07 +00:00
|
|
|
if (bp->b_errs) {
|
|
|
|
freeino(ino);
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
|
|
|
}
|
1997-03-11 12:20:21 +00:00
|
|
|
memmove(bp->b_un.b_buf, dirp, sizeof(struct dirtemplate));
|
1994-05-26 06:35:07 +00:00
|
|
|
for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
|
|
|
|
cp < &bp->b_un.b_buf[sblock.fs_fsize];
|
|
|
|
cp += DIRBLKSIZ)
|
1997-03-11 12:20:21 +00:00
|
|
|
memmove(cp, &emptydir, sizeof emptydir);
|
1994-05-26 06:35:07 +00:00
|
|
|
dirty(bp);
|
2004-09-01 05:48:06 +00:00
|
|
|
DIP_SET(dp, di_nlink, 2);
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(&ip);
|
2017-02-15 19:50:26 +00:00
|
|
|
if (ino == UFS_ROOTINO) {
|
2023-03-07 23:12:37 +00:00
|
|
|
inp = cacheino(dp, ino);
|
2022-09-03 21:46:50 +00:00
|
|
|
inp->i_parent = parent;
|
|
|
|
inp->i_dotdot = parent;
|
2023-03-07 23:12:37 +00:00
|
|
|
inp->i_flags |= INFO_NEW;
|
|
|
|
inoinfo(ino)->ino_type = DT_DIR;
|
|
|
|
inoinfo(ino)->ino_linkcnt = DIP(dp, di_nlink);
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return(ino);
|
|
|
|
}
|
2004-10-08 20:44:47 +00:00
|
|
|
if (!INO_IS_DVALID(parent)) {
|
1994-05-26 06:35:07 +00:00
|
|
|
freeino(ino);
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2022-09-06 23:22:03 +00:00
|
|
|
inp = cacheino(dp, ino);
|
2000-07-24 19:50:20 +00:00
|
|
|
inp->i_parent = parent;
|
|
|
|
inp->i_dotdot = parent;
|
2023-03-07 23:12:37 +00:00
|
|
|
inp->i_flags |= INFO_NEW;
|
Improvement in UFS/FFS directory placement when doing mkdir(2).
The algorithm for laying out new directories was devised in the 1980s
and markedly improved the performance of the filesystem. In those days
large disks had at most 100 cylinder groups and often as few as 10-20.
Modern multi-terrabyte disks have thousands of cylinder groups. The
original algorithm does not handle these large sizes well. This change
attempts to expand the scope of the original algorithm to work well
with these much larger disks while still retaining the properties
of the original algorithm for small disks.
The filesystem implementation is divided into policy routines and
implementation routines. The policy routines can be changed in any
way desired without risk of corrupting the filesystem. The policy
requests are handled by the implementation layer. If the policy
asks for an available resource, it is granted. But if it asks for
an already in-use resource, then the implementation will provide
an available one nearby the request. Thus it is impossible for a
policy to double allocate. This change is limited to the policy
implementation.
This change updates the ffs_dirpref() routine which is responsible
for selecting the cylinder group into which a new directory should
be placed. If we are near the root of the filesystem we aim to
spread them out as much as possible. As we descend deeper from the
root we cluster them closer together around their parent as we
expect them to be more closely interactive. Higher-level directories
like usr/src/sys and usr/src/bin should be separated while the
directories in these areas are more likely to be accessed together
so should be closer. And directories within commands or kernel
subsystems should be closer still.
We pick a range of cylinder groups around the cylinder group of the
directory in which we are being created. The size of the range for
our search is based on our depth from the root of our filesystem.
We then probe that range based on how many directories are already
present. The first new directory is at 1/2 (middle) of the range;
the second is in the first 1/4 of the range, then at 3/4, 1/8, 3/8,
5/8, 7/8, 1/16, 3/16, 5/16, etc.
It is desirable to store the depth of a directory in its on-disk
inode so that it is available when we need it. We add a new field
di_dirdepth to track the depth of each directory. Because there are
few spare fields left in the inode, we choose to share an existing
field in the inode rather than having one of our own. Specifically
we create a union with the di_freelink field. The di_freelink field
is used to track inodes that have been unlinked but remain referenced.
It is not needed until a rmdir(2) operation has been done on a
directory. At that point, the directory has no contents and even
if it is kept active as a current directory is no longer able to
have any new directories or files created in it. Thus the use of
di_dirdepth and di_freelink will never coincide.
Reported by: Timo Voelker
Reviewed by: kib
Tested by: Peter Holm
MFC after: 2 weeks
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D39246
2023-03-30 04:09:39 +00:00
|
|
|
if ((parentinp = getinoinfo(inp->i_parent)) == NULL) {
|
|
|
|
pfatal("allocdir: UNKNOWN PARENT DIR");
|
|
|
|
} else {
|
|
|
|
inp->i_depth = parentinp->i_depth + 1;
|
|
|
|
DIP_SET(dp, di_dirdepth, inp->i_depth);
|
|
|
|
}
|
2023-03-07 23:12:37 +00:00
|
|
|
inoinfo(ino)->ino_type = DT_DIR;
|
1998-12-03 02:27:35 +00:00
|
|
|
inoinfo(ino)->ino_state = inoinfo(parent)->ino_state;
|
|
|
|
if (inoinfo(ino)->ino_state == DSTATE) {
|
2002-06-21 06:18:05 +00:00
|
|
|
inoinfo(ino)->ino_linkcnt = DIP(dp, di_nlink);
|
1998-12-03 02:27:35 +00:00
|
|
|
inoinfo(parent)->ino_linkcnt++;
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2021-01-07 01:37:08 +00:00
|
|
|
irelse(&ip);
|
|
|
|
ginode(parent, &ip);
|
|
|
|
dp = ip.i_dp;
|
2004-09-01 05:48:06 +00:00
|
|
|
DIP_SET(dp, di_nlink, DIP(dp, di_nlink) + 1);
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(&ip);
|
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (ino);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* free a directory inode
|
|
|
|
*/
|
2023-03-07 23:12:37 +00:00
|
|
|
void
|
|
|
|
freedirino(ino_t ino, ino_t parent)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2021-01-07 01:37:08 +00:00
|
|
|
struct inode ip;
|
2002-06-21 06:18:05 +00:00
|
|
|
union dinode *dp;
|
1994-05-26 06:35:07 +00:00
|
|
|
|
|
|
|
if (ino != parent) {
|
2021-01-07 01:37:08 +00:00
|
|
|
ginode(parent, &ip);
|
|
|
|
dp = ip.i_dp;
|
2004-09-01 05:48:06 +00:00
|
|
|
DIP_SET(dp, di_nlink, DIP(dp, di_nlink) - 1);
|
2021-01-07 01:37:08 +00:00
|
|
|
inodirty(&ip);
|
|
|
|
irelse(&ip);
|
1994-05-26 06:35:07 +00:00
|
|
|
}
|
2023-03-07 23:12:37 +00:00
|
|
|
removecachedino(ino);
|
1994-05-26 06:35:07 +00:00
|
|
|
freeino(ino);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* generate a temporary name for the lost+found directory.
|
|
|
|
*/
|
1997-03-11 12:20:21 +00:00
|
|
|
static int
|
2002-03-20 22:57:10 +00:00
|
|
|
lftempname(char *bufp, ino_t ino)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
2002-03-20 17:55:10 +00:00
|
|
|
ino_t in;
|
|
|
|
char *cp;
|
1994-05-26 06:35:07 +00:00
|
|
|
int namlen;
|
|
|
|
|
|
|
|
cp = bufp + 2;
|
|
|
|
for (in = maxino; in > 0; in /= 10)
|
|
|
|
cp++;
|
|
|
|
*--cp = 0;
|
|
|
|
namlen = cp - bufp;
|
|
|
|
in = ino;
|
|
|
|
while (cp > bufp) {
|
|
|
|
*--cp = (in % 10) + '0';
|
|
|
|
in /= 10;
|
|
|
|
}
|
|
|
|
*cp = '#';
|
|
|
|
return (namlen);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a directory block.
|
|
|
|
* Insure that it is held until another is requested.
|
|
|
|
*/
|
1997-03-11 12:20:21 +00:00
|
|
|
static struct bufarea *
|
2002-06-21 06:18:05 +00:00
|
|
|
getdirblk(ufs2_daddr_t blkno, long size)
|
1994-05-26 06:35:07 +00:00
|
|
|
{
|
|
|
|
|
2021-01-07 01:37:08 +00:00
|
|
|
if (pdirbp != NULL && pdirbp->b_errs == 0)
|
|
|
|
brelse(pdirbp);
|
2013-02-24 06:44:29 +00:00
|
|
|
pdirbp = getdatablk(blkno, size, BT_DIRDATA);
|
1994-05-26 06:35:07 +00:00
|
|
|
return (pdirbp);
|
|
|
|
}
|