1994-05-27 05:00:24 +00:00
|
|
|
/*-
|
2017-11-20 19:49:47 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-27 05:00:24 +00:00
|
|
|
* Copyright (c) 1990, 1993, 1994
|
|
|
|
* 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-27 05:00:24 +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.
|
1999-12-18 04:36:14 +00:00
|
|
|
*
|
2018-07-03 17:31:45 +00:00
|
|
|
* From: @(#)fts.c 8.6 (Berkeley) 8/14/94
|
|
|
|
* From: $OpenBSD: fts.c,v 1.22 1999/10/03 19:22:22 millert Exp $
|
1994-05-27 05:00:24 +00:00
|
|
|
*/
|
|
|
|
|
2002-02-01 01:32:19 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
1994-05-27 05:00:24 +00:00
|
|
|
|
2001-01-24 13:01:12 +00:00
|
|
|
#include "namespace.h"
|
1994-05-27 05:00:24 +00:00
|
|
|
#include <sys/param.h>
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
#define _WANT_FREEBSD11_STATFS
|
2004-05-08 15:09:02 +00:00
|
|
|
#include <sys/mount.h>
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
#define _WANT_FREEBSD11_STAT
|
2004-05-12 21:38:39 +00:00
|
|
|
#include <sys/stat.h>
|
1994-05-27 05:00:24 +00:00
|
|
|
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
#define _WANT_FREEBSD11_DIRENT
|
1994-05-27 05:00:24 +00:00
|
|
|
#include <dirent.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
#include "gen-compat.h"
|
Our fts(3) API, as inherited from 4.4BSD, suffers from integer
fields in FTS and FTSENT structs being too narrow. In addition,
the narrow types creep from there into fts.c. As a result, fts(3)
consumers, e.g., find(1) or rm(1), can't handle file trees an ordinary
user can create, which can have security implications.
To fix the historic implementation of fts(3), OpenBSD and NetBSD
have already changed <fts.h> in somewhat incompatible ways, so we
are free to do so, too. This change is a superset of changes from
the other BSDs with a few more improvements. It doesn't touch
fts(3) functionality; it just extends integer types used by it to
match modern reality and the C standard.
Here are its points:
o For C object sizes, use size_t unless it's 100% certain that
the object will be really small. (Note that fts(3) can construct
pathnames _much_ longer than PATH_MAX for its consumers.)
o Avoid the short types because on modern platforms using them
results in larger and slower code. Change shorts to ints as
follows:
- For variables than count simple, limited things like states,
use plain vanilla `int' as it's the type of choice in C.
- For a limited number of bit flags use `unsigned' because signed
bit-wise operations are implementation-defined, i.e., unportable,
in C.
o For things that should be at least 64 bits wide, use long long
and not int64_t, as the latter is an optional type. See
FTSENT.fts_number aka FTS.fts_bignum. Extending fts_number `to
satisfy future needs' is pointless because there is fts_pointer,
which can be used to link to arbitrary data from an FTSENT.
However, there already are fts(3) consumers that require fts_number,
or fts_bignum, have at least 64 bits in it, so we must allow for them.
o For the tree depth, use `long'. This is a trade-off between making
this field too wide and allowing for 64-bit inode numbers and/or
chain-mounted filesystems. On the one hand, `long' is almost
enough for 32-bit filesystems on a 32-bit platform (our ino_t is
uint32_t now). On the other hand, platforms with a 64-bit (or
wider) `long' will be ready for 64-bit inode numbers, as well as
for several 32-bit filesystems mounted one under another. Note
that fts_level has to be signed because -1 is a magic value for it,
FTS_ROOTPARENTLEVEL.
o For the `nlinks' local var in fts_build(), use `long'. The logic
in fts_build() requires that `nlinks' be signed, but our nlink_t
currently is uint16_t. Therefore let's make the signed var wide
enough to be able to represent 2^16-1 in pure C99, and even 2^32-1
on a 64-bit platform. Perhaps the logic should be changed just
to use nlink_t, but it can be done later w/o breaking fts(3) ABI
any more because `nlinks' is just a local var.
This commit also inludes supporting stuff for the fts change:
o Preserve the old versions of fts(3) functions through libc symbol
versioning because the old versions appeared in all our former releases.
o Bump __FreeBSD_version just in case. There is a small chance that
some ill-written 3-rd party apps may fail to build or work correctly
if compiled after this change.
o Update the fts(3) manpage accordingly. In particular, remove
references to fts_bignum, which was a FreeBSD-specific hack to work
around the too narrow types of FTSENT members. Now fts_number is
at least 64 bits wide (long long) and fts_bignum is an undocumented
alias for fts_number kept around for compatibility reasons. According
to Google Code Search, the only big consumers of fts_bignum are in
our own source tree, so they can be fixed easily to use fts_number.
o Mention the change in src/UPDATING.
PR: bin/104458
Approved by: re (quite a while ago)
Discussed with: deischen (the symbol versioning part)
Reviewed by: -arch (mostly silence); das (generally OK, but we didn't
agree on some types used; assuming that no objections on
-arch let me to stick to my opinion)
2008-01-26 17:09:40 +00:00
|
|
|
#include "fts-compat.h"
|
2001-01-24 13:01:12 +00:00
|
|
|
#include "un-namespace.h"
|
1994-05-27 05:00:24 +00:00
|
|
|
|
2012-05-19 12:44:27 +00:00
|
|
|
#include "gen-private.h"
|
|
|
|
|
Our fts(3) API, as inherited from 4.4BSD, suffers from integer
fields in FTS and FTSENT structs being too narrow. In addition,
the narrow types creep from there into fts.c. As a result, fts(3)
consumers, e.g., find(1) or rm(1), can't handle file trees an ordinary
user can create, which can have security implications.
To fix the historic implementation of fts(3), OpenBSD and NetBSD
have already changed <fts.h> in somewhat incompatible ways, so we
are free to do so, too. This change is a superset of changes from
the other BSDs with a few more improvements. It doesn't touch
fts(3) functionality; it just extends integer types used by it to
match modern reality and the C standard.
Here are its points:
o For C object sizes, use size_t unless it's 100% certain that
the object will be really small. (Note that fts(3) can construct
pathnames _much_ longer than PATH_MAX for its consumers.)
o Avoid the short types because on modern platforms using them
results in larger and slower code. Change shorts to ints as
follows:
- For variables than count simple, limited things like states,
use plain vanilla `int' as it's the type of choice in C.
- For a limited number of bit flags use `unsigned' because signed
bit-wise operations are implementation-defined, i.e., unportable,
in C.
o For things that should be at least 64 bits wide, use long long
and not int64_t, as the latter is an optional type. See
FTSENT.fts_number aka FTS.fts_bignum. Extending fts_number `to
satisfy future needs' is pointless because there is fts_pointer,
which can be used to link to arbitrary data from an FTSENT.
However, there already are fts(3) consumers that require fts_number,
or fts_bignum, have at least 64 bits in it, so we must allow for them.
o For the tree depth, use `long'. This is a trade-off between making
this field too wide and allowing for 64-bit inode numbers and/or
chain-mounted filesystems. On the one hand, `long' is almost
enough for 32-bit filesystems on a 32-bit platform (our ino_t is
uint32_t now). On the other hand, platforms with a 64-bit (or
wider) `long' will be ready for 64-bit inode numbers, as well as
for several 32-bit filesystems mounted one under another. Note
that fts_level has to be signed because -1 is a magic value for it,
FTS_ROOTPARENTLEVEL.
o For the `nlinks' local var in fts_build(), use `long'. The logic
in fts_build() requires that `nlinks' be signed, but our nlink_t
currently is uint16_t. Therefore let's make the signed var wide
enough to be able to represent 2^16-1 in pure C99, and even 2^32-1
on a 64-bit platform. Perhaps the logic should be changed just
to use nlink_t, but it can be done later w/o breaking fts(3) ABI
any more because `nlinks' is just a local var.
This commit also inludes supporting stuff for the fts change:
o Preserve the old versions of fts(3) functions through libc symbol
versioning because the old versions appeared in all our former releases.
o Bump __FreeBSD_version just in case. There is a small chance that
some ill-written 3-rd party apps may fail to build or work correctly
if compiled after this change.
o Update the fts(3) manpage accordingly. In particular, remove
references to fts_bignum, which was a FreeBSD-specific hack to work
around the too narrow types of FTSENT members. Now fts_number is
at least 64 bits wide (long long) and fts_bignum is an undocumented
alias for fts_number kept around for compatibility reasons. According
to Google Code Search, the only big consumers of fts_bignum are in
our own source tree, so they can be fixed easily to use fts_number.
o Mention the change in src/UPDATING.
PR: bin/104458
Approved by: re (quite a while ago)
Discussed with: deischen (the symbol versioning part)
Reviewed by: -arch (mostly silence); das (generally OK, but we didn't
agree on some types used; assuming that no objections on
-arch let me to stick to my opinion)
2008-01-26 17:09:40 +00:00
|
|
|
FTSENT *__fts_children_44bsd(FTS *, int);
|
|
|
|
int __fts_close_44bsd(FTS *);
|
|
|
|
void *__fts_get_clientptr_44bsd(FTS *);
|
|
|
|
FTS *__fts_get_stream_44bsd(FTSENT *);
|
|
|
|
FTS *__fts_open_44bsd(char * const *, int,
|
|
|
|
int (*)(const FTSENT * const *, const FTSENT * const *));
|
|
|
|
FTSENT *__fts_read_44bsd(FTS *);
|
|
|
|
int __fts_set_44bsd(FTS *, FTSENT *, int);
|
|
|
|
void __fts_set_clientptr_44bsd(FTS *, void *);
|
|
|
|
|
2002-02-01 01:32:19 +00:00
|
|
|
static FTSENT *fts_alloc(FTS *, char *, int);
|
|
|
|
static FTSENT *fts_build(FTS *, int);
|
|
|
|
static void fts_lfree(FTSENT *);
|
|
|
|
static void fts_load(FTS *, FTSENT *);
|
|
|
|
static size_t fts_maxarglen(char * const *);
|
|
|
|
static void fts_padjust(FTS *, FTSENT *);
|
|
|
|
static int fts_palloc(FTS *, size_t);
|
|
|
|
static FTSENT *fts_sort(FTS *, FTSENT *, int);
|
|
|
|
static u_short fts_stat(FTS *, FTSENT *, int);
|
|
|
|
static int fts_safe_changedir(FTS *, FTSENT *, int, char *);
|
2004-05-12 21:38:39 +00:00
|
|
|
static int fts_ufslinks(FTS *, const FTSENT *);
|
1994-05-27 05:00:24 +00:00
|
|
|
|
1997-08-29 22:56:41 +00:00
|
|
|
#define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
|
1994-05-27 05:00:24 +00:00
|
|
|
|
1997-08-29 22:56:41 +00:00
|
|
|
#define CLR(opt) (sp->fts_options &= ~(opt))
|
|
|
|
#define ISSET(opt) (sp->fts_options & (opt))
|
|
|
|
#define SET(opt) (sp->fts_options |= (opt))
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
#define FCHDIR(sp, fd) (!ISSET(FTS_NOCHDIR) && fchdir(fd))
|
|
|
|
|
|
|
|
/* fts_build flags */
|
|
|
|
#define BCHILD 1 /* fts_children */
|
|
|
|
#define BNAMES 2 /* fts_children, names only */
|
|
|
|
#define BREAD 3 /* fts_read */
|
|
|
|
|
2004-05-08 15:09:02 +00:00
|
|
|
/*
|
2004-05-12 21:38:39 +00:00
|
|
|
* Internal representation of an FTS, including extra implementation
|
|
|
|
* details. The FTS returned from fts_open points to this structure's
|
|
|
|
* ftsp_fts member (and can be cast to an _fts_private as required)
|
2004-05-08 15:09:02 +00:00
|
|
|
*/
|
|
|
|
struct _fts_private {
|
2004-05-12 21:38:39 +00:00
|
|
|
FTS ftsp_fts;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
struct freebsd11_statfs ftsp_statfs;
|
|
|
|
uint32_t ftsp_dev;
|
2004-05-12 21:38:39 +00:00
|
|
|
int ftsp_linksreliable;
|
2004-05-08 15:09:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2004-05-12 21:38:39 +00:00
|
|
|
* The "FTS_NOSTAT" option can avoid a lot of calls to stat(2) if it
|
|
|
|
* knows that a directory could not possibly have subdirectories. This
|
|
|
|
* is decided by looking at the link count: a subdirectory would
|
|
|
|
* increment its parent's link count by virtue of its own ".." entry.
|
|
|
|
* This assumption only holds for UFS-like filesystems that implement
|
|
|
|
* links and directories this way, so we must punt for others.
|
2004-05-08 15:09:02 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static const char *ufslike_filesystems[] = {
|
|
|
|
"ufs",
|
2011-03-16 08:58:09 +00:00
|
|
|
"zfs",
|
2004-05-08 15:09:02 +00:00
|
|
|
"nfs",
|
|
|
|
"ext2fs",
|
|
|
|
0
|
|
|
|
};
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
FTS *
|
2015-09-20 20:23:16 +00:00
|
|
|
__fts_open_44bsd(char * const *argv, int options,
|
|
|
|
int (*compar)(const FTSENT * const *, const FTSENT * const *))
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2004-05-08 15:09:02 +00:00
|
|
|
struct _fts_private *priv;
|
2002-02-01 01:32:19 +00:00
|
|
|
FTS *sp;
|
|
|
|
FTSENT *p, *root;
|
|
|
|
int nitems;
|
1994-05-27 05:00:24 +00:00
|
|
|
FTSENT *parent, *tmp;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
/* Options check. */
|
|
|
|
if (options & ~FTS_OPTIONMASK) {
|
|
|
|
errno = EINVAL;
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2004-05-13 15:59:38 +00:00
|
|
|
/* Allocate/initialize the stream. */
|
2015-09-29 04:47:31 +00:00
|
|
|
if ((priv = calloc(1, sizeof(*priv))) == NULL)
|
1994-05-27 05:00:24 +00:00
|
|
|
return (NULL);
|
2004-05-08 15:09:02 +00:00
|
|
|
sp = &priv->ftsp_fts;
|
1994-05-27 05:00:24 +00:00
|
|
|
sp->fts_compar = compar;
|
|
|
|
sp->fts_options = options;
|
|
|
|
|
|
|
|
/* Logical walks turn on NOCHDIR; symbolic links are too hard. */
|
|
|
|
if (ISSET(FTS_LOGICAL))
|
|
|
|
SET(FTS_NOCHDIR);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start out with 1K of path space, and enough, in any case,
|
|
|
|
* to hold the user's paths.
|
|
|
|
*/
|
|
|
|
if (fts_palloc(sp, MAX(fts_maxarglen(argv), MAXPATHLEN)))
|
|
|
|
goto mem1;
|
|
|
|
|
|
|
|
/* Allocate/initialize root's parent. */
|
|
|
|
if ((parent = fts_alloc(sp, "", 0)) == NULL)
|
|
|
|
goto mem2;
|
|
|
|
parent->fts_level = FTS_ROOTPARENTLEVEL;
|
|
|
|
|
2017-05-26 01:14:58 +00:00
|
|
|
/* Shush, GCC. */
|
|
|
|
tmp = NULL;
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
/* Allocate/initialize root(s). */
|
2000-08-16 23:37:16 +00:00
|
|
|
for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
|
1994-05-27 05:00:24 +00:00
|
|
|
/* Don't allow zero-length paths. */
|
|
|
|
if ((len = strlen(*argv)) == 0) {
|
|
|
|
errno = ENOENT;
|
|
|
|
goto mem3;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = fts_alloc(sp, *argv, len);
|
|
|
|
p->fts_level = FTS_ROOTLEVEL;
|
|
|
|
p->fts_parent = parent;
|
|
|
|
p->fts_accpath = p->fts_name;
|
|
|
|
p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW));
|
|
|
|
|
|
|
|
/* Command-line "." and ".." are real directories. */
|
|
|
|
if (p->fts_info == FTS_DOT)
|
|
|
|
p->fts_info = FTS_D;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If comparison routine supplied, traverse in sorted
|
|
|
|
* order; otherwise traverse in the order specified.
|
|
|
|
*/
|
|
|
|
if (compar) {
|
|
|
|
p->fts_link = root;
|
|
|
|
root = p;
|
|
|
|
} else {
|
|
|
|
p->fts_link = NULL;
|
|
|
|
if (root == NULL)
|
|
|
|
tmp = root = p;
|
|
|
|
else {
|
|
|
|
tmp->fts_link = p;
|
|
|
|
tmp = p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (compar && nitems > 1)
|
|
|
|
root = fts_sort(sp, root, nitems);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a dummy pointer and make fts_read think that we've just
|
|
|
|
* finished the node before the root(s); set p->fts_info to FTS_INIT
|
|
|
|
* so that everything about the "current" node is ignored.
|
|
|
|
*/
|
|
|
|
if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)
|
|
|
|
goto mem3;
|
|
|
|
sp->fts_cur->fts_link = root;
|
|
|
|
sp->fts_cur->fts_info = FTS_INIT;
|
|
|
|
|
|
|
|
/*
|
1999-12-18 04:36:14 +00:00
|
|
|
* If using chdir(2), grab a file descriptor pointing to dot to ensure
|
1994-05-27 05:00:24 +00:00
|
|
|
* that we can get back here; this could be avoided for some paths,
|
|
|
|
* but almost certainly not worth the effort. Slashes, symbolic links,
|
|
|
|
* and ".." are all fairly nasty problems. Note, if we can't get the
|
|
|
|
* descriptor we run anyway, just more slowly.
|
|
|
|
*/
|
2012-09-27 22:05:54 +00:00
|
|
|
if (!ISSET(FTS_NOCHDIR) &&
|
|
|
|
(sp->fts_rfd = _open(".", O_RDONLY | O_CLOEXEC, 0)) < 0)
|
1994-05-27 05:00:24 +00:00
|
|
|
SET(FTS_NOCHDIR);
|
|
|
|
|
|
|
|
return (sp);
|
|
|
|
|
|
|
|
mem3: fts_lfree(root);
|
|
|
|
free(parent);
|
|
|
|
mem2: free(sp->fts_path);
|
|
|
|
mem1: free(sp);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-09-20 20:23:16 +00:00
|
|
|
fts_load(FTS *sp, FTSENT *p)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
int len;
|
|
|
|
char *cp;
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Load the stream structure for the next traversal. Since we don't
|
|
|
|
* actually enter the directory until after the preorder visit, set
|
|
|
|
* the fts_accpath field specially so the chdir gets done to the right
|
|
|
|
* place and the user can access the first node. From fts_open it's
|
|
|
|
* known that the path will fit.
|
|
|
|
*/
|
|
|
|
len = p->fts_pathlen = p->fts_namelen;
|
|
|
|
memmove(sp->fts_path, p->fts_name, len + 1);
|
|
|
|
if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
|
|
|
|
len = strlen(++cp);
|
|
|
|
memmove(p->fts_name, cp, len + 1);
|
|
|
|
p->fts_namelen = len;
|
|
|
|
}
|
|
|
|
p->fts_accpath = p->fts_path = sp->fts_path;
|
|
|
|
sp->fts_dev = p->fts_dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2015-09-20 20:23:16 +00:00
|
|
|
__fts_close_44bsd(FTS *sp)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT *freep, *p;
|
1994-05-27 05:00:24 +00:00
|
|
|
int saved_errno;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This still works if we haven't read anything -- the dummy structure
|
|
|
|
* points to the root list, so we step through to the end of the root
|
|
|
|
* list which has a valid parent pointer.
|
|
|
|
*/
|
|
|
|
if (sp->fts_cur) {
|
|
|
|
for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
|
|
|
|
freep = p;
|
2000-08-16 23:37:16 +00:00
|
|
|
p = p->fts_link != NULL ? p->fts_link : p->fts_parent;
|
1994-05-27 05:00:24 +00:00
|
|
|
free(freep);
|
|
|
|
}
|
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free up child linked list, sort array, path buffer. */
|
|
|
|
if (sp->fts_child)
|
|
|
|
fts_lfree(sp->fts_child);
|
|
|
|
if (sp->fts_array)
|
|
|
|
free(sp->fts_array);
|
|
|
|
free(sp->fts_path);
|
|
|
|
|
|
|
|
/* Return to original directory, save errno if necessary. */
|
|
|
|
if (!ISSET(FTS_NOCHDIR)) {
|
|
|
|
saved_errno = fchdir(sp->fts_rfd) ? errno : 0;
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
(void)_close(sp->fts_rfd);
|
1994-05-27 05:00:24 +00:00
|
|
|
|
1999-12-18 04:36:14 +00:00
|
|
|
/* Set errno and return. */
|
|
|
|
if (saved_errno != 0) {
|
|
|
|
/* Free up the stream pointer. */
|
|
|
|
free(sp);
|
|
|
|
errno = saved_errno;
|
|
|
|
return (-1);
|
|
|
|
}
|
1994-05-27 05:00:24 +00:00
|
|
|
}
|
1999-12-18 04:36:14 +00:00
|
|
|
|
1998-07-03 08:21:05 +00:00
|
|
|
/* Free up the stream pointer. */
|
|
|
|
free(sp);
|
1994-05-27 05:00:24 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-08-29 22:56:41 +00:00
|
|
|
* Special case of "/" at the end of the path so that slashes aren't
|
|
|
|
* appended which would cause paths to be written as "....//foo".
|
1994-05-27 05:00:24 +00:00
|
|
|
*/
|
|
|
|
#define NAPPEND(p) \
|
1997-08-29 22:56:41 +00:00
|
|
|
(p->fts_path[p->fts_pathlen - 1] == '/' \
|
|
|
|
? p->fts_pathlen - 1 : p->fts_pathlen)
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
FTSENT *
|
2015-09-20 20:23:16 +00:00
|
|
|
__fts_read_44bsd(FTS *sp)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT *p, *tmp;
|
|
|
|
int instr;
|
|
|
|
char *t;
|
1994-05-27 05:00:24 +00:00
|
|
|
int saved_errno;
|
|
|
|
|
|
|
|
/* If finished or unrecoverable error, return NULL. */
|
|
|
|
if (sp->fts_cur == NULL || ISSET(FTS_STOP))
|
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
/* Set current node pointer. */
|
|
|
|
p = sp->fts_cur;
|
|
|
|
|
|
|
|
/* Save and zero out user instructions. */
|
|
|
|
instr = p->fts_instr;
|
|
|
|
p->fts_instr = FTS_NOINSTR;
|
|
|
|
|
|
|
|
/* Any type of file may be re-visited; re-stat and re-turn. */
|
|
|
|
if (instr == FTS_AGAIN) {
|
|
|
|
p->fts_info = fts_stat(sp, p, 0);
|
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Following a symlink -- SLNONE test allows application to see
|
|
|
|
* SLNONE and recover. If indirecting through a symlink, have
|
|
|
|
* keep a pointer to current location. If unable to get that
|
|
|
|
* pointer, follow fails.
|
|
|
|
*/
|
|
|
|
if (instr == FTS_FOLLOW &&
|
|
|
|
(p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
|
|
|
|
p->fts_info = fts_stat(sp, p, 1);
|
1999-12-18 04:36:14 +00:00
|
|
|
if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
|
2012-09-27 22:05:54 +00:00
|
|
|
if ((p->fts_symfd = _open(".", O_RDONLY | O_CLOEXEC,
|
|
|
|
0)) < 0) {
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_errno = errno;
|
|
|
|
p->fts_info = FTS_ERR;
|
|
|
|
} else
|
|
|
|
p->fts_flags |= FTS_SYMFOLLOW;
|
1999-12-18 04:36:14 +00:00
|
|
|
}
|
1994-05-27 05:00:24 +00:00
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Directory in pre-order. */
|
|
|
|
if (p->fts_info == FTS_D) {
|
|
|
|
/* If skipped or crossed mount point, do post-order visit. */
|
|
|
|
if (instr == FTS_SKIP ||
|
1997-08-29 22:56:41 +00:00
|
|
|
(ISSET(FTS_XDEV) && p->fts_dev != sp->fts_dev)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
if (p->fts_flags & FTS_SYMFOLLOW)
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
(void)_close(p->fts_symfd);
|
1994-05-27 05:00:24 +00:00
|
|
|
if (sp->fts_child) {
|
|
|
|
fts_lfree(sp->fts_child);
|
|
|
|
sp->fts_child = NULL;
|
|
|
|
}
|
|
|
|
p->fts_info = FTS_DP;
|
|
|
|
return (p);
|
1995-05-30 05:51:47 +00:00
|
|
|
}
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
/* Rebuild if only read the names and now traversing. */
|
2000-08-16 23:37:16 +00:00
|
|
|
if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {
|
1997-08-29 22:56:41 +00:00
|
|
|
CLR(FTS_NAMEONLY);
|
1994-05-27 05:00:24 +00:00
|
|
|
fts_lfree(sp->fts_child);
|
|
|
|
sp->fts_child = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cd to the subdirectory.
|
|
|
|
*
|
|
|
|
* If have already read and now fail to chdir, whack the list
|
|
|
|
* to make the names come out right, and set the parent errno
|
|
|
|
* so the application will eventually get an error condition.
|
|
|
|
* Set the FTS_DONTCHDIR flag so that when we logically change
|
|
|
|
* directories back to the parent we don't do a chdir.
|
|
|
|
*
|
|
|
|
* If haven't read do so. If the read fails, fts_build sets
|
|
|
|
* FTS_STOP or the fts_info field of the node.
|
|
|
|
*/
|
2000-08-16 23:37:16 +00:00
|
|
|
if (sp->fts_child != NULL) {
|
2001-06-01 21:53:50 +00:00
|
|
|
if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_errno = errno;
|
|
|
|
p->fts_flags |= FTS_DONTCHDIR;
|
2004-05-13 15:59:38 +00:00
|
|
|
for (p = sp->fts_child; p != NULL;
|
2000-08-16 23:37:16 +00:00
|
|
|
p = p->fts_link)
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_accpath =
|
|
|
|
p->fts_parent->fts_accpath;
|
|
|
|
}
|
|
|
|
} else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {
|
|
|
|
if (ISSET(FTS_STOP))
|
|
|
|
return (NULL);
|
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
p = sp->fts_child;
|
|
|
|
sp->fts_child = NULL;
|
|
|
|
goto name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move to the next node on this level. */
|
|
|
|
next: tmp = p;
|
2000-08-16 23:37:16 +00:00
|
|
|
if ((p = p->fts_link) != NULL) {
|
1994-05-27 05:00:24 +00:00
|
|
|
free(tmp);
|
|
|
|
|
|
|
|
/*
|
1999-12-18 04:36:14 +00:00
|
|
|
* If reached the top, return to the original directory (or
|
|
|
|
* the root of the tree), and load the paths for the next root.
|
1994-05-27 05:00:24 +00:00
|
|
|
*/
|
|
|
|
if (p->fts_level == FTS_ROOTLEVEL) {
|
1997-08-29 22:56:41 +00:00
|
|
|
if (FCHDIR(sp, sp->fts_rfd)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
SET(FTS_STOP);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
fts_load(sp, p);
|
|
|
|
return (sp->fts_cur = p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* User may have called fts_set on the node. If skipped,
|
|
|
|
* ignore. If followed, get a file descriptor so we can
|
|
|
|
* get back if necessary.
|
|
|
|
*/
|
|
|
|
if (p->fts_instr == FTS_SKIP)
|
|
|
|
goto next;
|
|
|
|
if (p->fts_instr == FTS_FOLLOW) {
|
|
|
|
p->fts_info = fts_stat(sp, p, 1);
|
1999-12-18 04:36:14 +00:00
|
|
|
if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
if ((p->fts_symfd =
|
2012-09-27 22:05:54 +00:00
|
|
|
_open(".", O_RDONLY | O_CLOEXEC, 0)) < 0) {
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_errno = errno;
|
|
|
|
p->fts_info = FTS_ERR;
|
|
|
|
} else
|
|
|
|
p->fts_flags |= FTS_SYMFOLLOW;
|
1999-12-18 04:36:14 +00:00
|
|
|
}
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_instr = FTS_NOINSTR;
|
|
|
|
}
|
|
|
|
|
|
|
|
name: t = sp->fts_path + NAPPEND(p->fts_parent);
|
|
|
|
*t++ = '/';
|
|
|
|
memmove(t, p->fts_name, p->fts_namelen + 1);
|
|
|
|
return (sp->fts_cur = p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move up to the parent node. */
|
|
|
|
p = tmp->fts_parent;
|
|
|
|
free(tmp);
|
|
|
|
|
|
|
|
if (p->fts_level == FTS_ROOTPARENTLEVEL) {
|
|
|
|
/*
|
|
|
|
* Done; free everything up and set errno to 0 so the user
|
|
|
|
* can distinguish between error and EOF.
|
|
|
|
*/
|
|
|
|
free(p);
|
|
|
|
errno = 0;
|
|
|
|
return (sp->fts_cur = NULL);
|
|
|
|
}
|
|
|
|
|
1999-12-18 04:36:14 +00:00
|
|
|
/* NUL terminate the pathname. */
|
1994-05-27 05:00:24 +00:00
|
|
|
sp->fts_path[p->fts_pathlen] = '\0';
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return to the parent directory. If at a root node or came through
|
|
|
|
* a symlink, go back through the file descriptor. Otherwise, cd up
|
|
|
|
* one directory.
|
|
|
|
*/
|
|
|
|
if (p->fts_level == FTS_ROOTLEVEL) {
|
1997-08-29 22:56:41 +00:00
|
|
|
if (FCHDIR(sp, sp->fts_rfd)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
SET(FTS_STOP);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
} else if (p->fts_flags & FTS_SYMFOLLOW) {
|
|
|
|
if (FCHDIR(sp, p->fts_symfd)) {
|
|
|
|
saved_errno = errno;
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
(void)_close(p->fts_symfd);
|
1994-05-27 05:00:24 +00:00
|
|
|
errno = saved_errno;
|
|
|
|
SET(FTS_STOP);
|
|
|
|
return (NULL);
|
|
|
|
}
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
(void)_close(p->fts_symfd);
|
2001-05-30 20:35:44 +00:00
|
|
|
} else if (!(p->fts_flags & FTS_DONTCHDIR) &&
|
2004-05-13 15:59:38 +00:00
|
|
|
fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
|
2001-06-01 21:53:50 +00:00
|
|
|
SET(FTS_STOP);
|
|
|
|
return (NULL);
|
1994-05-27 05:00:24 +00:00
|
|
|
}
|
|
|
|
p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
|
|
|
|
return (sp->fts_cur = p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fts_set takes the stream as an argument although it's not used in this
|
|
|
|
* implementation; it would be necessary if anyone wanted to add global
|
|
|
|
* semantics to fts using fts_set. An error return is allowed for similar
|
|
|
|
* reasons.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
|
|
|
int
|
2015-09-20 20:23:16 +00:00
|
|
|
__fts_set_44bsd(FTS *sp, FTSENT *p, int instr)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2000-08-16 23:37:16 +00:00
|
|
|
if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
|
1994-05-27 05:00:24 +00:00
|
|
|
instr != FTS_NOINSTR && instr != FTS_SKIP) {
|
|
|
|
errno = EINVAL;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
p->fts_instr = instr;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
FTSENT *
|
2015-09-20 20:23:16 +00:00
|
|
|
__fts_children_44bsd(FTS *sp, int instr)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT *p;
|
1994-05-27 05:00:24 +00:00
|
|
|
int fd;
|
|
|
|
|
2000-08-16 23:37:16 +00:00
|
|
|
if (instr != 0 && instr != FTS_NAMEONLY) {
|
1994-05-27 05:00:24 +00:00
|
|
|
errno = EINVAL;
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set current node pointer. */
|
|
|
|
p = sp->fts_cur;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Errno set to 0 so user can distinguish empty directory from
|
|
|
|
* an error.
|
|
|
|
*/
|
|
|
|
errno = 0;
|
|
|
|
|
|
|
|
/* Fatal errors stop here. */
|
|
|
|
if (ISSET(FTS_STOP))
|
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
/* Return logical hierarchy of user's arguments. */
|
|
|
|
if (p->fts_info == FTS_INIT)
|
|
|
|
return (p->fts_link);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If not a directory being visited in pre-order, stop here. Could
|
|
|
|
* allow FTS_DNR, assuming the user has fixed the problem, but the
|
|
|
|
* same effect is available with FTS_AGAIN.
|
|
|
|
*/
|
|
|
|
if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)
|
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
/* Free up any previous child list. */
|
2000-08-16 23:37:16 +00:00
|
|
|
if (sp->fts_child != NULL)
|
1994-05-27 05:00:24 +00:00
|
|
|
fts_lfree(sp->fts_child);
|
|
|
|
|
|
|
|
if (instr == FTS_NAMEONLY) {
|
1997-08-29 22:56:41 +00:00
|
|
|
SET(FTS_NAMEONLY);
|
1994-05-27 05:00:24 +00:00
|
|
|
instr = BNAMES;
|
1995-05-30 05:51:47 +00:00
|
|
|
} else
|
1994-05-27 05:00:24 +00:00
|
|
|
instr = BCHILD;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If using chdir on a relative path and called BEFORE fts_read does
|
|
|
|
* its chdir to the root of a traversal, we can lose -- we need to
|
|
|
|
* chdir into the subdirectory, and we don't know where the current
|
|
|
|
* directory is, so we can't get back so that the upcoming chdir by
|
|
|
|
* fts_read will work.
|
|
|
|
*/
|
|
|
|
if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||
|
|
|
|
ISSET(FTS_NOCHDIR))
|
|
|
|
return (sp->fts_child = fts_build(sp, instr));
|
|
|
|
|
2012-09-27 22:05:54 +00:00
|
|
|
if ((fd = _open(".", O_RDONLY | O_CLOEXEC, 0)) < 0)
|
1994-05-27 05:00:24 +00:00
|
|
|
return (NULL);
|
|
|
|
sp->fts_child = fts_build(sp, instr);
|
2016-05-25 06:55:53 +00:00
|
|
|
if (fchdir(fd)) {
|
|
|
|
(void)_close(fd);
|
1994-05-27 05:00:24 +00:00
|
|
|
return (NULL);
|
2016-05-25 06:55:53 +00:00
|
|
|
}
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
(void)_close(fd);
|
1994-05-27 05:00:24 +00:00
|
|
|
return (sp->fts_child);
|
|
|
|
}
|
|
|
|
|
2002-09-21 01:28:41 +00:00
|
|
|
#ifndef fts_get_clientptr
|
|
|
|
#error "fts_get_clientptr not defined"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void *
|
Our fts(3) API, as inherited from 4.4BSD, suffers from integer
fields in FTS and FTSENT structs being too narrow. In addition,
the narrow types creep from there into fts.c. As a result, fts(3)
consumers, e.g., find(1) or rm(1), can't handle file trees an ordinary
user can create, which can have security implications.
To fix the historic implementation of fts(3), OpenBSD and NetBSD
have already changed <fts.h> in somewhat incompatible ways, so we
are free to do so, too. This change is a superset of changes from
the other BSDs with a few more improvements. It doesn't touch
fts(3) functionality; it just extends integer types used by it to
match modern reality and the C standard.
Here are its points:
o For C object sizes, use size_t unless it's 100% certain that
the object will be really small. (Note that fts(3) can construct
pathnames _much_ longer than PATH_MAX for its consumers.)
o Avoid the short types because on modern platforms using them
results in larger and slower code. Change shorts to ints as
follows:
- For variables than count simple, limited things like states,
use plain vanilla `int' as it's the type of choice in C.
- For a limited number of bit flags use `unsigned' because signed
bit-wise operations are implementation-defined, i.e., unportable,
in C.
o For things that should be at least 64 bits wide, use long long
and not int64_t, as the latter is an optional type. See
FTSENT.fts_number aka FTS.fts_bignum. Extending fts_number `to
satisfy future needs' is pointless because there is fts_pointer,
which can be used to link to arbitrary data from an FTSENT.
However, there already are fts(3) consumers that require fts_number,
or fts_bignum, have at least 64 bits in it, so we must allow for them.
o For the tree depth, use `long'. This is a trade-off between making
this field too wide and allowing for 64-bit inode numbers and/or
chain-mounted filesystems. On the one hand, `long' is almost
enough for 32-bit filesystems on a 32-bit platform (our ino_t is
uint32_t now). On the other hand, platforms with a 64-bit (or
wider) `long' will be ready for 64-bit inode numbers, as well as
for several 32-bit filesystems mounted one under another. Note
that fts_level has to be signed because -1 is a magic value for it,
FTS_ROOTPARENTLEVEL.
o For the `nlinks' local var in fts_build(), use `long'. The logic
in fts_build() requires that `nlinks' be signed, but our nlink_t
currently is uint16_t. Therefore let's make the signed var wide
enough to be able to represent 2^16-1 in pure C99, and even 2^32-1
on a 64-bit platform. Perhaps the logic should be changed just
to use nlink_t, but it can be done later w/o breaking fts(3) ABI
any more because `nlinks' is just a local var.
This commit also inludes supporting stuff for the fts change:
o Preserve the old versions of fts(3) functions through libc symbol
versioning because the old versions appeared in all our former releases.
o Bump __FreeBSD_version just in case. There is a small chance that
some ill-written 3-rd party apps may fail to build or work correctly
if compiled after this change.
o Update the fts(3) manpage accordingly. In particular, remove
references to fts_bignum, which was a FreeBSD-specific hack to work
around the too narrow types of FTSENT members. Now fts_number is
at least 64 bits wide (long long) and fts_bignum is an undocumented
alias for fts_number kept around for compatibility reasons. According
to Google Code Search, the only big consumers of fts_bignum are in
our own source tree, so they can be fixed easily to use fts_number.
o Mention the change in src/UPDATING.
PR: bin/104458
Approved by: re (quite a while ago)
Discussed with: deischen (the symbol versioning part)
Reviewed by: -arch (mostly silence); das (generally OK, but we didn't
agree on some types used; assuming that no objections on
-arch let me to stick to my opinion)
2008-01-26 17:09:40 +00:00
|
|
|
(__fts_get_clientptr_44bsd)(FTS *sp)
|
2002-09-21 01:28:41 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (fts_get_clientptr(sp));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef fts_get_stream
|
|
|
|
#error "fts_get_stream not defined"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
FTS *
|
Our fts(3) API, as inherited from 4.4BSD, suffers from integer
fields in FTS and FTSENT structs being too narrow. In addition,
the narrow types creep from there into fts.c. As a result, fts(3)
consumers, e.g., find(1) or rm(1), can't handle file trees an ordinary
user can create, which can have security implications.
To fix the historic implementation of fts(3), OpenBSD and NetBSD
have already changed <fts.h> in somewhat incompatible ways, so we
are free to do so, too. This change is a superset of changes from
the other BSDs with a few more improvements. It doesn't touch
fts(3) functionality; it just extends integer types used by it to
match modern reality and the C standard.
Here are its points:
o For C object sizes, use size_t unless it's 100% certain that
the object will be really small. (Note that fts(3) can construct
pathnames _much_ longer than PATH_MAX for its consumers.)
o Avoid the short types because on modern platforms using them
results in larger and slower code. Change shorts to ints as
follows:
- For variables than count simple, limited things like states,
use plain vanilla `int' as it's the type of choice in C.
- For a limited number of bit flags use `unsigned' because signed
bit-wise operations are implementation-defined, i.e., unportable,
in C.
o For things that should be at least 64 bits wide, use long long
and not int64_t, as the latter is an optional type. See
FTSENT.fts_number aka FTS.fts_bignum. Extending fts_number `to
satisfy future needs' is pointless because there is fts_pointer,
which can be used to link to arbitrary data from an FTSENT.
However, there already are fts(3) consumers that require fts_number,
or fts_bignum, have at least 64 bits in it, so we must allow for them.
o For the tree depth, use `long'. This is a trade-off between making
this field too wide and allowing for 64-bit inode numbers and/or
chain-mounted filesystems. On the one hand, `long' is almost
enough for 32-bit filesystems on a 32-bit platform (our ino_t is
uint32_t now). On the other hand, platforms with a 64-bit (or
wider) `long' will be ready for 64-bit inode numbers, as well as
for several 32-bit filesystems mounted one under another. Note
that fts_level has to be signed because -1 is a magic value for it,
FTS_ROOTPARENTLEVEL.
o For the `nlinks' local var in fts_build(), use `long'. The logic
in fts_build() requires that `nlinks' be signed, but our nlink_t
currently is uint16_t. Therefore let's make the signed var wide
enough to be able to represent 2^16-1 in pure C99, and even 2^32-1
on a 64-bit platform. Perhaps the logic should be changed just
to use nlink_t, but it can be done later w/o breaking fts(3) ABI
any more because `nlinks' is just a local var.
This commit also inludes supporting stuff for the fts change:
o Preserve the old versions of fts(3) functions through libc symbol
versioning because the old versions appeared in all our former releases.
o Bump __FreeBSD_version just in case. There is a small chance that
some ill-written 3-rd party apps may fail to build or work correctly
if compiled after this change.
o Update the fts(3) manpage accordingly. In particular, remove
references to fts_bignum, which was a FreeBSD-specific hack to work
around the too narrow types of FTSENT members. Now fts_number is
at least 64 bits wide (long long) and fts_bignum is an undocumented
alias for fts_number kept around for compatibility reasons. According
to Google Code Search, the only big consumers of fts_bignum are in
our own source tree, so they can be fixed easily to use fts_number.
o Mention the change in src/UPDATING.
PR: bin/104458
Approved by: re (quite a while ago)
Discussed with: deischen (the symbol versioning part)
Reviewed by: -arch (mostly silence); das (generally OK, but we didn't
agree on some types used; assuming that no objections on
-arch let me to stick to my opinion)
2008-01-26 17:09:40 +00:00
|
|
|
(__fts_get_stream_44bsd)(FTSENT *p)
|
2002-09-21 01:28:41 +00:00
|
|
|
{
|
|
|
|
return (fts_get_stream(p));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
Our fts(3) API, as inherited from 4.4BSD, suffers from integer
fields in FTS and FTSENT structs being too narrow. In addition,
the narrow types creep from there into fts.c. As a result, fts(3)
consumers, e.g., find(1) or rm(1), can't handle file trees an ordinary
user can create, which can have security implications.
To fix the historic implementation of fts(3), OpenBSD and NetBSD
have already changed <fts.h> in somewhat incompatible ways, so we
are free to do so, too. This change is a superset of changes from
the other BSDs with a few more improvements. It doesn't touch
fts(3) functionality; it just extends integer types used by it to
match modern reality and the C standard.
Here are its points:
o For C object sizes, use size_t unless it's 100% certain that
the object will be really small. (Note that fts(3) can construct
pathnames _much_ longer than PATH_MAX for its consumers.)
o Avoid the short types because on modern platforms using them
results in larger and slower code. Change shorts to ints as
follows:
- For variables than count simple, limited things like states,
use plain vanilla `int' as it's the type of choice in C.
- For a limited number of bit flags use `unsigned' because signed
bit-wise operations are implementation-defined, i.e., unportable,
in C.
o For things that should be at least 64 bits wide, use long long
and not int64_t, as the latter is an optional type. See
FTSENT.fts_number aka FTS.fts_bignum. Extending fts_number `to
satisfy future needs' is pointless because there is fts_pointer,
which can be used to link to arbitrary data from an FTSENT.
However, there already are fts(3) consumers that require fts_number,
or fts_bignum, have at least 64 bits in it, so we must allow for them.
o For the tree depth, use `long'. This is a trade-off between making
this field too wide and allowing for 64-bit inode numbers and/or
chain-mounted filesystems. On the one hand, `long' is almost
enough for 32-bit filesystems on a 32-bit platform (our ino_t is
uint32_t now). On the other hand, platforms with a 64-bit (or
wider) `long' will be ready for 64-bit inode numbers, as well as
for several 32-bit filesystems mounted one under another. Note
that fts_level has to be signed because -1 is a magic value for it,
FTS_ROOTPARENTLEVEL.
o For the `nlinks' local var in fts_build(), use `long'. The logic
in fts_build() requires that `nlinks' be signed, but our nlink_t
currently is uint16_t. Therefore let's make the signed var wide
enough to be able to represent 2^16-1 in pure C99, and even 2^32-1
on a 64-bit platform. Perhaps the logic should be changed just
to use nlink_t, but it can be done later w/o breaking fts(3) ABI
any more because `nlinks' is just a local var.
This commit also inludes supporting stuff for the fts change:
o Preserve the old versions of fts(3) functions through libc symbol
versioning because the old versions appeared in all our former releases.
o Bump __FreeBSD_version just in case. There is a small chance that
some ill-written 3-rd party apps may fail to build or work correctly
if compiled after this change.
o Update the fts(3) manpage accordingly. In particular, remove
references to fts_bignum, which was a FreeBSD-specific hack to work
around the too narrow types of FTSENT members. Now fts_number is
at least 64 bits wide (long long) and fts_bignum is an undocumented
alias for fts_number kept around for compatibility reasons. According
to Google Code Search, the only big consumers of fts_bignum are in
our own source tree, so they can be fixed easily to use fts_number.
o Mention the change in src/UPDATING.
PR: bin/104458
Approved by: re (quite a while ago)
Discussed with: deischen (the symbol versioning part)
Reviewed by: -arch (mostly silence); das (generally OK, but we didn't
agree on some types used; assuming that no objections on
-arch let me to stick to my opinion)
2008-01-26 17:09:40 +00:00
|
|
|
__fts_set_clientptr_44bsd(FTS *sp, void *clientptr)
|
2002-09-21 01:28:41 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
sp->fts_clientptr = clientptr;
|
|
|
|
}
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
/*
|
|
|
|
* This is the tricky part -- do not casually change *anything* in here. The
|
|
|
|
* idea is to build the linked list of entries that are used by fts_children
|
|
|
|
* and fts_read. There are lots of special cases.
|
|
|
|
*
|
|
|
|
* The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is
|
|
|
|
* set and it's a physical walk (so that symbolic links can't be directories),
|
|
|
|
* we can do things quickly. First, if it's a 4.4BSD file system, the type
|
|
|
|
* of the file is in the directory entry. Otherwise, we assume that the number
|
|
|
|
* of subdirectories in a node is equal to the number of links to the parent.
|
|
|
|
* The former skips all stat calls. The latter skips stat calls in any leaf
|
|
|
|
* directories and for any files after the subdirectories in the directory have
|
|
|
|
* been found, cutting the stat calls by about 2/3.
|
|
|
|
*/
|
|
|
|
static FTSENT *
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_build(FTS *sp, int type)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
struct freebsd11_dirent *dp;
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT *p, *head;
|
|
|
|
int nitems;
|
1994-05-27 05:00:24 +00:00
|
|
|
FTSENT *cur, *tail;
|
|
|
|
DIR *dirp;
|
1999-12-18 04:36:14 +00:00
|
|
|
void *oldaddr;
|
|
|
|
int cderrno, descend, len, level, maxlen, nlinks, oflag, saved_errno,
|
2020-09-27 22:26:41 +00:00
|
|
|
nostat, doadjust, dnamlen;
|
1994-05-27 05:00:24 +00:00
|
|
|
char *cp;
|
|
|
|
|
|
|
|
/* Set current node pointer. */
|
|
|
|
cur = sp->fts_cur;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Open the directory for reading. If this fails, we're done.
|
|
|
|
* If being called from fts_read, set the fts_info field.
|
|
|
|
*/
|
1997-03-11 11:52:33 +00:00
|
|
|
#ifdef FTS_WHITEOUT
|
|
|
|
if (ISSET(FTS_WHITEOUT))
|
2019-03-26 19:35:41 +00:00
|
|
|
oflag = DTF_NODUP;
|
1997-03-11 11:52:33 +00:00
|
|
|
else
|
2019-03-26 19:35:41 +00:00
|
|
|
oflag = DTF_HIDEW | DTF_NODUP;
|
1997-03-11 11:52:33 +00:00
|
|
|
#else
|
|
|
|
#define __opendir2(path, flag) opendir(path)
|
|
|
|
#endif
|
|
|
|
if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
|
1994-05-27 05:00:24 +00:00
|
|
|
if (type == BREAD) {
|
|
|
|
cur->fts_info = FTS_DNR;
|
|
|
|
cur->fts_errno = errno;
|
|
|
|
}
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Nlinks is the number of possible entries of type directory in the
|
|
|
|
* directory if we're cheating on stat calls, 0 if we're not doing
|
|
|
|
* any stat calls at all, -1 if we're doing stats on everything.
|
|
|
|
*/
|
1999-12-18 04:36:14 +00:00
|
|
|
if (type == BNAMES) {
|
1994-05-27 05:00:24 +00:00
|
|
|
nlinks = 0;
|
1999-12-18 04:36:14 +00:00
|
|
|
/* Be quiet about nostat, GCC. */
|
|
|
|
nostat = 0;
|
|
|
|
} else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
|
2004-05-08 15:09:02 +00:00
|
|
|
if (fts_ufslinks(sp, cur))
|
|
|
|
nlinks = cur->fts_nlink - (ISSET(FTS_SEEDOT) ? 0 : 2);
|
|
|
|
else
|
|
|
|
nlinks = -1;
|
1999-12-18 04:36:14 +00:00
|
|
|
nostat = 1;
|
|
|
|
} else {
|
1994-05-27 05:00:24 +00:00
|
|
|
nlinks = -1;
|
1999-12-18 04:36:14 +00:00
|
|
|
nostat = 0;
|
|
|
|
}
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
#ifdef notdef
|
|
|
|
(void)printf("nlinks == %d (cur: %d)\n", nlinks, cur->fts_nlink);
|
|
|
|
(void)printf("NOSTAT %d PHYSICAL %d SEEDOT %d\n",
|
|
|
|
ISSET(FTS_NOSTAT), ISSET(FTS_PHYSICAL), ISSET(FTS_SEEDOT));
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* If we're going to need to stat anything or we want to descend
|
|
|
|
* and stay in the directory, chdir. If this fails we keep going,
|
|
|
|
* but set a flag so we don't chdir after the post-order visit.
|
|
|
|
* We won't be able to stat anything, but we can still return the
|
|
|
|
* names themselves. Note, that since fts_read won't be able to
|
|
|
|
* chdir into the directory, it will have to return different path
|
|
|
|
* names than before, i.e. "a/b" instead of "b". Since the node
|
|
|
|
* has already been visited in pre-order, have to wait until the
|
|
|
|
* post-order visit to return the error. There is a special case
|
|
|
|
* here, if there was nothing to stat then it's not an error to
|
|
|
|
* not be able to stat. This is all fairly nasty. If a program
|
|
|
|
* needed sorted entries or stat information, they had better be
|
|
|
|
* checking FTS_NS on the returned nodes.
|
|
|
|
*/
|
|
|
|
cderrno = 0;
|
1999-12-18 04:36:14 +00:00
|
|
|
if (nlinks || type == BREAD) {
|
2012-05-19 12:44:27 +00:00
|
|
|
if (fts_safe_changedir(sp, cur, _dirfd(dirp), NULL)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
if (nlinks && type == BREAD)
|
|
|
|
cur->fts_errno = errno;
|
|
|
|
cur->fts_flags |= FTS_DONTCHDIR;
|
|
|
|
descend = 0;
|
|
|
|
cderrno = errno;
|
|
|
|
} else
|
|
|
|
descend = 1;
|
1999-12-18 04:36:14 +00:00
|
|
|
} else
|
1994-05-27 05:00:24 +00:00
|
|
|
descend = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Figure out the max file name length that can be stored in the
|
|
|
|
* current path -- the inner loop allocates more path as necessary.
|
|
|
|
* We really wouldn't have to do the maxlen calculations here, we
|
|
|
|
* could do them in fts_read before returning the path, but it's a
|
|
|
|
* lot easier here since the length is part of the dirent structure.
|
|
|
|
*
|
|
|
|
* If not changing directories set a pointer so that can just append
|
|
|
|
* each new name into the path.
|
|
|
|
*/
|
|
|
|
len = NAPPEND(cur);
|
|
|
|
if (ISSET(FTS_NOCHDIR)) {
|
|
|
|
cp = sp->fts_path + len;
|
|
|
|
*cp++ = '/';
|
1999-12-18 04:36:14 +00:00
|
|
|
} else {
|
|
|
|
/* GCC, you're too verbose. */
|
|
|
|
cp = NULL;
|
1994-05-27 05:00:24 +00:00
|
|
|
}
|
1999-12-18 04:36:14 +00:00
|
|
|
len++;
|
|
|
|
maxlen = sp->fts_pathlen - len;
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
level = cur->fts_level + 1;
|
|
|
|
|
|
|
|
/* Read the directory, attaching each entry to the `link' pointer. */
|
1999-12-18 04:36:14 +00:00
|
|
|
doadjust = 0;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
for (head = tail = NULL, nitems = 0;
|
|
|
|
dirp && (dp = freebsd11_readdir(dirp));) {
|
2004-05-05 06:33:00 +00:00
|
|
|
dnamlen = dp->d_namlen;
|
1994-05-27 05:00:24 +00:00
|
|
|
if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
|
|
|
|
continue;
|
|
|
|
|
2020-09-27 22:26:41 +00:00
|
|
|
if ((p = fts_alloc(sp, dp->d_name, dnamlen)) == NULL)
|
1994-05-27 05:00:24 +00:00
|
|
|
goto mem1;
|
2004-05-05 06:33:00 +00:00
|
|
|
if (dnamlen >= maxlen) { /* include space for NUL */
|
1999-12-18 04:36:14 +00:00
|
|
|
oldaddr = sp->fts_path;
|
2004-05-05 06:33:00 +00:00
|
|
|
if (fts_palloc(sp, dnamlen + len + 1)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
/*
|
|
|
|
* No more memory for path or structures. Save
|
|
|
|
* errno, free up the current structure and the
|
|
|
|
* structures already allocated.
|
|
|
|
*/
|
|
|
|
mem1: saved_errno = errno;
|
|
|
|
if (p)
|
|
|
|
free(p);
|
|
|
|
fts_lfree(head);
|
|
|
|
(void)closedir(dirp);
|
|
|
|
cur->fts_info = FTS_ERR;
|
|
|
|
SET(FTS_STOP);
|
1999-12-18 04:36:14 +00:00
|
|
|
errno = saved_errno;
|
1994-05-27 05:00:24 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
1999-12-18 04:36:14 +00:00
|
|
|
/* Did realloc() change the pointer? */
|
|
|
|
if (oldaddr != sp->fts_path) {
|
|
|
|
doadjust = 1;
|
|
|
|
if (ISSET(FTS_NOCHDIR))
|
|
|
|
cp = sp->fts_path + len;
|
|
|
|
}
|
|
|
|
maxlen = sp->fts_pathlen - len;
|
1994-05-27 05:00:24 +00:00
|
|
|
}
|
|
|
|
|
2004-05-05 06:33:00 +00:00
|
|
|
if (len + dnamlen >= USHRT_MAX) {
|
1999-12-18 04:36:14 +00:00
|
|
|
/*
|
|
|
|
* In an FTSENT, fts_pathlen is a u_short so it is
|
|
|
|
* possible to wraparound here. If we do, free up
|
|
|
|
* the current structure and the structures already
|
|
|
|
* allocated, then error out with ENAMETOOLONG.
|
|
|
|
*/
|
|
|
|
free(p);
|
|
|
|
fts_lfree(head);
|
|
|
|
(void)closedir(dirp);
|
|
|
|
cur->fts_info = FTS_ERR;
|
|
|
|
SET(FTS_STOP);
|
|
|
|
errno = ENAMETOOLONG;
|
|
|
|
return (NULL);
|
|
|
|
}
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_level = level;
|
1999-12-18 04:36:14 +00:00
|
|
|
p->fts_parent = sp->fts_cur;
|
2004-05-05 06:33:00 +00:00
|
|
|
p->fts_pathlen = len + dnamlen;
|
1994-05-27 05:00:24 +00:00
|
|
|
|
1997-03-11 11:52:33 +00:00
|
|
|
#ifdef FTS_WHITEOUT
|
|
|
|
if (dp->d_type == DT_WHT)
|
|
|
|
p->fts_flags |= FTS_ISW;
|
|
|
|
#endif
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
if (cderrno) {
|
|
|
|
if (nlinks) {
|
|
|
|
p->fts_info = FTS_NS;
|
|
|
|
p->fts_errno = cderrno;
|
|
|
|
} else
|
|
|
|
p->fts_info = FTS_NSOK;
|
|
|
|
p->fts_accpath = cur->fts_accpath;
|
|
|
|
} else if (nlinks == 0
|
|
|
|
#ifdef DT_DIR
|
1999-12-18 04:36:14 +00:00
|
|
|
|| (nostat &&
|
1996-07-12 18:57:58 +00:00
|
|
|
dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
|
1994-05-27 05:00:24 +00:00
|
|
|
#endif
|
|
|
|
) {
|
|
|
|
p->fts_accpath =
|
|
|
|
ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name;
|
|
|
|
p->fts_info = FTS_NSOK;
|
|
|
|
} else {
|
|
|
|
/* Build a file name for fts_stat to stat. */
|
|
|
|
if (ISSET(FTS_NOCHDIR)) {
|
|
|
|
p->fts_accpath = p->fts_path;
|
|
|
|
memmove(cp, p->fts_name, p->fts_namelen + 1);
|
|
|
|
} else
|
|
|
|
p->fts_accpath = p->fts_name;
|
|
|
|
/* Stat it. */
|
|
|
|
p->fts_info = fts_stat(sp, p, 0);
|
|
|
|
|
|
|
|
/* Decrement link count if applicable. */
|
|
|
|
if (nlinks > 0 && (p->fts_info == FTS_D ||
|
|
|
|
p->fts_info == FTS_DC || p->fts_info == FTS_DOT))
|
|
|
|
--nlinks;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We walk in directory order so "ls -f" doesn't get upset. */
|
|
|
|
p->fts_link = NULL;
|
|
|
|
if (head == NULL)
|
|
|
|
head = tail = p;
|
|
|
|
else {
|
|
|
|
tail->fts_link = p;
|
|
|
|
tail = p;
|
|
|
|
}
|
|
|
|
++nitems;
|
|
|
|
}
|
1997-08-29 22:56:41 +00:00
|
|
|
if (dirp)
|
|
|
|
(void)closedir(dirp);
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
/*
|
1999-12-18 04:36:14 +00:00
|
|
|
* If realloc() changed the address of the path, adjust the
|
|
|
|
* addresses for the rest of the tree and the dir list.
|
1994-05-27 05:00:24 +00:00
|
|
|
*/
|
1999-12-18 04:36:14 +00:00
|
|
|
if (doadjust)
|
|
|
|
fts_padjust(sp, head);
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If not changing directories, reset the path back to original
|
|
|
|
* state.
|
|
|
|
*/
|
|
|
|
if (ISSET(FTS_NOCHDIR)) {
|
1999-12-18 04:36:14 +00:00
|
|
|
if (len == sp->fts_pathlen || nitems == 0)
|
1994-05-27 05:00:24 +00:00
|
|
|
--cp;
|
|
|
|
*cp = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If descended after called from fts_children or after called from
|
|
|
|
* fts_read and nothing found, get back. At the root level we use
|
|
|
|
* the saved fd; if one of fts_open()'s arguments is a relative path
|
|
|
|
* to an empty directory, we wind up here with no other way back. If
|
|
|
|
* can't get back, we're done.
|
|
|
|
*/
|
|
|
|
if (descend && (type == BCHILD || !nitems) &&
|
|
|
|
(cur->fts_level == FTS_ROOTLEVEL ?
|
2001-06-01 21:53:50 +00:00
|
|
|
FCHDIR(sp, sp->fts_rfd) :
|
|
|
|
fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
|
1994-05-27 05:00:24 +00:00
|
|
|
cur->fts_info = FTS_ERR;
|
|
|
|
SET(FTS_STOP);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If didn't find anything, return NULL. */
|
|
|
|
if (!nitems) {
|
|
|
|
if (type == BREAD)
|
|
|
|
cur->fts_info = FTS_DP;
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sort the entries. */
|
|
|
|
if (sp->fts_compar && nitems > 1)
|
|
|
|
head = fts_sort(sp, head, nitems);
|
|
|
|
return (head);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u_short
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_stat(FTS *sp, FTSENT *p, int follow)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT *t;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
uint32_t dev;
|
|
|
|
uint32_t ino;
|
|
|
|
struct freebsd11_stat *sbp, sb;
|
1994-05-27 05:00:24 +00:00
|
|
|
int saved_errno;
|
|
|
|
|
|
|
|
/* If user needs stat info, stat buffer already allocated. */
|
|
|
|
sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;
|
1995-05-30 05:51:47 +00:00
|
|
|
|
1997-03-11 11:52:33 +00:00
|
|
|
#ifdef FTS_WHITEOUT
|
2004-05-13 15:59:38 +00:00
|
|
|
/* Check for whiteout. */
|
1997-03-11 11:52:33 +00:00
|
|
|
if (p->fts_flags & FTS_ISW) {
|
|
|
|
if (sbp != &sb) {
|
2004-05-13 15:59:38 +00:00
|
|
|
memset(sbp, '\0', sizeof(*sbp));
|
1997-03-11 11:52:33 +00:00
|
|
|
sbp->st_mode = S_IFWHT;
|
|
|
|
}
|
|
|
|
return (FTS_W);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
/*
|
|
|
|
* If doing a logical walk, or application requested FTS_FOLLOW, do
|
|
|
|
* a stat(2). If that fails, check for a non-existent symlink. If
|
|
|
|
* fail, set the errno from the stat call.
|
|
|
|
*/
|
|
|
|
if (ISSET(FTS_LOGICAL) || follow) {
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
if (freebsd11_stat(p->fts_accpath, sbp)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
saved_errno = errno;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
if (!freebsd11_lstat(p->fts_accpath, sbp)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
errno = 0;
|
|
|
|
return (FTS_SLNONE);
|
1995-05-30 05:51:47 +00:00
|
|
|
}
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_errno = saved_errno;
|
|
|
|
goto err;
|
|
|
|
}
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
} else if (freebsd11_lstat(p->fts_accpath, sbp)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_errno = errno;
|
2018-05-28 02:31:49 +00:00
|
|
|
err: memset(sbp, 0, sizeof(*sbp));
|
1994-05-27 05:00:24 +00:00
|
|
|
return (FTS_NS);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (S_ISDIR(sbp->st_mode)) {
|
|
|
|
/*
|
|
|
|
* Set the device/inode. Used to find cycles and check for
|
|
|
|
* crossing mount points. Also remember the link count, used
|
|
|
|
* in fts_build to limit the number of stat calls. It is
|
|
|
|
* understood that these fields are only referenced if fts_info
|
|
|
|
* is set to FTS_D.
|
|
|
|
*/
|
|
|
|
dev = p->fts_dev = sbp->st_dev;
|
|
|
|
ino = p->fts_ino = sbp->st_ino;
|
|
|
|
p->fts_nlink = sbp->st_nlink;
|
|
|
|
|
|
|
|
if (ISDOT(p->fts_name))
|
|
|
|
return (FTS_DOT);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cycle detection is done by brute force when the directory
|
|
|
|
* is first encountered. If the tree gets deep enough or the
|
|
|
|
* number of symbolic links to directories is high enough,
|
|
|
|
* something faster might be worthwhile.
|
|
|
|
*/
|
|
|
|
for (t = p->fts_parent;
|
|
|
|
t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
|
|
|
|
if (ino == t->fts_ino && dev == t->fts_dev) {
|
|
|
|
p->fts_cycle = t;
|
|
|
|
return (FTS_DC);
|
|
|
|
}
|
|
|
|
return (FTS_D);
|
|
|
|
}
|
|
|
|
if (S_ISLNK(sbp->st_mode))
|
|
|
|
return (FTS_SL);
|
|
|
|
if (S_ISREG(sbp->st_mode))
|
|
|
|
return (FTS_F);
|
|
|
|
return (FTS_DEFAULT);
|
|
|
|
}
|
|
|
|
|
2002-09-21 01:28:41 +00:00
|
|
|
/*
|
|
|
|
* The comparison function takes pointers to pointers to FTSENT structures.
|
|
|
|
* Qsort wants a comparison function that takes pointers to void.
|
|
|
|
* (Both with appropriate levels of const-poisoning, of course!)
|
|
|
|
* Use a trampoline function to deal with the difference.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
fts_compar(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
FTS *parent;
|
|
|
|
|
|
|
|
parent = (*(const FTSENT * const *)a)->fts_fts;
|
|
|
|
return (*parent->fts_compar)(a, b);
|
|
|
|
}
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
static FTSENT *
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_sort(FTS *sp, FTSENT *head, int nitems)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT **ap, *p;
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct an array of pointers to the structures and call qsort(3).
|
|
|
|
* Reassemble the array in the order returned by qsort. If unable to
|
|
|
|
* sort for memory reasons, return the directory entries in their
|
|
|
|
* current order. Allocate enough space for the current needs plus
|
|
|
|
* 40 so don't realloc one entry at a time.
|
|
|
|
*/
|
|
|
|
if (nitems > sp->fts_nitems) {
|
|
|
|
sp->fts_nitems = nitems + 40;
|
2000-08-16 23:37:16 +00:00
|
|
|
if ((sp->fts_array = reallocf(sp->fts_array,
|
1999-12-18 04:36:14 +00:00
|
|
|
sp->fts_nitems * sizeof(FTSENT *))) == NULL) {
|
1994-05-27 05:00:24 +00:00
|
|
|
sp->fts_nitems = 0;
|
|
|
|
return (head);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (ap = sp->fts_array, p = head; p; p = p->fts_link)
|
|
|
|
*ap++ = p;
|
2002-09-21 01:28:41 +00:00
|
|
|
qsort(sp->fts_array, nitems, sizeof(FTSENT *), fts_compar);
|
1994-05-27 05:00:24 +00:00
|
|
|
for (head = *(ap = sp->fts_array); --nitems; ++ap)
|
|
|
|
ap[0]->fts_link = ap[1];
|
|
|
|
ap[0]->fts_link = NULL;
|
|
|
|
return (head);
|
|
|
|
}
|
|
|
|
|
|
|
|
static FTSENT *
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_alloc(FTS *sp, char *name, int namelen)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT *p;
|
1994-05-27 05:00:24 +00:00
|
|
|
size_t len;
|
|
|
|
|
2002-09-21 01:28:41 +00:00
|
|
|
struct ftsent_withstat {
|
|
|
|
FTSENT ent;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
struct freebsd11_stat statbuf;
|
2002-09-21 01:28:41 +00:00
|
|
|
};
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
/*
|
|
|
|
* The file name is a variable length array and no stat structure is
|
|
|
|
* necessary if the user has set the nostat bit. Allocate the FTSENT
|
|
|
|
* structure, the file name and the stat structure in one chunk, but
|
2002-09-21 01:28:41 +00:00
|
|
|
* be careful that the stat structure is reasonably aligned.
|
1994-05-27 05:00:24 +00:00
|
|
|
*/
|
2002-09-21 01:28:41 +00:00
|
|
|
if (ISSET(FTS_NOSTAT))
|
|
|
|
len = sizeof(FTSENT) + namelen + 1;
|
|
|
|
else
|
|
|
|
len = sizeof(struct ftsent_withstat) + namelen + 1;
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
if ((p = malloc(len)) == NULL)
|
|
|
|
return (NULL);
|
|
|
|
|
2002-09-21 01:28:41 +00:00
|
|
|
if (ISSET(FTS_NOSTAT)) {
|
|
|
|
p->fts_name = (char *)(p + 1);
|
|
|
|
p->fts_statp = NULL;
|
|
|
|
} else {
|
|
|
|
p->fts_name = (char *)((struct ftsent_withstat *)p + 1);
|
|
|
|
p->fts_statp = &((struct ftsent_withstat *)p)->statbuf;
|
|
|
|
}
|
|
|
|
|
1999-12-18 04:36:14 +00:00
|
|
|
/* Copy the name and guarantee NUL termination. */
|
2002-09-21 01:28:41 +00:00
|
|
|
memcpy(p->fts_name, name, namelen);
|
1999-12-18 04:36:14 +00:00
|
|
|
p->fts_name[namelen] = '\0';
|
1994-05-27 05:00:24 +00:00
|
|
|
p->fts_namelen = namelen;
|
|
|
|
p->fts_path = sp->fts_path;
|
|
|
|
p->fts_errno = 0;
|
|
|
|
p->fts_flags = 0;
|
|
|
|
p->fts_instr = FTS_NOINSTR;
|
|
|
|
p->fts_number = 0;
|
|
|
|
p->fts_pointer = NULL;
|
2002-09-21 01:28:41 +00:00
|
|
|
p->fts_fts = sp;
|
1994-05-27 05:00:24 +00:00
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_lfree(FTSENT *head)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
2002-02-01 01:32:19 +00:00
|
|
|
FTSENT *p;
|
1994-05-27 05:00:24 +00:00
|
|
|
|
|
|
|
/* Free a linked list of structures. */
|
1997-08-29 22:56:41 +00:00
|
|
|
while ((p = head)) {
|
1994-05-27 05:00:24 +00:00
|
|
|
head = head->fts_link;
|
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allow essentially unlimited paths; find, rm, ls should all work on any tree.
|
|
|
|
* Most systems will allow creation of paths much longer than MAXPATHLEN, even
|
|
|
|
* though the kernel won't resolve them. Add the size (not just what's needed)
|
1995-05-30 05:51:47 +00:00
|
|
|
* plus 256 bytes so don't realloc the path 2 bytes at a time.
|
1994-05-27 05:00:24 +00:00
|
|
|
*/
|
|
|
|
static int
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_palloc(FTS *sp, size_t more)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
|
|
|
|
1999-12-18 04:36:14 +00:00
|
|
|
sp->fts_pathlen += more + 256;
|
|
|
|
/*
|
|
|
|
* Check for possible wraparound. In an FTS, fts_pathlen is
|
|
|
|
* a signed int but in an FTSENT it is an unsigned short.
|
|
|
|
* We limit fts_pathlen to USHRT_MAX to be safe in both cases.
|
|
|
|
*/
|
|
|
|
if (sp->fts_pathlen < 0 || sp->fts_pathlen >= USHRT_MAX) {
|
|
|
|
if (sp->fts_path)
|
|
|
|
free(sp->fts_path);
|
|
|
|
sp->fts_path = NULL;
|
|
|
|
errno = ENAMETOOLONG;
|
|
|
|
return (1);
|
1999-09-02 07:45:07 +00:00
|
|
|
}
|
2000-08-16 23:37:16 +00:00
|
|
|
sp->fts_path = reallocf(sp->fts_path, sp->fts_pathlen);
|
|
|
|
return (sp->fts_path == NULL);
|
1999-09-02 07:45:07 +00:00
|
|
|
}
|
|
|
|
|
1994-05-27 05:00:24 +00:00
|
|
|
/*
|
|
|
|
* When the path is realloc'd, have to fix all of the pointers in structures
|
|
|
|
* already returned.
|
|
|
|
*/
|
|
|
|
static void
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_padjust(FTS *sp, FTSENT *head)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
|
|
|
FTSENT *p;
|
1999-12-18 04:36:14 +00:00
|
|
|
char *addr = sp->fts_path;
|
1994-05-27 05:00:24 +00:00
|
|
|
|
2000-08-16 23:37:16 +00:00
|
|
|
#define ADJUST(p) do { \
|
1999-12-18 04:36:14 +00:00
|
|
|
if ((p)->fts_accpath != (p)->fts_name) { \
|
|
|
|
(p)->fts_accpath = \
|
|
|
|
(char *)addr + ((p)->fts_accpath - (p)->fts_path); \
|
|
|
|
} \
|
1994-05-27 05:00:24 +00:00
|
|
|
(p)->fts_path = addr; \
|
2000-08-16 23:37:16 +00:00
|
|
|
} while (0)
|
1994-05-27 05:00:24 +00:00
|
|
|
/* Adjust the current set of children. */
|
|
|
|
for (p = sp->fts_child; p; p = p->fts_link)
|
1999-12-18 04:36:14 +00:00
|
|
|
ADJUST(p);
|
1994-05-27 05:00:24 +00:00
|
|
|
|
1999-12-18 04:36:14 +00:00
|
|
|
/* Adjust the rest of the tree, including the current level. */
|
|
|
|
for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {
|
|
|
|
ADJUST(p);
|
1994-05-27 05:00:24 +00:00
|
|
|
p = p->fts_link ? p->fts_link : p->fts_parent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_maxarglen(char * const *argv)
|
1994-05-27 05:00:24 +00:00
|
|
|
{
|
|
|
|
size_t len, max;
|
|
|
|
|
|
|
|
for (max = 0; *argv; ++argv)
|
|
|
|
if ((len = strlen(*argv)) > max)
|
|
|
|
max = len;
|
1999-12-18 04:36:14 +00:00
|
|
|
return (max + 1);
|
1994-05-27 05:00:24 +00:00
|
|
|
}
|
1997-08-29 22:56:41 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Change to dir specified by fd or p->fts_accpath without getting
|
|
|
|
* tricked by someone changing the world out from underneath us.
|
|
|
|
* Assumes p->fts_dev and p->fts_ino are filled in.
|
|
|
|
*/
|
|
|
|
static int
|
2015-09-14 18:44:13 +00:00
|
|
|
fts_safe_changedir(FTS *sp, FTSENT *p, int fd, char *path)
|
1997-08-29 22:56:41 +00:00
|
|
|
{
|
|
|
|
int ret, oerrno, newfd;
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
struct freebsd11_stat sb;
|
1997-08-29 22:56:41 +00:00
|
|
|
|
|
|
|
newfd = fd;
|
|
|
|
if (ISSET(FTS_NOCHDIR))
|
|
|
|
return (0);
|
2012-09-27 22:05:54 +00:00
|
|
|
if (fd < 0 && (newfd = _open(path, O_RDONLY | O_CLOEXEC, 0)) < 0)
|
1997-08-29 22:56:41 +00:00
|
|
|
return (-1);
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
if (freebsd11_fstat(newfd, &sb)) {
|
1997-08-29 22:56:41 +00:00
|
|
|
ret = -1;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
if (p->fts_dev != sb.st_dev || p->fts_ino != sb.st_ino) {
|
|
|
|
errno = ENOENT; /* disinformation */
|
|
|
|
ret = -1;
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
ret = fchdir(newfd);
|
|
|
|
bail:
|
|
|
|
oerrno = errno;
|
|
|
|
if (fd < 0)
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
(void)_close(newfd);
|
1997-08-29 22:56:41 +00:00
|
|
|
errno = oerrno;
|
|
|
|
return (ret);
|
|
|
|
}
|
2004-05-08 15:09:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the filesystem for "ent" has UFS-style links.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
fts_ufslinks(FTS *sp, const FTSENT *ent)
|
|
|
|
{
|
|
|
|
struct _fts_private *priv;
|
|
|
|
const char **cpp;
|
|
|
|
|
2004-05-12 21:38:39 +00:00
|
|
|
priv = (struct _fts_private *)sp;
|
2004-05-08 15:09:02 +00:00
|
|
|
/*
|
|
|
|
* If this node's device is different from the previous, grab
|
|
|
|
* the filesystem information, and decide on the reliability
|
|
|
|
* of the link information from this filesystem for stat(2)
|
|
|
|
* avoidance.
|
|
|
|
*/
|
|
|
|
if (priv->ftsp_dev != ent->fts_dev) {
|
Commit the 64-bit inode project.
Extend the ino_t, dev_t, nlink_t types to 64-bit ints. Modify
struct dirent layout to add d_off, increase the size of d_fileno
to 64-bits, increase the size of d_namlen to 16-bits, and change
the required alignment. Increase struct statfs f_mntfromname[] and
f_mntonname[] array length MNAMELEN to 1024.
ABI breakage is mitigated by providing compatibility using versioned
symbols, ingenious use of the existing padding in structures, and
by employing other tricks. Unfortunately, not everything can be
fixed, especially outside the base system. For instance, third-party
APIs which pass struct stat around are broken in backward and
forward incompatible ways.
Kinfo sysctl MIBs ABI is changed in backward-compatible way, but
there is no general mechanism to handle other sysctl MIBS which
return structures where the layout has changed. It was considered
that the breakage is either in the management interfaces, where we
usually allow ABI slip, or is not important.
Struct xvnode changed layout, no compat shims are provided.
For struct xtty, dev_t tty device member was reduced to uint32_t.
It was decided that keeping ABI compat in this case is more useful
than reporting 64-bit dev_t, for the sake of pstat.
Update note: strictly follow the instructions in UPDATING. Build
and install the new kernel with COMPAT_FREEBSD11 option enabled,
then reboot, and only then install new world.
Credits: The 64-bit inode project, also known as ino64, started life
many years ago as a project by Gleb Kurtsou (gleb). Kirk McKusick
(mckusick) then picked up and updated the patch, and acted as a
flag-waver. Feedback, suggestions, and discussions were carried
by Ed Maste (emaste), John Baldwin (jhb), Jilles Tjoelker (jilles),
and Rick Macklem (rmacklem). Kris Moore (kris) performed an initial
ports investigation followed by an exp-run by Antoine Brodin (antoine).
Essential and all-embracing testing was done by Peter Holm (pho).
The heavy lifting of coordinating all these efforts and bringing the
project to completion were done by Konstantin Belousov (kib).
Sponsored by: The FreeBSD Foundation (emaste, kib)
Differential revision: https://reviews.freebsd.org/D10439
2017-05-23 09:29:05 +00:00
|
|
|
if (freebsd11_statfs(ent->fts_path, &priv->ftsp_statfs) != -1) {
|
2004-05-08 15:09:02 +00:00
|
|
|
priv->ftsp_dev = ent->fts_dev;
|
|
|
|
priv->ftsp_linksreliable = 0;
|
|
|
|
for (cpp = ufslike_filesystems; *cpp; cpp++) {
|
|
|
|
if (strcmp(priv->ftsp_statfs.f_fstypename,
|
|
|
|
*cpp) == 0) {
|
|
|
|
priv->ftsp_linksreliable = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
priv->ftsp_linksreliable = 0;
|
|
|
|
}
|
|
|
|
}
|
2004-05-12 21:38:39 +00:00
|
|
|
return (priv->ftsp_linksreliable);
|
2004-05-08 15:09:02 +00:00
|
|
|
}
|
Our fts(3) API, as inherited from 4.4BSD, suffers from integer
fields in FTS and FTSENT structs being too narrow. In addition,
the narrow types creep from there into fts.c. As a result, fts(3)
consumers, e.g., find(1) or rm(1), can't handle file trees an ordinary
user can create, which can have security implications.
To fix the historic implementation of fts(3), OpenBSD and NetBSD
have already changed <fts.h> in somewhat incompatible ways, so we
are free to do so, too. This change is a superset of changes from
the other BSDs with a few more improvements. It doesn't touch
fts(3) functionality; it just extends integer types used by it to
match modern reality and the C standard.
Here are its points:
o For C object sizes, use size_t unless it's 100% certain that
the object will be really small. (Note that fts(3) can construct
pathnames _much_ longer than PATH_MAX for its consumers.)
o Avoid the short types because on modern platforms using them
results in larger and slower code. Change shorts to ints as
follows:
- For variables than count simple, limited things like states,
use plain vanilla `int' as it's the type of choice in C.
- For a limited number of bit flags use `unsigned' because signed
bit-wise operations are implementation-defined, i.e., unportable,
in C.
o For things that should be at least 64 bits wide, use long long
and not int64_t, as the latter is an optional type. See
FTSENT.fts_number aka FTS.fts_bignum. Extending fts_number `to
satisfy future needs' is pointless because there is fts_pointer,
which can be used to link to arbitrary data from an FTSENT.
However, there already are fts(3) consumers that require fts_number,
or fts_bignum, have at least 64 bits in it, so we must allow for them.
o For the tree depth, use `long'. This is a trade-off between making
this field too wide and allowing for 64-bit inode numbers and/or
chain-mounted filesystems. On the one hand, `long' is almost
enough for 32-bit filesystems on a 32-bit platform (our ino_t is
uint32_t now). On the other hand, platforms with a 64-bit (or
wider) `long' will be ready for 64-bit inode numbers, as well as
for several 32-bit filesystems mounted one under another. Note
that fts_level has to be signed because -1 is a magic value for it,
FTS_ROOTPARENTLEVEL.
o For the `nlinks' local var in fts_build(), use `long'. The logic
in fts_build() requires that `nlinks' be signed, but our nlink_t
currently is uint16_t. Therefore let's make the signed var wide
enough to be able to represent 2^16-1 in pure C99, and even 2^32-1
on a 64-bit platform. Perhaps the logic should be changed just
to use nlink_t, but it can be done later w/o breaking fts(3) ABI
any more because `nlinks' is just a local var.
This commit also inludes supporting stuff for the fts change:
o Preserve the old versions of fts(3) functions through libc symbol
versioning because the old versions appeared in all our former releases.
o Bump __FreeBSD_version just in case. There is a small chance that
some ill-written 3-rd party apps may fail to build or work correctly
if compiled after this change.
o Update the fts(3) manpage accordingly. In particular, remove
references to fts_bignum, which was a FreeBSD-specific hack to work
around the too narrow types of FTSENT members. Now fts_number is
at least 64 bits wide (long long) and fts_bignum is an undocumented
alias for fts_number kept around for compatibility reasons. According
to Google Code Search, the only big consumers of fts_bignum are in
our own source tree, so they can be fixed easily to use fts_number.
o Mention the change in src/UPDATING.
PR: bin/104458
Approved by: re (quite a while ago)
Discussed with: deischen (the symbol versioning part)
Reviewed by: -arch (mostly silence); das (generally OK, but we didn't
agree on some types used; assuming that no objections on
-arch let me to stick to my opinion)
2008-01-26 17:09:40 +00:00
|
|
|
|
|
|
|
__sym_compat(fts_open, __fts_open_44bsd, FBSD_1.0);
|
|
|
|
__sym_compat(fts_close, __fts_close_44bsd, FBSD_1.0);
|
|
|
|
__sym_compat(fts_read, __fts_read_44bsd, FBSD_1.0);
|
|
|
|
__sym_compat(fts_set, __fts_set_44bsd, FBSD_1.0);
|
|
|
|
__sym_compat(fts_children, __fts_children_44bsd, FBSD_1.0);
|
|
|
|
__sym_compat(fts_get_clientptr, __fts_get_clientptr_44bsd, FBSD_1.0);
|
|
|
|
__sym_compat(fts_get_stream, __fts_get_stream_44bsd, FBSD_1.0);
|
|
|
|
__sym_compat(fts_set_clientptr, __fts_set_clientptr_44bsd, FBSD_1.0);
|