xfsprogs: program changes (mostly xfs_scrub) for 6.10
Hi everyone,
This is a partial patchbomb of all the changes I would like to merge for xfsprogs 6.10. The first patchset adds exchange-range support, and the 11th patchset adds parent pointers support. Nearly everything else are all the fixes needed in userspace (i.e. xfs_scrub) to complete online repair.
Most of the new stuff for xfs_scrub are a lot of hardening of the systemd system services; strengthening of the deceptive unicode checker to report on the last few years' worth of unicode attacks; and better responsiveness during the phase 8 FITRIM.
I've omitted everything that's already passed review, which cut down on the patch count substantially. Any patch with an 'R' column 1 has been reviewed by someone; a patch with a '-' in column 1 has not been RVB'd.
[PATCHSET v30.7 01/16] xfsprogs: atomic file updates
- [PATCH 01/12] man: document the exchange-range ioctl
- [PATCH 02/12] man: document XFS_FSOP_GEOM_FLAGS_EXCHRANGE
- [PATCH 03/12] libhandle: add support for bulkstat v5
- [PATCH 04/12] libfrog: add support for exchange range ioctl family
- [PATCH 05/12] xfs_db: advertise exchange-range in the version command
- [PATCH 06/12] xfs_logprint: support dumping exchmaps log items
- [PATCH 07/12] xfs_fsr: convert to bulkstat v5 ioctls
- [PATCH 08/12] xfs_fsr: skip the xattr/forkoff levering with the newer
- [PATCH 09/12] xfs_io: create exchangerange command to test file range
- [PATCH 10/12] libfrog: advertise exchange-range support
- [PATCH 11/12] xfs_repair: add exchange-range to file systems
- [PATCH 12/12] mkfs: add a formatting option for exchange-range [PATCHSET v30.7 02/16] xfsprogs: inode-related repair fixes
- [PATCH 1/3] xfs_{db,repair}: add an explicit owner field to
- [PATCH 2/3] libxfs: port the bumplink function from the kernel
- [PATCH 3/3] mkfs/repair: pin inodes that would otherwise overflow [PATCHSET v30.7 03/16] xfs_scrub: detect deceptive filename
- [PATCH 01/13] xfs_scrub: use proper UChar string iterators
- [PATCH 02/13] xfs_scrub: hoist code that removes ignorable characters
- [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code
- [PATCH 04/13] xfs_scrub: avoid potential UAF after freeing a
- [PATCH 05/13] xfs_scrub: guard against libicu returning negative
- [PATCH 06/13] xfs_scrub: hoist non-rendering character predicate
- [PATCH 07/13] xfs_scrub: store bad flags with the name entry
- [PATCH 08/13] xfs_scrub: rename UNICRASH_ZERO_WIDTH to
- [PATCH 09/13] xfs_scrub: type-coerce the UNICRASH_* flags
- [PATCH 10/13] xfs_scrub: reduce size of struct name_entry
- [PATCH 11/13] xfs_scrub: rename struct unicrash.normalizer
- [PATCH 12/13] xfs_scrub: report deceptive file extensions
- [PATCH 13/13] xfs_scrub: dump unicode points
[PATCHSET v30.7 04/16] xfs_scrub: move fstrim to a separate phase
- [PATCH 1/8] xfs_scrub: move FITRIM to phase 8
- [PATCH 2/8] xfs_scrub: ignore phase 8 if the user disabled fstrim
- [PATCH 3/8] xfs_scrub: collapse trim_filesystem
- [PATCH 4/8] xfs_scrub: fix the work estimation for phase 8
- [PATCH 5/8] xfs_scrub: report FITRIM errors properly
- [PATCH 6/8] xfs_scrub: don't call FITRIM after runtime errors
- [PATCH 7/8] xfs_scrub: don't trim the first agbno of each AG for
- [PATCH 8/8] xfs_scrub: improve progress meter for phase 8 fstrimming [PATCHSET v30.7 05/16] xfs_scrub: use free space histograms to reduce
- [PATCH 1/7] libfrog: hoist free space histogram code
- [PATCH 2/7] libfrog: print wider columns for free space histogram
- [PATCH 3/7] libfrog: print cdf of free space buckets
- [PATCH 4/7] xfs_scrub: don't close stdout when closing the progress
- [PATCH 5/7] xfs_scrub: remove pointless spacemap.c arguments
- [PATCH 6/7] xfs_scrub: collect free space histograms during phase 7
- [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free [PATCHSET v30.7 06/16] xfs_scrub: tighten security of systemd
- [PATCH 1/6] xfs_scrub: allow auxiliary pathnames for sandboxing R [PATCH 2/6] xfs_scrub.service: reduce CPU usage to 60%% when possible R [PATCH 3/6] xfs_scrub: use dynamic users when running as a systemd R [PATCH 4/6] xfs_scrub: tighten up the security on the background
- [PATCH 5/6] xfs_scrub_fail: tighten up the security on the background
- [PATCH 6/6] xfs_scrub_all: tighten up the security on the background [PATCHSET v30.7 07/16] xfs_scrub_all: automatic media scan service
- [PATCH 1/6] xfs_scrub_all: only use the xfs_scrub@ systemd services
- [PATCH 2/6] xfs_scrub_all: remove journalctl background process
- [PATCH 3/6] xfs_scrub_all: support metadata+media scans of all
- [PATCH 4/6] xfs_scrub_all: enable periodic file data scrubs
- [PATCH 5/6] xfs_scrub_all: trigger automatic media scans once per
- [PATCH 6/6] xfs_scrub_all: failure reporting for the xfs_scrub_all [PATCHSET v30.7 08/16] xfs_scrub_all: improve systemd handling
- [PATCH 1/5] xfs_scrub_all: encapsulate all the subprocess code in an
- [PATCH 2/5] xfs_scrub_all: encapsulate all the systemctl code in an
- [PATCH 3/5] xfs_scrub_all: add CLI option for easier debugging
- [PATCH 4/5] xfs_scrub_all: convert systemctl calls to dbus
- [PATCH 5/5] xfs_scrub_all: implement retry and backoff for dbus calls [PATCHSET v30.7 09/16] xfs_scrub: automatic optimization by default
- [PATCH 1/3] xfs_scrub: automatic downgrades to dry-run mode in
- [PATCH 2/3] xfs_scrub: add an optimization-only mode
- [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by [PATCHSET v13.7 10/16] xfsprogs: improve extended attribute
- [PATCH 1/3] xfs_repair: check free space requirements before allowing
- [PATCH 2/3] xfs_repair: enforce one namespace bit per extended
- [PATCH 3/3] xfs_repair: check for unknown flags in attr entries [PATCHSET v13.7 11/16] xfsprogs: Parent Pointers
- [PATCH 01/24] libxfs: create attr log item opcodes and formats for
- [PATCH 02/24] xfs_{db,repair}: implement new attr hash value function
- [PATCH 03/24] xfs_logprint: dump new attr log item fields
- [PATCH 04/24] man: document the XFS_IOC_GETPARENTS ioctl
- [PATCH 05/24] libfrog: report parent pointers to userspace
- [PATCH 06/24] libfrog: add parent pointer support code
R [PATCH 07/24] xfs_io: adapt parent command to new parent pointer R [PATCH 08/24] xfs_io: Add i, n and f flags to parent command R [PATCH 09/24] xfs_logprint: decode parent pointers in ATTRI items
- [PATCH 10/24] xfs_spaceman: report file paths
- [PATCH 11/24] xfs_scrub: use parent pointers when possible to report
- [PATCH 12/24] xfs_scrub: use parent pointers to report lost file data
- [PATCH 13/24] xfs_db: report parent pointers in version command R [PATCH 14/24] xfs_db: report parent bit on xattrs
- [PATCH 15/24] xfs_db: report parent pointers embedded in xattrs
- [PATCH 16/24] xfs_db: obfuscate dirent and parent pointer names
- [PATCH 17/24] libxfs: export attr3_leaf_hdr_from_disk via
- [PATCH 18/24] xfs_db: add a parents command to list the parents of a
- [PATCH 19/24] xfs_db: make attr_set and attr_remove handle parent
- [PATCH 20/24] xfs_db: add link and unlink expert commands
- [PATCH 21/24] xfs_db: compute hashes of parent pointers
- [PATCH 22/24] libxfs: create new files with attr forks if necessary R [PATCH 23/24] mkfs: Add parent pointers during protofile creation R [PATCH 24/24] mkfs: enable formatting with parent pointers [PATCHSET v13.7 12/16] xfsprogs: scrubbing for parent pointers
- [PATCH 1/2] xfs: create a blob array data structure
- [PATCH 2/2] man2: update ioctl_xfs_scrub_metadata.2 for parent [PATCHSET v13.7 13/16] xfsprogs: offline repair for parent pointers
- [PATCH 01/12] xfs_db: remove some boilerplate from xfs_attr_set
- [PATCH 02/12] xfs_db: actually report errors from libxfs_attr_set
- [PATCH 03/12] xfs_repair: junk parent pointer attributes when
- [PATCH 04/12] xfs_repair: add parent pointers when messing with
- [PATCH 05/12] xfs_repair: junk duplicate hashtab entries when
- [PATCH 06/12] xfs_repair: build a parent pointer index
- [PATCH 07/12] xfs_repair: move the global dirent name store to a
- [PATCH 08/12] xfs_repair: deduplicate strings stored in string blob
- [PATCH 09/12] xfs_repair: check parent pointers
- [PATCH 10/12] xfs_repair: dump garbage parent pointer attributes
- [PATCH 11/12] xfs_repair: update ondisk parent pointer records
- [PATCH 12/12] xfs_repair: wipe ondisk parent pointers when there are [PATCHSET v13.7 14/16] xfsprogs: detect and correct directory tree
- [PATCH 1/5] libfrog: add directory tree structure scrubber to scrub
- [PATCH 2/5] xfs_spaceman: report directory tree corruption in the
- [PATCH 3/5] xfs_scrub: fix erroring out of check_inode_names
- [PATCH 4/5] xfs_scrub: detect and repair directory tree corruptions
- [PATCH 5/5] xfs_scrub: defer phase5 file scans if dirloop fails [PATCHSET v30.7 15/16] xfs_scrub: vectorize kernel calls
- [PATCH 01/10] man: document vectored scrub mode
- [PATCH 02/10] libfrog: support vectored scrub
- [PATCH 03/10] xfs_io: support vectored scrub
- [PATCH 04/10] xfs_scrub: split the scrub epilogue code into a
- [PATCH 05/10] xfs_scrub: split the repair epilogue code into a
- [PATCH 06/10] xfs_scrub: convert scrub and repair epilogues to use
- [PATCH 07/10] xfs_scrub: vectorize scrub calls
- [PATCH 08/10] xfs_scrub: vectorize repair calls
- [PATCH 09/10] xfs_scrub: use scrub barriers to reduce kernel calls
- [PATCH 10/10] xfs_scrub: try spot repairs of metadata items to make [PATCHSET v30.7 16/16] xfs_repair: small remote symlinks are ok
- [PATCH 1/1] xfs_repair: allow symlinks with short remote targets
--D
PATCH 1/16 xfsprogs: atomic file updates
Hi all,
This series creates a new XFS_IOC_EXCHANGE_RANGE ioctl to exchange ranges of bytes between two files atomically.
This new functionality enables data storage programs to stage and commit file updates such that reader programs will see either the old contents or the new contents in their entirety, with no chance of torn writes. A successful call completion guarantees that the new contents will be seen even if the system fails.
The ability to exchange file fork mappings between files in this manner is critical to supporting online filesystem repair, which is built upon the strategy of constructing a clean copy of a damaged structure and committing the new structure into the metadata file atomically. The ioctls exist to facilitate testing of the new functionality and to enable future application program designs.
User programs will be able to update files atomically by opening an O_TMPFILE, reflinking the source file to it, making whatever updates they want to make, and exchange the relevant ranges of the temp file with the original file. If the updates are aligned with the file block size, a new (since v2) flag provides for exchanging only the written areas. Note that application software must quiesce writes to the file while it stages an atomic update. This will be addressed by a subsequent series.
This mechanism solves the clunkiness of two existing atomic file update
mechanisms: for O_TRUNC + rewrite, this eliminates the brief period where other programs can see an empty file. For create tempfile + rename, the need to copy file attributes and extended attributes for each file update is eliminated.
However, this method introduces its own awkwardness -- any program initiating an exchange now needs to have a way to signal to other programs that the file contents have changed. For file access mediated via read and write, fanotify or inotify are probably sufficient. For mmaped files, that may not be fast enough.
The reference implementation in XFS creates a new log incompat feature and log intent items to track high level progress of swapping ranges of two files and finish interrupted work if the system goes down. Sample code can be found in the corresponding changes to xfs_io to exercise the use case mentioned above.
Note that this function is /not/ the O_DIRECT atomic untorn file writes concept that has also been floating around for years. It is also not the RWF_ATOMIC patchset that has been shared. This RFC is constructed entirely in software, which means that there are no limitations other than the general filesystem limits.
As a side note, the original motivation behind the kernel functionality is online repair of file-based metadata. The atomic file content exchange is implemented as an atomic exchange of file fork mappings, which means that we can implement online reconstruction of extended attributes and directories by building a new one in another inode and exchanging the contents.
Subsequent patchsets adapt the online filesystem repair code to use atomic file exchanges. This enables repair functions to construct a clean copy of a directory, xattr information, symbolic links, realtime bitmaps, and realtime summary information in a temporary inode. If this completes successfully, the new contents can be committed atomically into the inode being repaired. This is essential to avoid making corruption problems worse if the system goes down in the middle of running repair.
For userspace, this series also includes the userspace pieces needed to test the new functionality, and a sample implementation of atomic file updates.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=atomic-file-updates
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=atomic-file-updates
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=atomic-file-updates
xfsdocs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-documentation.git/log/?h=atomic-file-updates
---
Commits in this patchset:
* man: document the exchange-range ioctl
* man: document XFS_FSOP_GEOM_FLAGS_EXCHRANGE
* libhandle: add support for bulkstat v5
* libfrog: add support for exchange range ioctl family
* xfs_db: advertise exchange-range in the version command
* xfs_logprint: support dumping exchmaps log items
* xfs_fsr: convert to bulkstat v5 ioctls
* xfs_fsr: skip the xattr/forkoff levering with the newer swapext implementations
* xfs_io: create exchangerange command to test file range exchange ioctl
* libfrog: advertise exchange-range support
* xfs_repair: add exchange-range to file systems
* mkfs: add a formatting option for exchange-range
--- db/sb.c | 2 fsr/xfs_fsr.c | 162 ++++++++++++-------- include/jdm.h | 24 +++ io/Makefile | 48 +++++- io/exchrange.c | 156 ++++++++++++++++++++ io/init.c | 1 io/io.h | 1 libfrog/Makefile | 2 libfrog/file_exchange.c | 52 +++++++ libfrog/file_exchange.h | 15 ++ libfrog/fsgeom.c | 49 +++++- libfrog/fsgeom.h | 1 libhandle/jdm.c | 117 +++++++++++++++ logprint/log_misc.c | 11 + logprint/log_print_all.c | 12 ++ logprint/log_redo.c | 128 ++++++++++++++++ logprint/logprint.h | 6 + man/man2/ioctl_xfs_exchange_range.2 | 278 +++++++++++++++++++++++++++++++++++ man/man2/ioctl_xfs_fsgeometry.2 | 3 man/man8/mkfs.xfs.8.in | 7 + man/man8/xfs_admin.8 | 7 + man/man8/xfs_io.8 | 40 +++++ mkfs/lts_4.19.conf | 1 mkfs/lts_5.10.conf | 1 mkfs/lts_5.15.conf | 1 mkfs/lts_5.4.conf | 1 mkfs/lts_6.1.conf | 1 mkfs/lts_6.6.conf | 1 mkfs/xfs_mkfs.c | 26 +++ repair/globals.c | 1 repair/globals.h | 1 repair/phase2.c | 30 ++++ repair/xfs_repair.c | 11 + 33 files changed, 1111 insertions(+), 86 deletions(-) create mode 100644 io/exchrange.c create mode 100644 libfrog/file_exchange.c create mode 100644 libfrog/file_exchange.h create mode 100644 man/man2/ioctl_xfs_exchange_range.2
PATCH 1/12 man: document the exchange-range ioctl
From: Darrick J. Wong <[email protected]>
Document the new file data exchange ioctl.
--- man/man2/ioctl_xfs_exchange_range.2 | 278 +++++++++++++++++++++++++++++++++++ 1 file changed, 278 insertions(+) create mode 100644 man/man2/ioctl_xfs_exchange_range.2
man/man2/ioctl_xfs_exchange_range.2 new file +278 -0
@@ -0,0 +1,278 @@ +.\" Copyright (c) 2020-2024 Oracle. All rights reserved. +.\" +.\" %%%LICENSE_START(GPLv2+_DOC_FULL) +.\" This is free documentation; you can redistribute it and/or +.\" modify it under the terms of the GNU General Public License as +.\" published by the Free Software Foundation; either version 2 of +.\" the License, or (at your option) any later version. +.\" +.\" The GNU General Public License's references to "object code" +.\" and "executables" are to be interpreted as the output of any +.\" document formatting or typesetting system, including +.\" intermediate and printed output. +.\" +.\" This manual is distributed in the hope that it will be useful, +.\" but WITHOUT ANY WARRANTY; without even the implied warranty of +.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +.\" GNU General Public License for more details. +.\" +.\" You should have received a copy of the GNU General Public +.\" License along with this manual; if not, see +.\" <http://www.gnu.org/licenses/>. +.\" %%%LICENSE_END +.TH IOCTL-XFS-EXCHANGE-RANGE 2 2024-02-10 "XFS" +.SH NAME +ioctl_xfs_exchange_range \- exchange the contents of parts of two files +.SH SYNOPSIS +.br +.B #include <sys/ioctl.h> +.br +.B #include <xfs/xfs_fs.h> +.PP +.BI "int ioctl(int " file2_fd ", XFS_IOC_EXCHANGE_RANGE, struct xfs_exchange_range *" arg ); +.SH DESCRIPTION +Given a range of bytes in a first file +.B file1_fd +and a second range of bytes in a second file +.BR file2_fd , +this +.BR ioctl (2) +exchanges the contents of the two ranges. +.PP +Exchanges are atomic with regards to concurrent file operations. +Implementations must guarantee that readers see either the old contents or the +new contents in their entirety, even if the system fails. +.PP +The system call parameters are conveyed in structures of the following form: +.PP +.in +4n +.EX +struct xfs_exchange_range { + __s32 file1_fd; + __u32 pad; + __u64 file1_offset; + __u64 file2_offset; + __u64 length; + __u64 flags; +}; +.EE +.in +.PP +The field +.I pad +must be zero. +.PP +The fields +.IR file1_fd ", " file1_offset ", and " length +define the first range of bytes to be exchanged. +.PP +The fields +.IR file2_fd ", " file2_offset ", and " length +define the second range of bytes to be exchanged. +.PP +Both files must be from the same filesystem mount. +If the two file descriptors represent the same file, the byte ranges must not +overlap. +Most disk-based filesystems require that the starts of both ranges must be +aligned to the file block size. +If this is the case, the ends of the ranges must also be so aligned unless the +.B XFS_EXCHANGE_RANGE_TO_EOF +flag is set. + +.PP +The field +.I flags +control the behavior of the exchange operation. +.RS 0.4i +.TP +.B XFS_EXCHANGE_RANGE_TO_EOF +Ignore the +.I length +parameter. +All bytes in +.I file1_fd +from +.I file1_offset +to EOF are moved to +.IR file2_fd , +and file2's size is set to +.RI ( file2_offset "+(" file1_length - file1_offset )). +Meanwhile, all bytes in file2 from +.I file2_offset +to EOF are moved to file1 and file1's size is set to +.RI ( file1_offset "+(" file2_length - file2_offset )). +.TP +.B XFS_EXCHANGE_RANGE_DSYNC +Ensure that all modified in-core data in both file ranges and all metadata +updates pertaining to the exchange operation are flushed to persistent storage +before the call returns. +Opening either file descriptor with +.BR O_SYNC " or " O_DSYNC +will have the same effect. +.TP +.B XFS_EXCHANGE_RANGE_FILE1_WRITTEN +Only exchange sub-ranges of +.I file1_fd +that are known to contain data written by application software. +Each sub-range may be expanded (both upwards and downwards) to align with the +file allocation unit. +For files on the data device, this is one filesystem block. +For files on the realtime device, this is the realtime extent size. +This facility can be used to implement fast atomic scatter-gather writes of any +complexity for software-defined storage targets if all writes are aligned to +the file allocation unit. +.TP +.B XFS_EXCHANGE_RANGE_DRY_RUN +Check the parameters and the feasibility of the operation, but do not change +anything. +.RE +.PP +.SH RETURN VALUE +On error, \-1 is returned, and +.I errno +is set to indicate the error. +.PP +.SH ERRORS +Error codes can be one of, but are not limited to, the following: +.TP +.B EBADF +.IR file1_fd +is not open for reading and writing or is open for append-only writes; or +.IR file2_fd +is not open for reading and writing or is open for append-only writes. +.TP +.B EINVAL +The parameters are not correct for these files. +This error can also appear if either file descriptor represents +a device, FIFO, or socket. +Disk filesystems generally require the offset and length arguments +to be aligned to the fundamental block sizes of both files. +.TP +.B EIO +An I/O error occurred. +.TP +.B EISDIR +One of the files is a directory. +.TP +.B ENOMEM +The kernel was unable to allocate sufficient memory to perform the +operation. +.TP +.B ENOSPC +There is not enough free space in the filesystem exchange the contents safely. +.TP +.B EOPNOTSUPP +The filesystem does not support exchanging bytes between the two +files. +.TP +.B EPERM +.IR file1_fd " or " file2_fd +are immutable. +.TP +.B ETXTBSY +One of the files is a swap file. +.TP +.B EUCLEAN +The filesystem is corrupt. +.TP +.B EXDEV +.IR file1_fd " and " file2_fd +are not on the same mounted filesystem. +.SH CONFORMING TO +This API is XFS-specific. +.SH USE CASES +.PP +Several use cases are imagined for this system call. +In all cases, application software must coordinate updates to the file +because the exchange is performed unconditionally. +.PP +The first is a data storage program that wants to commit non-contiguous updates +to a file atomically and coordinates write access to that file. +This can be done by creating a temporary file, calling +.BR FICLONE (2) +to share the contents, and staging the updates into the temporary file. +The +.B FULL_FILES +flag is recommended for this purpose. +The temporary file can be deleted or punched out afterwards. +.PP +An example program might look like this: +.PP +.in +4n +.EX +int fd = open("/some/file", O_RDWR); +int temp_fd = open("/some", O_TMPFILE | O_RDWR); + +ioctl(temp_fd, FICLONE, fd); + +/* append 1MB of records */ +lseek(temp_fd, 0, SEEK_END); +write(temp_fd, data1, 1000000); + +/* update record index */ +pwrite(temp_fd, data1, 600, 98765); +pwrite(temp_fd, data2, 320, 54321); +pwrite(temp_fd, data2, 15, 0); + +/* commit the entire update */ +struct xfs_exchange_range args = { + .file1_fd = temp_fd, + .flags = XFS_EXCHANGE_RANGE_TO_EOF, +}; + +ioctl(fd, XFS_IOC_EXCHANGE_RANGE, &args); +.EE +.in +.PP +The second is a software-defined storage host (e.g. a disk jukebox) which +implements an atomic scatter-gather write command. +Provided the exported disk's logical block size matches the file's allocation +unit size, this can be done by creating a temporary file and writing the data +at the appropriate offsets. +It is recommended that the temporary file be truncated to the size of the +regular file before any writes are staged to the temporary file to avoid issues +with zeroing during EOF extension. +Use this call with the +.B FILE1_WRITTEN +flag to exchange only the file allocation units involved in the emulated +device's write command. +The temporary file should be truncated or punched out completely before being +reused to stage another write. +.PP +An example program might look like this: +.PP +.in +4n +.EX +int fd = open("/some/file", O_RDWR); +int temp_fd = open("/some", O_TMPFILE | O_RDWR); +struct stat sb; +int blksz; + +fstat(fd, &sb); +blksz = sb.st_blksize; + +/* land scatter gather writes between 100fsb and 500fsb */ +pwrite(temp_fd, data1, blksz * 2, blksz * 100); +pwrite(temp_fd, data2, blksz * 20, blksz * 480); +pwrite(temp_fd, data3, blksz * 7, blksz * 257); + +/* commit the entire update */ +struct xfs_exchange_range args = { + .file1_fd = temp_fd, + .file1_offset = blksz * 100, + .file2_offset = blksz * 100, + .length = blksz * 400, + .flags = XFS_EXCHANGE_RANGE_FILE1_WRITTEN | + XFS_EXCHANGE_RANGE_FILE1_DSYNC, +}; + +ioctl(fd, XFS_IOC_EXCHANGE_RANGE, &args); +.EE +.in +.B +.SH NOTES +.PP +Some filesystems may limit the amount of data or the number of extents that can +be exchanged in a single call. +.SH SEE ALSO +.BR ioctl (2)
Re: [PATCH 01/12] man: document the exchange-range ioctl
Looks good:
PATCH 2/12 man: document XFS_FSOP_GEOM_FLAGS_EXCHRANGE
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Document this new feature flag in the fs geometry ioctl.
--- man/man2/ioctl_xfs_fsgeometry.2 | 3 +++ 1 file changed, 3 insertions(+)
man/man2/ioctl_xfs_fsgeometry.2 +3 -0
@@ -211,6 +211,9 @@ Filesystem stores reverse mappings of blocks to owners. .TP .B XFS_FSOP_GEOM_FLAGS_REFLINK Filesystem supports sharing blocks between files. +.TP +.B XFS_FSOP_GEOM_FLAGS_EXCHRANGE +Filesystem can exchange file contents atomically via XFS_IOC_EXCHANGE_RANGE. .RE .SH XFS METADATA HEALTH REPORTING .PP
Re: [PATCH 02/12] man: document XFS_FSOP_GEOM_FLAGS_EXCHRANGE
Looks good:
PATCH 3/12 libhandle: add support for bulkstat v5
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add support to libhandle for generating file handles with bulkstat v5 structures. xfs_fsr will need this to be able to interface with the new vfs range swap ioctl, and other client programs will probably want this over time.
--- include/jdm.h | 24 +++++++++++ libhandle/jdm.c | 117 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 141 insertions(+)
include/jdm.h +24 -0
@@ -11,6 +11,7 @@ typedef void jdm_fshandle_t; /* filesystem handle */typedef void jdm_filehandle_t ;/* filehandle */ struct xfs_bstat ; +struct xfs_bulkstat ;struct attrlist_cursor ;struct parent ;
@@ -23,6 +24,9 @@ jdm_new_filehandle( jdm_filehandle_t **handlep, /* new filehandle */jdm_fshandle_t *fshandlep,/* filesystem filehandle */ struct xfs_bstat *sp); /* bulkstat info */ +extern void jdm_new_filehandle_v5 (jdm_filehandle_t **handlep,size_t *hlen, +jdm_fshandle_t *fshandlep,struct xfs_bulkstat *sp); +extern void jdm_delete_filehandle (jdm_filehandle_t *handlep,/* filehandle to delete */ size_t hlen);/* filehandle size */
@@ -32,35 +36,55 @@ jdm_open( jdm_fshandle_t *fshandlep,struct xfs_bstat *sp, intgen_t oflags); +extern intgen_t jdm_open_v5 (jdm_fshandle_t *fshandlep,struct xfs_bulkstat *sp, +intgen_t oflags); +extern intgen_t jdm_readlink (jdm_fshandle_t *fshandlep,struct xfs_bstat *sp,char *bufp,size_t bufsz); +extern intgen_t jdm_readlink_v5 (jdm_fshandle_t *fshandlep, +struct xfs_bulkstat *sp,char *bufp,size_t bufsz); +extern intgen_t jdm_attr_multi (jdm_fshandle_t *fshp,struct xfs_bstat *statp,char *bufp,int rtrvcnt,int flags); +extern intgen_t jdm_attr_multi_v5 (jdm_fshandle_t *fshp, +struct xfs_bulkstat *statp,char *bufp,int rtrvcnt, +int flags); +extern intgen_t jdm_attr_list (jdm_fshandle_t *fshp,struct xfs_bstat *statp,char *bufp,size_t bufsz,int flags,struct attrlist_cursor *cursor); +extern intgen_t jdm_attr_list_v5 (jdm_fshandle_t *fshp, +struct xfs_bulkstat *statp,char *bufp,size_t bufsz,int + flags,struct attrlist_cursor *cursor); +extern int jdm_parents (jdm_fshandle_t *fshp,struct xfs_bstat *statp,struct parent *bufp,size_t bufsz,unsigned int *count); +extern int jdm_parents_v5 (jdm_fshandle_t *fshp,struct xfs_bulkstat *statp, +struct parent *bufp,size_t bufsz,unsigned int *count); +extern int jdm_parentpaths (jdm_fshandle_t *fshp,struct xfs_bstat *statp,struct parent *bufp,size_t bufsz,unsigned int *count); +extern int jdm_parentpaths_v5 (jdm_fshandle_t *fshp,struct xfs_bulkstat *statp, +struct parent *bufp,size_t bufsz,unsigned int *count); +/* macro for determining the size of a structure member */ #define sizeofmember ( t, m ) sizeof( ( ( t * )0 )->m )
libhandle/jdm.c +117 -0
162 lines not on this page · raw message
Re: [PATCH 03/12] libhandle: add support for bulkstat v5
include/jdm.h jdm_new_filehandle( jdm_filehandle_t **handlep, /* new filehandle */ · line 28
Quoted 2 lines
include/jdm.h +2
-0+extern void jdm_new_filehandle_v5 (jdm_filehandle_t **handlep,size_t *hlen, +jdm_fshandle_t *fshandlep,struct xfs_bulkstat *sp);
No need for the extern here. Same for the others below.
Otherwise looks good:
Re: [PATCH 03/12] libhandle: add support for bulkstat v5
Quoted 4 lines · Christoph Hellwig
include/jdm.h jdm_new_filehandle( jdm_filehandle_t **handlep, /* new filehandle */ · line 28
Quoted 2 lines
include/jdm.h +2
-0+extern void jdm_new_filehandle_v5 (jdm_filehandle_t **handlep,size_t *hlen, +jdm_fshandle_t *fshandlep,struct xfs_bulkstat *sp);No need for the extern here. Same for the others below.
Ok, will remove.
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 4/12 libfrog: add support for exchange range ioctl family
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add some library code to support the new file range exchange and commit ioctls.
--- libfrog/Makefile | 2 ++ libfrog/file_exchange.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++ libfrog/file_exchange.h | 15 ++++++++++++++ 3 files changed, 69 insertions(+) create mode 100644 libfrog/file_exchange.c create mode 100644 libfrog/file_exchange.h
libfrog/Makefile +2 -0
@@ -18,6 +18,7 @@ bitmap.c \ bulkstat.c \ convert.c \ crc32.c \ +file_exchange.c \ fsgeom.c \ list_sort.c \ linux.c \
@@ -42,6 +43,7 @@ crc32defs.h \ crc32table.h \ dahashselftest.h \ div64.h \ +file_exchange.h \ fsgeom.h \ logging.h \ paths.h \
libfrog/file_exchange.c new file +52 -0
52 lines not on this page · raw message
libfrog/file_exchange.h new file +15 -0
@@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* +* Copyright (c) 2020-2024 Oracle. All rights reserved. +* All Rights Reserved. +*/ +#ifndef __LIBFROG_FILE_EXCHANGE_H__ +#define __LIBFROG_FILE_EXCHANGE_H__ + +void xfrog_exchangerange_prep (struct xfs_exchange_range *fxr, +off_t file2_offset,int file1_fd, +off_t file1_offset,uint64_t length); +int xfrog_exchangerange (int file2_fd,struct xfs_exchange_range *fxr, +uint64_t flags); + +#endif /* __LIBFROG_FILE_EXCHANGE_H__ */
Re: [PATCH 04/12] libfrog: add support for exchange range ioctl family
Looks good:
PATCH 5/12 xfs_db: advertise exchange-range in the version command
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Amend the version command to advertise exchange-range support.
--- db/sb.c | 2 ++ 1 file changed, 2 insertions(+)
db/sb.c +2 -0
@@ -706,6 +706,8 @@ version_string(strcat (s,",NEEDSREPAIR" );if (xfs_has_large_extent_counts (mp))strcat (s,",NREXT64" ); +if (xfs_has_exchange_range (mp)) +strcat (s,",EXCHANGE" );return s; }
Re: [PATCH 05/12] xfs_db: advertise exchange-range in the version command
Looks good:
PATCH 6/12 xfs_logprint: support dumping exchmaps log items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Support dumping exchmaps log items.
--- logprint/log_misc.c | 11 ++++ logprint/log_print_all.c | 12 ++++ logprint/log_redo.c | 128 ++++++++++++++++++++++++++++++++++++++++++++++ logprint/logprint.h | 6 ++ 4 files changed, 157 insertions(+)
logprint/log_misc.c +11 -0
@@ -1052,6 +1052,17 @@ xlog_print_record( be32_to_cpu(op_head->oh_len));break ; } +case XFS_LI_XMI : { + skip =xlog_print_trans_xmi (&ptr, +be32_to_cpu (op_head->oh_len), + continued); +break ; + } +case XFS_LI_XMD : { + skip =xlog_print_trans_xmd (&ptr, +be32_to_cpu (op_head->oh_len)); +break ; + }case XFS_LI_QUOTAOFF : { skip =xlog_print_trans_qoff (&ptr,be32_to_cpu (op_head->oh_len));
logprint/log_print_all.c +12 -0
@@ -440,6 +440,12 @@ xlog_recover_print_logitem(case XFS_LI_BUI :xlog_recover_print_bui (item);break ; +case XFS_LI_XMD : +xlog_recover_print_xmd (item); +break ; +case XFS_LI_XMI : +xlog_recover_print_xmi (item); +break ;case XFS_LI_DQUOT :xlog_recover_print_dquot (item);break ;
@@ -498,6 +504,12 @@ xlog_recover_print_item(case XFS_LI_BUI :printf ("BUI" );break ; +case XFS_LI_XMD : +printf ("XMD" ); +break ; +case XFS_LI_XMI : +printf ("XMI" ); +break ;case XFS_LI_DQUOT :printf ("DQ " );break ;
logprint/log_redo.c +128 -0
131 lines not on this page · raw message
logprint/logprint.h +6 -0
@@ -65,4 +65,10 @@ extern void xlog_recover_print_attri(struct xlog_recover_item *item);extern int xlog_print_trans_attrd (char **ptr,uint len);extern void xlog_recover_print_attrd (struct xlog_recover_item *item);extern void xlog_print_op_header (xlog_op_header_t *op_head,int i,char **ptr); + +extern int xlog_print_trans_xmi (char **ptr,uint src_len,int continued); +extern void xlog_recover_print_xmi (struct xlog_recover_item *item); +extern int xlog_print_trans_xmd (char **ptr,uint len); +extern void xlog_recover_print_xmd (struct xlog_recover_item *item); +#endif /* LOGPRINT_H */
Re: [PATCH 06/12] xfs_logprint: support dumping exchmaps log items
logprint/logprint.h extern void xlog_recover_print_attri(struct xlog_recover_item *item); · line 72
Quoted 4 lines
logprint/logprint.h +4
-0+extern int xlog_print_trans_xmi (char **ptr,uint src_len,int continued); +extern void xlog_recover_print_xmi (struct xlog_recover_item *item); +extern int xlog_print_trans_xmd (char **ptr,uint len); +extern void xlog_recover_print_xmd (struct xlog_recover_item *item);
Drop the pointless externs here.
Otherwise looks good:
Re: [PATCH 06/12] xfs_logprint: support dumping exchmaps log items
Quoted 6 lines · Christoph Hellwig
logprint/logprint.h extern void xlog_recover_print_attri(struct xlog_recover_item *item); · line 72
Quoted 4 lines
logprint/logprint.h +4
-0+extern int xlog_print_trans_xmi (char **ptr,uint src_len,int continued); +extern void xlog_recover_print_xmi (struct xlog_recover_item *item); +extern int xlog_print_trans_xmd (char **ptr,uint len); +extern void xlog_recover_print_xmd (struct xlog_recover_item *item);Drop the pointless externs here.
Done.
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 7/12 xfs_fsr: convert to bulkstat v5 ioctls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that libhandle can, er, handle bulkstat information coming from the v5 bulkstat ioctl, port xfs_fsr to use the new interfaces instead of repeatedly converting things back and forth.
--- fsr/xfs_fsr.c | 148 ++++++++++++++++++++++++++++++------------------------ libfrog/fsgeom.c | 45 ++++++++++++---- libfrog/fsgeom.h | 1 3 files changed, 117 insertions(+), 77 deletions(-)
fsr/xfs_fsr.c +83 -65
@@ -65,10 +65,10 @@ static int pagesize;void usage (int ret);static int fsrfile (char *fname,xfs_ino_t ino); -static int fsrfile_common (char *fname,char *tname,char *mnt, -int fd,struct xfs_bstat *statp); -static int packfile (char *fname,char *tname,int fd, -struct xfs_bstat *statp,struct fsxattr *fsxp); +static int fsrfile_common (char *fname,char *tname,char *mnt, +struct xfs_fd *file_fd,struct xfs_bulkstat *statp); +static int packfile (char *fname,char *tname,struct xfs_fd *file_fd, +struct xfs_bulkstat *statp,struct fsxattr *fsxp);static void fsrdir (char *dirname);static int fsrfs (char *mntdir,xfs_ino_t ino,int targetrange);static void initallfs (char *mtab);
@@ -80,7 +80,7 @@ int xfs_getrt(int fd, struct statvfs *sfbp);char *gettmpname (char *fname);char *getparent (char *fname);int fsrprintf (const char *fmt, ...); -int read_fd_bmap (int ,struct xfs_bstat *,int *); +int read_fd_bmap (int ,struct xfs_bulkstat *,int *);static void tmp_init (char *mnt);static char *tmp_next (char *mnt);static void tmp_close (char *mnt);
@@ -102,6 +102,26 @@ static int nfrags = 0; /* Debug option: Coerse into specific number* of extents */ static int openopts =O_CREAT |O_EXCL |O_RDWR |O_DIRECT ; +/* +* Open a file on an XFS filesystem from file handle components and fs geometry +* data. Returns zero or a negative error code. +*/ +static int +open_handle ( +struct xfs_fd *xfd, +jdm_fshandle_t *fshandle, +struct xfs_bulkstat *bulkstat, +struct xfs_fsop_geom *fsgeom, +int flags) +{ + xfd->fd =jdm_open_v5 (fshandle, bulkstat, flags); +if (xfd->fd <0 ) +return errno; + +xfd_install_geometry (xfd, fsgeom); +return 0 ; +} +static int xfs_swapext (int fd,xfs_swapext_t *sx) {
@@ -627,7 +647,6 @@ static int fsrfs(char *mntdir, xfs_ino_t startino, int targetrange) {struct xfs_fd fsxfd =XFS_FD_INIT_EMPTY ; -int fd;int count =0 ;int ret;char fname[64 ];
@@ -665,10 +684,10 @@ fsrfs(char *mntdir, xfs_ino_t startino, int targetrange) }while ((ret = -xfrog_bulkstat (&fsxfd, breq) ==0 )) { -struct xfs_bstat bs1;struct xfs_bulkstat *buf = breq->bulkstat;struct xfs_bulkstat *p;struct xfs_bulkstat *endp; +struct xfs_fd file_fd =XFS_FD_INIT_EMPTY ;uint32_t buflenout = breq->hdr.ocount;if (buflenout ==0 )
@@ -685,15 +704,9 @@ fsrfs(char *mntdir, xfs_ino_t startino, int targetrange) (p->bs_extents64 < 2))continue ; - ret = -xfrog_bulkstat_v5_to_v1 (&fsxfd, &bs1, p); + ret =open_handle (&file_fd, fshandlep, p, + &fsxfd.fsgeom,O_RDWR |O_DIRECT );if (ret) { -fsrprintf (_ ("bstat conversion error: %s\n" ), -strerror (ret)); -continue ; - } - - fd =jdm_open (fshandlep, &bs1,O_RDWR |O_DIRECT ); -if (fd <0 ) {/* This probably means the file was * removed while in progress of handling * it. Just quietly ignore this file.
@@ -710,11 +723,12 @@ fsrfs(char *mntdir, xfs_ino_t startino, int targetrange)/* Get a tmp file name */ tname =tmp_next (mntdir); - ret =fsrfile_common (fname, tname, mntdir, fd, &bs1); + ret =fsrfile_common (fname, tname, mntdir, &file_fd, + p); leftoffino = p->bs_ino; -close (fd); +xfd_close (&file_fd);if (ret ==0 ) {if (--count <=0 )
@@ -762,9 +776,8 @@ fsrfile( {struct xfs_fd fsxfd =XFS_FD_INIT_EMPTY ;struct xfs_bulkstat bulkstat; -struct xfs_bstat statbuf; +struct xfs_fd file_fd =XFS_FD_INIT_EMPTY ;jdm_fshandle_t *fshandlep; -int fd =-1 ;int error =-1 ;char *tname;
@@ -792,17 +805,12 @@ fsrfile( fname, strerror(error)); goto out; } - error = -xfrog_bulkstat_v5_to_v1 (&fsxfd, &statbuf, &bulkstat); -if (error) { -fsrprintf (_ ("bstat conversion error on %s: %s\n" ), - fname,strerror (error)); - goto out; - } - fd =jdm_open (fshandlep, &statbuf,O_RDWR |O_DIRECT ); -if (fd <0 ) { + error =open_handle (&file_fd, fshandlep, &bulkstat, &fsxfd.fsgeom, +O_RDWR |O_DIRECT ); +if (error) {fsrprintf (_ ("unable to open handle %s: %s\n" ), - fname,strerror (errno)); + fname,strerror (error)); goto out; }
@@ -810,14 +818,13 @@ fsrfile(memcpy (&fsgeom, &fsxfd.fsgeom,sizeof (fsgeom)); tname =gettmpname (fname); -if (tname) - error =fsrfile_common (fname, tname,NULL , fd, &statbuf); + error =fsrfile_common (fname, tname,NULL , &file_fd, + &bulkstat); out:xfd_close (&fsxfd); -if (fd >=0 ) -close (fd); +xfd_close (&file_fd);free (fshandlep);return error;
@@ -843,8 +850,8 @@ fsrfile_common(char *fname, char *tname, char *fsname, - int fd, - struct xfs_bstat *statp) + struct xfs_fd *file_fd, + struct xfs_bulkstat *statp) { int error;struct statvfs vfss;
@@ -854,7 +861,7 @@ fsrfile_common(if (vflag)fsrprintf ("%s\n" , fname); -if (fsync (fd) <0 ) { +if (fsync (file_fd->fd) <0 ) {fsrprintf (_ ("sync failed: %s: %s\n" ), fname,strerror (errno));return -1 ; }
@@ -878,7 +885,7 @@ fsrfile_common( fl.l_whence =SEEK_SET ; fl.l_start = (off_t )0 ; fl.l_len =0 ; -if ((fcntl (fd,F_GETLK , &fl)) <0 ) { +if ((fcntl (file_fd->fd,F_GETLK , &fl)) <0 ) {if (vflag)fsrprintf (_ ("locking check failed: %s\n" ), fname);
@@ -896,7 +903,7 @@ fsrfile_common(/* * Check if there is room to copy the file. * -* Note that xfs_bstat.bs_blksize returns the filesystem blocksize, +* Note that xfs_bulkstat.bs_blksize returns the filesystem blocksize, * not the optimal I/O size as struct stat. */ if (statvfs (fsname ? fsname : fname, &vfss) <0 ) {
@@ -913,7 +920,7 @@ fsrfile_common(return 1 ; } -if ((ioctl (fd,FS_IOC_FSGETXATTR , &fsx)) <0 ) { +if ((ioctl (file_fd->fd,FS_IOC_FSGETXATTR , &fsx)) <0 ) {fsrprintf (_ ("failed to get inode attrs: %s\n" ), fname);return (-1 ); }
@@ -929,7 +936,7 @@ fsrfile_common(return (0 ); }if (fsx.fsx_xflags &FS_XFLAG_REALTIME ) { -if (xfs_getrt (fd, &vfss) <0 ) { +if (xfs_getrt (file_fd->fd, &vfss) <0 ) {fsrprintf (_ ("cannot get realtime geometry for: %s\n" ), fname);return (-1 );
@@ -955,7 +962,7 @@ fsrfile_common(* file we're defragging, in packfile(). */ -if ((error =packfile (fname, tname, fd, statp, &fsx))) +if ((error =packfile (fname, tname, file_fd, statp, &fsx)))return error;return -1 ;/* no error */ }
@@ -979,7 +986,7 @@ static intfsr_setup_attr_fork ( int fd, int tfd, - struct xfs_bstat *bstatp) + struct xfs_bulkstat *bstatp) { struct xfs_fd txfd = XFS_FD_INIT(tfd);struct stat tstatbuf;
@@ -1161,23 +1168,28 @@ fsr_setup_attr_fork(* 1: No change / No Error */ static int -packfile (char *fname,char *tname,int fd, -struct xfs_bstat *statp,struct fsxattr *fsxp) +packfile ( +char *fname, +char *tname, +struct xfs_fd *file_fd, +struct xfs_bulkstat *statp, +struct fsxattr *fsxp) { -int tfd =-1 ; -int srval; -int retval =-1 ;/* Failure is the default */ -int nextents, extent, cur_nextents, new_nextents; -unsigned blksz_dio; -unsigned dio_min; -struct dioattr dio; -static xfs_swapext_t sx; -struct xfs_flock64 space; -off_t cnt, pos; -void *fbuf =NULL ; -int ct, wc, wc_b4; -char ffname[SMBUFSZ ]; -int ffd =-1 ; +int tfd =-1 ; +int srval; +int retval =-1 ;/* Failure is the default */ +int nextents, extent, cur_nextents, new_nextents; +unsigned blksz_dio; +unsigned dio_min; +struct dioattr dio; +static xfs_swapext_t sx; +struct xfs_flock64 space; +off_t cnt, pos; +void *fbuf =NULL ; +int ct, wc, wc_b4; +char ffname[SMBUFSZ ]; +int ffd =-1 ; +int error;/* * Work out the extent map - nextents will be set to the
@@ -1185,7 +1197,7 @@ packfile(char *fname, char *tname, int fd,* into account holes), cur_nextents is the current number * of extents. */ - nextents =read_fd_bmap (fd, statp, &cur_nextents); + nextents =read_fd_bmap (file_fd->fd, statp, &cur_nextents);if (cur_nextents ==1 || cur_nextents <= nextents) {if (vflag)
@@ -1208,7 +1220,7 @@ packfile(char *fname, char *tname, int fd,unlink (tname);/* Setup extended attributes */ -if (fsr_setup_attr_fork (fd, tfd, statp) !=0 ) { +if (fsr_setup_attr_fork (file_fd->fd, tfd, statp) !=0 ) {fsrprintf (_ ("failed to set ATTR fork on tmp: %s:\n" ), tname); goto out; }
@@ -1326,7 +1338,7 @@ packfile(char *fname, char *tname, int fd, tname, strerror(errno)); goto out; } -if (lseek (fd, outmap[extent].bmv_length,SEEK_CUR ) <0 ) { +if (lseek (file_fd->fd, outmap[extent].bmv_length,SEEK_CUR ) <0 ) {fsrprintf (_ ("could not lseek in file: %s : %s\n" ), fname,strerror (errno)); goto out;
@@ -1346,7 +1358,7 @@ packfile(char *fname, char *tname, int fd, ct =min (cnt + dio_min - (cnt % dio_min), blksz_dio); } - ct =read (fd, fbuf, ct); + ct =read (file_fd->fd, fbuf, ct);if (ct ==0 ) {/* EOF, stop trying to read */ extent = nextents;
@@ -1417,9 +1429,15 @@ packfile(char *fname, char *tname, int fd, goto out; } - sx.sx_stat = *statp;/* struct copy */ + error = -xfrog_bulkstat_v5_to_v1 (file_fd, &sx.sx_stat, statp); +if (error) { +fsrprintf (_ ("bstat conversion error on %s: %s\n" ), + fname,strerror (error)); + goto out; + } + sx.sx_version =XFS_SX_VERSION ; - sx.sx_fdtarget = fd; + sx.sx_fdtarget = file_fd->fd; sx.sx_fdtmp = tfd; sx.sx_offset =0 ; sx.sx_length = statp->bs_size;
@@ -1433,7 +1451,7 @@ packfile(char *fname, char *tname, int fd, }/* Swap the extents */ - srval =xfs_swapext (fd, &sx); + srval =xfs_swapext (file_fd->fd, &sx);if (srval <0 ) {if (errno ==ENOTSUP ) {if (vflag || dflag)
@@ -1529,7 +1547,7 @@ getparent(char *fname)#define MAPSIZE 128#define OUTMAP_SIZE_INCREMENT MAPSIZE -int read_fd_bmap (int fd,struct xfs_bstat *sin,int *cur_nextents) +int read_fd_bmap (int fd,struct xfs_bulkstat *sin,int *cur_nextents) {int i, cnt;struct getbmap map[MAPSIZE ];
libfrog/fsgeom.c +33 -12
62 lines not on this page · raw message
libfrog/fsgeom.h +1 -0
@@ -55,6 +55,7 @@ struct xfs_fd {#define XFS_FD_INIT_EMPTY XFS_FD_INIT(-1)int xfd_prepare_geometry (struct xfs_fd *xfd); +void xfd_install_geometry (struct xfs_fd *xfd,struct xfs_fsop_geom *fsgeom);int xfd_open (struct xfs_fd *xfd,const char *pathname,int flags);int xfd_close (struct xfs_fd *xfd);
Re: [PATCH 07/12] xfs_fsr: convert to bulkstat v5 ioctls
fsr/xfs_fsr.c packfile(char *fname, char *tname, int fd, · line 1342
Quoted 2 lines
fsr/xfs_fsr.c +1
-0+if (lseek (file_fd->fd, outmap[extent].bmv_length,SEEK_CUR ) <0 ) { fsrprintf(_("could not lseek in file: %s : %s\n"),
Maybe avoid the overly long lines here?
fsr/xfs_fsr.c getparent(char *fname) · line 1550
Quoted 2 lines
fsr/xfs_fsr.c +1
-1-int read_fd_bmap (int fd,struct xfs_bstat *sin,int *cur_nextents) +int read_fd_bmap (int fd,struct xfs_bulkstat *sin,int *cur_nextents)
Maybe fix the weird formatting here while you're at it?
Otherwise looks good:
Re: [PATCH 07/12] xfs_fsr: convert to bulkstat v5 ioctls
Quoted 9 lines · Christoph Hellwig
fsr/xfs_fsr.c packfile(char *fname, char *tname, int fd, · line 1342
Quoted 2 lines
fsr/xfs_fsr.c +1
-0+if (lseek (file_fd->fd, outmap[extent].bmv_length,SEEK_CUR ) <0 ) { fsrprintf(_("could not lseek in file: %s : %s\n"),Maybe avoid the overly long lines here?
fsr/xfs_fsr.c getparent(char *fname) · line 1550
Quoted 2 lines
fsr/xfs_fsr.c +1
-1-int read_fd_bmap (int fd,struct xfs_bstat *sin,int *cur_nextents) +int read_fd_bmap (int fd,struct xfs_bulkstat *sin,int *cur_nextents)Maybe fix the weird formatting here while you're at it?
Both fixed.
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 8/12 xfs_fsr: skip the xattr/forkoff levering with the newer swapext implementations
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The newer swapext implementations in the kernel run at a high enough level (above the bmap layer) that it's no longer required to manipulate bs_forkoff by creating garbage xattrs to get the extent tree that we want. If we detect the newer algorithms, skip this error prone step.
--- fsr/xfs_fsr.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
fsr/xfs_fsr.c +14 -0
@@ -999,6 +999,20 @@ fsr_setup_attr_fork(if (!(bstatp->bs_xflags &FS_XFLAG_HASATTR ))return 0 ; +/* +* If the filesystem has the ability to perform atomic file mapping +* exchanges, the file extent swap implementation uses a higher level +* algorithm that calls into the bmap code instead of playing games +* with swapping the extent forks. +* +* This new functionality does not require specific values of +* bs_forkoff, unlike the old fork swap code. Leave the extended +* attributes alone if we know we're not using the old fork swap +* strategy. This eliminates a major source of runtime errors in fsr. +*/ +if (fsgeom.flags &XFS_FSOP_GEOM_FLAGS_EXCHANGE_RANGE ) +return 0 ; +/* * use the old method if we have attr1 or the kernel does not yet * support passing the fork offset in the bulkstat data.
Re: [PATCH 08/12] xfs_fsr: skip the xattr/forkoff levering with the newer swapext implementations
Looks good:
PATCH 9/12 xfs_io: create exchangerange command to test file range exchange ioctl
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new xfs_Io command to make raw calls to the XFS_IOC_EXCHANGE_RANGE ioctl.
--- io/Makefile | 48 ++++++++++++++-- io/exchrange.c | 156 +++++++++++++++++++++++++++++++++++++++++++++++++++++ io/init.c | 1 io/io.h | 1 man/man8/xfs_io.8 | 40 ++++++++++++++ 5 files changed, 239 insertions(+), 7 deletions(-) create mode 100644 io/exchrange.c
io/Makefile +41 -7
@@ -8,13 +8,47 @@ include $(TOPDIR)/include/builddefs LTCOMMAND = xfs_io LSRCFILES = xfs_bmap.sh xfs_freeze.sh xfs_mkfile.sh HFILES = init.h io.h -CFILES = init.c \ - attr.c bmap.c bulkstat.c crc32cselftest.c cowextsize.c encrypt.c \ - file.c freeze.c fsuuid.c fsync.c getrusage.c imap.c inject.c label.c \ - link.c mmap.c open.c parent.c pread.c prealloc.c pwrite.c reflink.c \ - resblks.c scrub.c seek.c shutdown.c stat.c swapext.c sync.c \ - truncate.c utimes.c fadvise.c sendfile.c madvise.c mincore.c fiemap.c \ - sync_file_range.c readdir.c +CFILES = \ + attr.c \ + bmap.c \ + bulkstat.c \ + cowextsize.c \ + crc32cselftest.c \ + encrypt.c \ + exchrange.c \ + fadvise.c \ + fiemap.c \ + file.c \ + freeze.c \ + fsuuid.c \ + fsync.c \ + getrusage.c \ + imap.c \ + init.c \ + inject.c \ + label.c \ + link.c \ + madvise.c \ + mincore.c \ + mmap.c \ + open.c \ + parent.c \ + pread.c \ + prealloc.c \ + pwrite.c \ + readdir.c \ + reflink.c \ + resblks.c \ + scrub.c \ + seek.c \ + sendfile.c \ + shutdown.c \ + stat.c \ + swapext.c \ + sync.c \ + sync_file_range.c \ + truncate.c \ + utimes.c LLDLIBS = $(LIBXCMD) $(LIBHANDLE) $(LIBFROG) $(LIBPTHREAD) $(LIBUUID) LTDEPENDENCIES = $(LIBXCMD) $(LIBHANDLE) $(LIBFROG)
io/exchrange.c new file +156 -0
156 lines not on this page · raw message
io/init.c +1 -0
@@ -88,6 +88,7 @@ init_commands(void)truncate_init ();utimes_init ();crc32cselftest_init (); +exchangerange_init (); }/*
io/io.h +1 -0
@@ -149,3 +149,4 @@ extern void scrub_init(void);extern void repair_init (void );extern void crc32cselftest_init (void );extern void bulkstat_init (void ); +extern void exchangerange_init (void );
man/man8/xfs_io.8 +40 -0
@@ -713,6 +713,46 @@ Swaps extent forks between files. The current open file is the target. The donor file is specified by path. Note that file data is not copied (file content moves with the fork(s)). .TP +.BI "exchangerange [OPTIONS]" donor_file " +Exchanges contents between files. +The current open file is the target. +The donor file is specified by path. +Note that file data is not copied (file content moves with the fork(s)). +Options include: +.RS 1.0i +.PD 0 +.TP 0.4i +.TP +.B \-C +Print timing information in a condensed format. +.TP +.BI \-d " dest_offset" +Swap extents with open file beginning at +.IR dest_offset . +.TP +.B \-f +Flush changed file data and file metadata to disk. +.TP +.BI \-l " length" +Swap up to +.I length +bytes of data. +.TP +.B \-n +Perform all the parameter validation checks but don't change anything. +.TP +.BI \-s " src_offset" +Swap extents with donor file beginning at +.IR src_offset . +.TP +.B \-t +Print timing information. +.TP +.B \-w +Only exchange written ranges in the supplied file. +.RE +.PD +.TP .BI "set_encpolicy [ \-c " mode " ] [ \-n " mode " ] [ \-f " flags " ] [ \-s " log2_dusize " ] [ \-v " version " ] [ " keyspec " ]" On filesystems that support encryption, assign an encryption policy to the current file.
Re: [PATCH 09/12] xfs_io: create exchangerange command to test file range exchange ioctl
Quoted 3 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new
xfs_Iocommand to make raw calls to the
s/xfs_Io/xfs_io/ ?
Quoted 1 line
+extern void
exchangerange_init(void);
No need for the extern.
Otherwise looks good:
Re: [PATCH 09/12] xfs_io: create exchangerange command to test file range exchange ioctl
Quoted 7 lines · Christoph Hellwig
Quoted 3 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new
xfs_Iocommand to make raw calls to thes/xfs_Io/xfs_io/ ?
Quoted 7 lines
Quoted 1 line
+extern void
exchangerange_init(void);No need for the extern.
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Both fixed, thanks!
--D
PATCH 10/12 libfrog: advertise exchange-range support
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Report the presence of exchange range for a given filesystem.
--- libfrog/fsgeom.c | 4 ++++ 1 file changed, 4 insertions(+)
libfrog/fsgeom.c +4 -0
@@ -31,6 +31,7 @@ xfs_report_geom(int bigtime_enabled;int inobtcount;int nrext64; +int exchangerange; isint = geo->logstart >0 ; lazycount = geo->flags &XFS_FSOP_GEOM_FLAGS_LAZYSB ?1 :0 ;
@@ -49,12 +50,14 @@ xfs_report_geom( bigtime_enabled = geo->flags &XFS_FSOP_GEOM_FLAGS_BIGTIME ?1 :0 ; inobtcount = geo->flags &XFS_FSOP_GEOM_FLAGS_INOBTCNT ?1 :0 ; nrext64 = geo->flags &XFS_FSOP_GEOM_FLAGS_NREXT64 ?1 :0 ; + exchangerange = geo->flags &XFS_FSOP_GEOM_FLAGS_EXCHANGE_RANGE ?1 :0 ; printf(_( "meta-data=%-22s isize=%-6d agcount=%u, agsize=%u blks\n" " =%-22s sectsz=%-5u attr=%u, projid32bit=%u\n" " =%-22s crc=%-8u finobt=%u, sparse=%u, rmapbt=%u\n" " =%-22s reflink=%-4u bigtime=%u inobtcount=%u nrext64=%u\n" +" =%-22s exchange=%-3u\n" "data =%-22s bsize=%-6u blocks=%llu, imaxpct=%u\n" " =%-22s sunit=%-6u swidth=%u blks\n" "naming =version %-14u bsize=%-6u ascii-ci=%d, ftype=%d\n"
@@ -65,6 +68,7 @@ xfs_report_geom("" , geo->sectsize, attrversion, projid32bit,"" , crcs_enabled, finobt_enabled, spinodes, rmapbt_enabled,"" , reflink_enabled, bigtime_enabled, inobtcount, nrext64, +"" , exchangerange,"" , geo->blocksize, (unsigned long long )geo->datablocks, geo->imaxpct, "", geo->sunit, geo->swidth,
Re: [PATCH 10/12] libfrog: advertise exchange-range support
Looks good:
PATCH 11/12 xfs_repair: add exchange-range to file systems
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enable upgrading existing filesystems to support the file exchange range feature.
--- man/man8/xfs_admin.8 | 7 +++++++ repair/globals.c | 1 + repair/globals.h | 1 + repair/phase2.c | 30 ++++++++++++++++++++++++++++++ repair/xfs_repair.c | 11 +++++++++++ 5 files changed, 50 insertions(+)
man/man8/xfs_admin.8 +7 -0
@@ -156,6 +156,13 @@ data fork extent count will be 2^48 - 1, while the maximum attribute fork extent count will be 2^32 - 1. The filesystem cannot be downgraded after this feature is enabled. Once enabled, the filesystem will not be mountable by older kernels. This feature was added to Linux 5.19. +.TP 0.4i +.B exchange +Upgrade a filesystem to support atomic file content exchanges through the +XFS_IOC_EXCHANGE_RANGE ioctl, and to support online repairs of directories, +extended attributes, symbolic links, and realtime free space metadata. +The filesystem cannot be downgraded after this feature is enabled. +Once enabled, the filesystem will not be mountable by older kernels. .RE .TP .BI \-U " uuid"
repair/globals.c +1 -0
@@ -52,6 +52,7 @@ bool features_changed; /* did we change superblock feature bits? */bool add_inobtcount;/* add inode btree counts to AGI */ bool add_bigtime;/* add support for timestamps up to 2486 */ bool add_nrext64; +bool add_exchrange;/* add file content exchange support */ /* misc status variables */
repair/globals.h +1 -0
@@ -93,6 +93,7 @@ extern bool features_changed; /* did we change superblock feature bits? */extern bool add_inobtcount;/* add inode btree counts to AGI */ extern bool add_bigtime;/* add support for timestamps up to 2486 */ extern bool add_nrext64; +extern bool add_exchrange;/* add file content exchange support */ /* misc status variables */
repair/phase2.c +30 -0
@@ -182,6 +182,34 @@ set_nrext64(return true; } +static bool +set_exchrange ( +struct xfs_mount *mp, +struct xfs_sb *new_sb) +{ +if (xfs_has_exchange_range (mp)) { +printf (_ ("Filesystem already supports exchange-range.\n" )); +exit (0 ); + } + +if (!xfs_has_crc (mp)) { +printf ( +_ ("File exchange-range feature only supported on V5 filesystems.\n" )); +exit (0 ); + } + +if (!xfs_has_reflink (mp)) { +printf ( +_ ("File exchange-range feature cannot be added without reflink.\n" )); +exit (0 ); + } + +printf (_ ("Adding file exchange-range support to filesystem.\n" )); + new_sb->sb_features_ro_compat |=XFS_SB_FEAT_INCOMPAT_EXCHRANGE ; + new_sb->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR ; +return true; +} +struct check_state {struct xfs_sb sb;uint64_t features;
@@ -290,6 +318,8 @@ upgrade_filesystem( dirty |=set_bigtime (mp, &new_sb);if (add_nrext64) dirty |=set_nrext64 (mp, &new_sb); +if (add_exchrange) + dirty |=set_exchrange (mp, &new_sb);if (!dirty)return ;
repair/xfs_repair.c +11 -0
@@ -69,6 +69,7 @@ enum c_opt_nums {CONVERT_INOBTCOUNT ,CONVERT_BIGTIME ,CONVERT_NREXT64 , +CONVERT_EXCHRANGE , C_MAX_OPTS, };
@@ -77,6 +78,7 @@ static char *c_opts[] = { [CONVERT_INOBTCOUNT] = "inobtcount", [CONVERT_BIGTIME] = "bigtime", [CONVERT_NREXT64] = "nrext64", + [CONVERT_EXCHRANGE] = "exchange", [C_MAX_OPTS] = NULL, };
@@ -360,6 +362,15 @@ process_args(int argc, char **argv) _("-c nrext64 only supports upgrades\n")); add_nrext64 = true;break ; +case CONVERT_EXCHRANGE : +if (!val) +do_abort ( +_ ("-c exchange requires a parameter\n" )); +if (strtol (val,NULL ,0 ) !=1 ) +do_abort ( +_ ("-c exchange only supports upgrades\n" )); + add_exchrange = true; +break ;default :unknown ('c' , val);break ;
Re: [PATCH 11/12] xfs_repair: add exchange-range to file systems
Looks good:
PATCH 12/12 mkfs: add a formatting option for exchange-range
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Allow users to enable the logged file mapping exchange intent items on a filesystem, which in turn enables XFS_IOC_EXCHANGE_RANGE and online repair of metadata that lives in files, e.g. directories and xattrs.
--- man/man8/mkfs.xfs.8.in | 7 +++++++ mkfs/lts_4.19.conf | 1 + mkfs/lts_5.10.conf | 1 + mkfs/lts_5.15.conf | 1 + mkfs/lts_5.4.conf | 1 + mkfs/lts_6.1.conf | 1 + mkfs/lts_6.6.conf | 1 + mkfs/xfs_mkfs.c | 26 ++++++++++++++++++++++++-- 8 files changed, 37 insertions(+), 2 deletions(-)
man/man8/mkfs.xfs.8.in +7 -0
@@ -670,6 +670,13 @@ If the value is omitted, 1 is assumed. This feature will be enabled when possible. This feature is only available for filesystems formatted with -m crc=1. .TP +.BI exchange[= value] +When enabled, application programs can exchange file contents atomically +via the XFS_IOC_EXCHANGE_RANGE ioctl. +Online repair uses this functionality to rebuild extended attributes, +directories, symbolic links, and realtime metadata files. +This feature is disabled by default. +This feature is only available for filesystems formatted with -m crc=1. .RE .PP .PD 0
mkfs/lts_4.19.conf +1 -0
@@ -12,3 +12,4 @@ rmapbt=0 [inode] sparse=1 nrext64=0 +exchange=0
mkfs/lts_5.10.conf +1 -0
@@ -12,3 +12,4 @@ rmapbt=0 [inode] sparse=1 nrext64=0 +exchange=0
mkfs/lts_5.15.conf +1 -0
@@ -12,3 +12,4 @@ rmapbt=0 [inode] sparse=1 nrext64=0 +exchange=0
mkfs/lts_5.4.conf +1 -0
@@ -12,3 +12,4 @@ rmapbt=0 [inode] sparse=1 nrext64=0 +exchange=0
mkfs/lts_6.1.conf +1 -0
@@ -12,3 +12,4 @@ rmapbt=0 [inode] sparse=1 nrext64=0 +exchange=0
mkfs/lts_6.6.conf +1 -0
@@ -12,3 +12,4 @@ rmapbt=1 [inode] sparse=1 nrext64=1 +exchange=0
mkfs/xfs_mkfs.c +24 -2
@@ -90,6 +90,7 @@ enum {I_PROJID32BIT ,I_SPINODES ,I_NREXT64 , +I_EXCHANGE , I_MAX_OPTS, };
@@ -469,6 +470,7 @@ static struct opt_params iopts = { [I_PROJID32BIT] = "projid32bit", [I_SPINODES] = "sparse", [I_NREXT64] = "nrext64", + [I_EXCHANGE] = "exchange", [I_MAX_OPTS ] =NULL , }, .subopt_params = {
@@ -523,7 +525,13 @@ static struct opt_params iopts = { .minval = 0, .maxval = 1, .defaultval = 1, - } + }, + { .index = I_EXCHANGE, + .conflicts = { { NULL, LAST_CONFLICT } }, + .minval = 0, + .maxval = 1, + .defaultval = 1, + }, }, };
@@ -889,6 +897,7 @@ struct sb_feat_args {bool nodalign;bool nortalign;bool nrext64; +bool exchrange;/* XFS_SB_FEAT_INCOMPAT_EXCHRANGE */ };struct cli_params {
@@ -1024,7 +1033,8 @@ usage( void ) sectsize=num,concurrency=num]\n\ /* force overwrite */ [-f]\n\ /* inode size */ [-i perblock=n|size=num,maxpct=n,attr=0|1|2,\n\ - projid32bit=0|1,sparse=0|1,nrext64=0|1]\n\ + projid32bit=0|1,sparse=0|1,nrext64=0|1,\n\ + exchange=0|1]\n\ /* no discard */ [-K]\n\ /* log subvol */ [-l agnum=n,internal,size=num,logdev=xxx,version=n\n\ sunit=value|su=num,sectsize=num,lazy-count=0|1,\n\
@@ -1722,6 +1732,9 @@ inode_opts_parser(case I_NREXT64 : cli->sb_feat.nrext64 =getnum (value, opts, subopt);break ; +case I_EXCHANGE : + cli->sb_feat.exchrange =getnum (value, opts, subopt); +break ;default :return -EINVAL ; }
@@ -2365,6 +2378,13 @@ _("64 bit extent count not supported without CRC support\n"));usage (); } cli->sb_feat.nrext64 = false; + +if (cli->sb_feat.exchrange &&cli_opt_set (&iopts,I_EXCHANGE )) { +fprintf (stderr, +_ ("exchange-range not supported without CRC support\n" )); +usage (); + } + cli->sb_feat.exchrange = false; }if (!cli->sb_feat.finobt) {
@@ -3498,6 +3518,8 @@ sb_set_features(if (fp->nrext64) sbp->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_NREXT64 ; +if (fp->exchrange) + sbp->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_EXCHRANGE ; }/*
Re: [PATCH 12/12] mkfs: add a formatting option for exchange-range
Looks good:
PATCH 2/16 xfsprogs: inode-related repair fixes
In reply to Darrick J. WongHi all,
While doing QA of the online fsck code, I made a few observations:
First, nobody was checking that the di_onlink field is actually zero; Second, that allocating a temporary file for repairs can fail (and thus bring down the entire fs) if the inode cluster is corrupt; and Third, that file link counts do not pin at ~0U to prevent integer overflows.
This scattered patchset fixes those three problems.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=inode-repair-improvements
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=inode-repair-improvements
---
Commits in this patchset:
* xfs_{db,repair}: add an explicit owner field to xfs_da_args
* libxfs: port the bumplink function from the kernel
* mkfs/repair: pin inodes that would otherwise overflow link count
--- db/namei.c | 1 + include/xfs_inode.h | 2 ++ libxfs/util.c | 18 ++++++++++++++++++ mkfs/proto.c | 4 ++-- repair/incore_ino.c | 3 ++- repair/phase6.c | 13 ++++++++----- 6 files changed, 33 insertions(+), 8 deletions(-)
PATCH 1/3 xfs_{db,repair}: add an explicit owner field to xfs_da_args
From: Darrick J. Wong <[email protected]>
Update these two utilities to set the owner field of the da args structure prior to calling directory and extended attribute functions.
--- db/namei.c | 1 + repair/phase6.c | 3 +++ 2 files changed, 4 insertions(+)
db/namei.c +1 -0
@@ -447,6 +447,7 @@ listdir(struct xfs_da_args args = { .dp = dp, .geo = dp->i_mount->m_dir_geo, + .owner = dp->i_ino, };int error;
repair/phase6.c +3 -0
@@ -1401,6 +1401,7 @@ dir2_kill_block( args.trans = tp; args.whichfork =XFS_DATA_FORK ; args.geo = mp->m_dir_geo; + args.owner = ip->i_ino;if (da_bno >= mp->m_dir_geo->leafblk && da_bno < mp->m_dir_geo->freeblk) error = -libxfs_da_shrink_inode (&args, da_bno, bp);else
@@ -1505,6 +1506,7 @@ longform_dir2_entry_check_data(struct xfs_da_args da = { .dp = ip, .geo = mp->m_dir_geo, + .owner = ip->i_ino, };
@@ -2294,6 +2296,7 @@ longform_dir2_entry_check(/* is this a block, leaf, or node directory? */ args.dp = ip; args.geo = mp->m_dir_geo; + args.owner = ip->i_ino; fmt =libxfs_dir2_format (&args, &error);/* check directory "data" blocks (ie. name/inode pairs) */
Re: [PATCH 1/3] xfs_{db,repair}: add an explicit owner field to xfs_da_args
Looks good:
PATCH 2/3 libxfs: port the bumplink function from the kernel
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Port the xfs_bumplink function from the kernel and use it to replace raw calls to inc_nlink. The next patch will need this common function to prevent integer overflows in the link count.
--- include/xfs_inode.h | 2 ++ libxfs/util.c | 17 +++++++++++++++++ mkfs/proto.c | 4 ++-- repair/phase6.c | 10 +++++----- 4 files changed, 26 insertions(+), 7 deletions(-)
include/xfs_inode.h +2 -0
@@ -359,6 +359,8 @@ extern void libxfs_trans_ichgtime(struct xfs_trans *, struct xfs_inode *, int);extern int libxfs_iflush_int (struct xfs_inode *,struct xfs_buf *); +void libxfs_bumplink (struct xfs_trans *tp,struct xfs_inode *ip); +/* Inode Cache Interfaces */ extern int libxfs_iget (struct xfs_mount *,struct xfs_trans *,xfs_ino_t ,uint ,struct xfs_inode **);
libxfs/util.c +17 -0
@@ -240,6 +240,23 @@ xfs_inode_propagate_flags( ip->i_diflags |= di_flags; } +/* +* Increment the link count on an inode & log the change. +*/ +void +libxfs_bumplink ( +struct xfs_trans *tp, +struct xfs_inode *ip) +{ +struct inode *inode =VFS_I (ip); + +xfs_trans_ichgtime (tp, ip,XFS_ICHGTIME_CHG ); + +inc_nlink (inode); + +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); +} +/* * Initialise a newly allocated inode and return the in-core inode to the * caller locked exclusively.
mkfs/proto.c +2 -2
@@ -591,7 +591,7 @@ parseproto( &creds, fsxp, &ip);if (error)fail (_ ("Inode allocation failed" ), error); -inc_nlink (VFS_I (ip));/* account for . */ +libxfs_bumplink (tp, ip);/* account for . */ if (!pip) { pip = ip; mp->m_sb.sb_rootino = ip->i_ino;
@@ -601,7 +601,7 @@ parseproto(libxfs_trans_ijoin (tp, pip,0 ); xname.type =XFS_DIR3_FT_DIR ;newdirent (mp, tp, pip, &xname, ip->i_ino); -inc_nlink (VFS_I (pip)); +libxfs_bumplink (tp, pip);libxfs_trans_log_inode (tp, pip,XFS_ILOG_CORE ); }newdirectory (mp, tp, ip, pip);
repair/phase6.c +5 -5
@@ -947,7 +947,7 @@ mk_orphanage(xfs_mount_t *mp)do_error (_ ("%s inode allocation failed %d\n" ),ORPHANAGE , error); } -inc_nlink (VFS_I (ip));/* account for . */ +libxfs_bumplink (tp, ip);/* account for . */ ino = ip->i_ino; irec = find_inode_rec(mp,
@@ -999,7 +999,7 @@ mk_orphanage(xfs_mount_t *mp)* for .. in the new directory, and update the irec copy of the * on-disk nlink so we don't fail the link count check later. */ -inc_nlink (VFS_I (pip)); +libxfs_bumplink (tp, pip); irec =find_inode_rec (mp,XFS_INO_TO_AGNO (mp, mp->m_sb.sb_rootino),XFS_INO_TO_AGINO (mp, mp->m_sb.sb_rootino));add_inode_ref (irec,0 );
@@ -1094,7 +1094,7 @@ mv_orphanage(if (irec)add_inode_ref (irec, ino_offset);else -inc_nlink (VFS_I (orphanage_ip)); +libxfs_bumplink (tp, orphanage_ip);libxfs_trans_log_inode (tp, orphanage_ip,XFS_ILOG_CORE ); err = -libxfs_dir_createname(tp, ino_p, &xfs_name_dotdot,
@@ -1103,7 +1103,7 @@ mv_orphanage(do_error (_ ("creation of .. entry failed (%d)\n" ), err); -inc_nlink (VFS_I (ino_p)); +libxfs_bumplink (tp, ino_p);libxfs_trans_log_inode (tp, ino_p,XFS_ILOG_CORE ); err = -libxfs_trans_commit (tp);if (err)
@@ -1128,7 +1128,7 @@ mv_orphanage(if (irec)add_inode_ref (irec, ino_offset);else -inc_nlink (VFS_I (orphanage_ip)); +libxfs_bumplink (tp, orphanage_ip);libxfs_trans_log_inode (tp, orphanage_ip,XFS_ILOG_CORE );/*
Re: [PATCH 2/3] libxfs: port the bumplink function from the kernel
Looks good:
PATCH 3/3 mkfs/repair: pin inodes that would otherwise overflow link count
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Update userspace utilities not to allow integer overflows of inode link counts to result in a file that is referenced by parent directories but has zero link count.
--- libxfs/util.c | 3 ++- repair/incore_ino.c | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-)
libxfs/util.c +2 -1
@@ -252,7 +252,8 @@ libxfs_bumplink(xfs_trans_ichgtime (tp, ip,XFS_ICHGTIME_CHG ); -inc_nlink (inode); +if (inode->i_nlink !=XFS_NLINK_PINNED ) +inc_nlink (inode);xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); }
repair/incore_ino.c +2 -1
@@ -108,7 +108,8 @@ void add_inode_ref(struct ino_tree_node *irec, int ino_offset)nlink_grow_16_to_32 (irec);/*FALLTHRU*/ case sizeof (uint32_t ): - irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]++; +if (irec->ino_un.ex_data->counted_nlinks.un32[ino_offset] !=XFS_NLINK_PINNED ) + irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]++;break ;default :ASSERT (0 );
Re: [PATCH 3/3] mkfs/repair: pin inodes that would otherwise overflow link count
repair/incore_ino.c void add_inode_ref(struct ino_tree_node *irec, int ino_offset) · line 111
Quoted 3 lines · Darrick J. Wong
repair/incore_ino.c +1
-1case sizeof (uint32_t ): - irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]++; +if (irec->ino_un.ex_data->counted_nlinks.un32[ino_offset] !=XFS_NLINK_PINNED )
Avoid the long line here.
Otherwise looks good:
PATCH 3/16 xfs_scrub: detect deceptive filename extensions
In reply to Darrick J. WongHi all,
In early 2023, malware researchers disclosed a phishing attack that was targeted at people running Linux workstations. The attack vector involved the use of filenames containing what looked like a file extension but instead contained a lookalike for the full stop (".") and a common extension ("pdf"). Enhance xfs_scrub phase 5 to detect these types of attacks and warn the system administrator.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-detect-deceptive-extensions
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=scrub-detect-deceptive-extensions
---
Commits in this patchset:
* xfs_scrub: use proper UChar string iterators
* xfs_scrub: hoist code that removes ignorable characters
* xfs_scrub: add a couple of omitted invisible code points
* xfs_scrub: avoid potential UAF after freeing a duplicate name entry
* xfs_scrub: guard against libicu returning negative buffer lengths
* xfs_scrub: hoist non-rendering character predicate
* xfs_scrub: store bad flags with the name entry
* xfs_scrub: rename UNICRASH_ZERO_WIDTH to UNICRASH_INVISIBLE
* xfs_scrub: type-coerce the UNICRASH_* flags
* xfs_scrub: reduce size of struct name_entry
* xfs_scrub: rename struct unicrash.normalizer
* xfs_scrub: report deceptive file extensions
* xfs_scrub: dump unicode points
--- scrub/unicrash.c | 530 +++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 424 insertions(+), 106 deletions(-)
PATCH 1/13 xfs_scrub: use proper UChar string iterators
From: Darrick J. Wong <[email protected]>
For code that wants to examine a UChar string, use libicu's string iterators to walk UChar strings, instead of the open-coded U16_NEXT* macros that perform no typechecking.
--- scrub/unicrash.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
scrub/unicrash.c +3 -4
@@ -330,13 +330,12 @@ name_entry_examine(struct name_entry *entry, unsigned int *badflags) { + UCharIterator uiter;UChar32 uchr; -int32_t i;uint8_t mask =0 ; -for (i =0 ; i < entry->normstrlen;) { -U16_NEXT_UNSAFE (entry->normstr, i, uchr); - +uiter_setString (&uiter, entry->normstr, entry->normstrlen); +while ((uchr =uiter_next32 (&uiter)) !=U_SENTINEL ) {/* zero width character sequences */ switch (uchr) {case 0x200B :/* zero width space */
Re: [PATCH 01/13] xfs_scrub: use proper UChar string iterators
Quoted 5 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
For code that wants to examine a UChar string, use libicu's string iterators to walk UChar strings, instead of the open-coded U16_NEXT* macros that perform no typechecking.
I don't claim to understand libicu, but the code looks sane to me:
PATCH 2/13 xfs_scrub: hoist code that removes ignorable characters
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Hoist the loop that removes "ignorable" code points from the skeleton string into a separate function and give the UChar cursors names that are easier to understand. Convert the code to use the safe versions of the U16_ accessor functions.
--- scrub/unicrash.c | 39 ++++++++++++++++++++++++++------------- 1 file changed, 26 insertions(+), 13 deletions(-)
scrub/unicrash.c +26 -13
@@ -145,6 +145,31 @@ is_utf8_locale(void)return answer; } +/* +* Remove control/formatting characters from this string and return its new +* length. UChar32 is required for U16_NEXT, despite the name. +*/ +static int32_t +remove_ignorable ( +UChar *ustr, +int32_t ustrlen) +{ +UChar32 uchr; +int32_t src, dest; + +for (src =0 , dest =0 ; src < ustrlen; dest = src) { +U16_NEXT (ustr, src, ustrlen, uchr); +if (!u_isIDIgnorable (uchr)) +continue ; +memmove (&ustr[dest], &ustr[src], + (ustrlen - src +1 ) *sizeof (UChar)); + ustrlen -= (src - dest); + src = dest; + } + +return dest; +} +/* * Generate normalized form and skeleton of the name. If this fails, just * forget everything and return false; this is an advisory checker.
@@ -160,9 +185,6 @@ name_entry_compute_checknames(int32_t normstrlen;int32_t unistrlen;int32_t skelstrlen; -UChar32 uchr; -int32_t i, j; -UErrorCode uerr =U_ZERO_ERROR ;/* Convert bytestr to unistr for normalization */
@@ -206,16 +228,7 @@ name_entry_compute_checknames(if (U_FAILURE (uerr)) goto out_skelstr; -/* Remove control/formatting characters from skeleton. */ -for (i =0 , j =0 ; i < skelstrlen; j = i) { -U16_NEXT_UNSAFE (skelstr, i, uchr); -if (!u_isIDIgnorable (uchr)) -continue ; -memmove (&skelstr[j], &skelstr[i], - (skelstrlen - i +1 ) *sizeof (UChar)); - skelstrlen -= (i - j); - i = j; - } + skelstrlen =remove_ignorable (skelstr, skelstrlen); entry->skelstr = skelstr; entry->skelstrlen = skelstrlen;
Re: [PATCH 02/13] xfs_scrub: hoist code that removes ignorable characters
Looks good:
PATCH 3/13 xfs_scrub: add a couple of omitted invisible code points
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
I missed a few non-rendering code points in the "zero width" classification code. Add them now, and sort the list.
$ wget https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt $ grep -E '(zero width|invisible|joiner|application)' -i UnicodeData.txt
--- scrub/unicrash.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
scrub/unicrash.c +3 -1
@@ -351,15 +351,17 @@ name_entry_examine(while ((uchr =uiter_next32 (&uiter)) !=U_SENTINEL ) {/* zero width character sequences */ switch (uchr) { +case 0x034F :/* combining grapheme joiner */ case 0x200B :/* zero width space */ case 0x200C :/* zero width non-joiner */ case 0x200D :/* zero width joiner */ -case 0xFEFF :/* zero width non breaking space */ case 0x2060 :/* word joiner */ case 0x2061 :/* function application */ case 0x2062 :/* invisible times (multiply) */ case 0x2063 :/* invisible separator (comma) */ case 0x2064 :/* invisible plus (addition) */ +case 0x2D7F :/* tifinagh consonant joiner */ +case 0xFEFF :/* zero width non breaking space */ *badflags |=UNICRASH_ZERO_WIDTH ;break ; }
Re: [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code points
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
I missed a few non-rendering code points in the "zero width" classification code. Add them now, and sort the list.
$ wget https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt $ grep -E '(zero width|invisible|joiner|application)' -i UnicodeData.txt
Should this be automated?
Otherwise looks good:
Re: [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code points
Quoted 10 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
I missed a few non-rendering code points in the "zero width" classification code. Add them now, and sort the list.
$ wget https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt $ grep -E '(zero width|invisible|joiner|application)' -i UnicodeData.txtShould this be automated?
That will require a bit more thought -- many distro build systems these days operate in a sealed box with no network access, so you can't really automate this. libicu (the last time I looked) didn't have a predicate to tell you if a particular code point was one of the invisible ones.
Here's what I get from running the commands right now:
009F;<control>;Cc;0;BN;;;;;N;APPLICATION PROGRAM COMMAND;;;; 034F;COMBINING GRAPHEME JOINER;Mn;0;NSM;;;;;N;;;;; 200B;ZERO WIDTH SPACE;Cf;0;BN;;;;;N;;;;;
200C;ZERO WIDTH NON-JOINER;Cf;0;BN;;;;;N;;;;; 200D;ZERO WIDTH JOINER;Cf;0;BN;;;;;N;;;;;
2060;WORD JOINER;Cf;0;BN;;;;;N;;;;;
2061;FUNCTION APPLICATION;Cf;0;BN;;;;;N;;;;; 2062;INVISIBLE TIMES;Cf;0;BN;;;;;N;;;;;
2063;INVISIBLE SEPARATOR;Cf;0;BN;;;;;N;;;;; 2064;INVISIBLE PLUS;Cf;0;BN;;;;;N;;;;;
2D7F;TIFINAGH CONSONANT JOINER;Mn;9;NSM;;;;;N;;;;; FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;; 1107F;BRAHMI NUMBER JOINER;Mn;9;NSM;;;;;N;;;;; 11A47;ZANABAZAR SQUARE SUBJOINER;Mn;9;NSM;;;;;N;;;;; 11A99;SOYOMBO SUBJOINER;Mn;9;NSM;;;;;N;;;;;
11F42;KAWI CONJOINER;Mn;9;NSM;;;;;N;;;;; 13430;EGYPTIAN HIEROGLYPH VERTICAL JOINER;Cf;0;L;;;;;N;;;;; 13431;EGYPTIAN HIEROGLYPH HORIZONTAL JOINER;Cf;0;L;;;;;N;;;;;
The five-digit ones are new to me; I'll go have a look at how the noto(fu) fonts render those.
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
Re: [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code points
Quoted 9 lines · Darrick J. Wong
Quoted 4 lines
Quoted 2 lines
$ wget https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt $ grep -E '(zero width|invisible|joiner|application)' -i UnicodeData.txtShould this be automated?
That will require a bit more thought -- many distro build systems these days operate in a sealed box with no network access, so you can't really automate this. libicu (the last time I looked) didn't have a predicate to tell you if a particular code point was one of the invisible ones.
Oh, I absolutely do not suggest to run the wget from a normal build!
But if you look at the kernel unicode CI support, it allows you to place the downloaded file into the kernel tree, and then case make file rules to re-generate the tables from it (see fs/unicode/Makefile).
Re: [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code points
Quoted 11 lines · Christoph Hellwig
Quoted 9 lines · Darrick J. Wong
Quoted 4 lines
Quoted 2 lines
$ wget https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt $ grep -E '(zero width|invisible|joiner|application)' -i UnicodeData.txtShould this be automated?
That will require a bit more thought -- many distro build systems these days operate in a sealed box with no network access, so you can't really automate this. libicu (the last time I looked) didn't have a predicate to tell you if a particular code point was one of the invisible ones.
Quoted 5 lines
Oh, I absolutely do not suggest to run the wget from a normal build!
But if you look at the kernel unicode CI support, it allows you to place the downloaded file into the kernel tree, and then case make file rules to re-generate the tables from it (see
fs/unicode/Makefile).
Ah ok got it, will take a closer look tomorrow.
--D
Re: [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code points
Quoted 12 lines · Darrick J. Wong
Quoted 11 lines · Christoph Hellwig
Quoted 9 lines · Darrick J. Wong
Quoted 4 lines
Quoted 2 lines
$ wget https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt $ grep -E '(zero width|invisible|joiner|application)' -i UnicodeData.txtShould this be automated?
That will require a bit more thought -- many distro build systems these days operate in a sealed box with no network access, so you can't really automate this. libicu (the last time I looked) didn't have a predicate to tell you if a particular code point was one of the invisible ones.
Quoted 7 lines
Quoted 5 lines
Oh, I absolutely do not suggest to run the wget from a normal build!
But if you look at the kernel unicode CI support, it allows you to place the downloaded file into the kernel tree, and then case make file rules to re-generate the tables from it (see
fs/unicode/Makefile).Ah ok got it, will take a closer look tomorrow.
I'm not sure if there's a good way to automate this. But let's go through the grep output?
009F;<control>;Cc;0;BN;;;;;N;APPLICATION PROGRAM COMMAND;;;;
This one seems to render as Ÿ (Y with two dots above it) so I didn't put this in the case statement.
034F;COMBINING GRAPHEME JOINER;Mn;0;NSM;;;;;N;;;;;
Doesn't seem to have any sort of rendering (i.e. if I type them into a web browser, it doesn't render any glyph at all), so I put it in the case statement.
200B;ZERO WIDTH SPACE;Cf;0;BN;;;;;N;;;;;
200C;ZERO WIDTH NON-JOINER;Cf;0;BN;;;;;N;;;;;
200D;ZERO WIDTH JOINER;Cf;0;BN;;;;;N;;;;;
These ones have 'zero-width' in the name, so I put these in the denylist.
2060;WORD JOINER;Cf;0;BN;;;;;N;;;;;
https://www.unicode.org/reports/tr14/ says that this doesn't have any rendering, nor does my web browser try one.
Come to think of it, I should probably add these two:
2028;LINE SEPARATOR;Zl;0;WS;;;;;N;;;;;
2029;PARAGRAPH SEPARATOR;Zp;0;B;;;;;N;;;;;
because it doesn't render either.
2061;FUNCTION APPLICATION;Cf;0;BN;;;;;N;;;;;
https://www.unicode.org/reports/tr25/tr25-6.html says this is a metacharacter and doesn't have its own rendering. It seems to be there to indicate that this:
f(x + y)
is a function taking "x + y" as a parameter, and not shorthand for:
f*x + f+y
2062;INVISIBLE TIMES;Cf;0;BN;;;;;N;;;;;
2063;INVISIBLE SEPARATOR;Cf;0;BN;;;;;N;;;;;
2064;INVISIBLE PLUS;Cf;0;BN;;;;;N;;;;;
These have 'invisible' in the name, that seems pretty obvious to me.
2D7F;TIFINAGH CONSONANT JOINER;Mn;9;NSM;;;;;N;;;;;
This one doesn't seem to render either. Unicode 15.1 says it isn't visible rendered.
FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;;
Another 'zero-width' one, same as the others.
1107F;BRAHMI NUMBER JOINER;Mn;9;NSM;;;;;N;;;;; 11A47;ZANABAZAR SQUARE SUBJOINER;Mn;9;NSM;;;;;N;;;;; 11A99;SOYOMBO SUBJOINER;Mn;9;NSM;;;;;N;;;;; 13430;EGYPTIAN HIEROGLYPH VERTICAL JOINER;Cf;0;L;;;;;N;;;;; 13431;EGYPTIAN HIEROGLYPH HORIZONTAL JOINER;Cf;0;L;;;;;N;;;;;
When I typed these into a browser, I got *some* kind of rendering. I doubt I'm using them correctly, since they're likely supposed to be surrounded by other codepoints from the same chart.
11F42;KAWI CONJOINER;Mn;9;NSM;;;;;N;;;;;
I don't even know about this one; it generated "tofu" (aka those horrid rectangular boxes with the byte representation in them). On the other hand, https://www.unicode.org/notes/tn48/UTN48-Implementing-Kawi-1.pdf
says it's not visible by itself. But paired with Kawi script, it's supposed to affect the formatting.
I'm not sure how exactly to write a classifier here -- the 'invisible' and 'zero width' ones are obvious, but the 'joiner' code points don't seem to have any obvious trend to them.
For now I think I'll take the "conservative" approach and only flag things that sound like they're supposed to be general metacharacters, and leave out the modifier codepoints that are ok if they're surrounded by certain codepoints. But this is a rather manual process.
--D
Re: [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code points
Quoted 8 lines · Darrick J. Wong
I'm not sure how exactly to write a classifier here -- the 'invisible' and 'zero width' ones are obvious, but the 'joiner' code points don't seem to have any obvious trend to them.
For now I think I'll take the "conservative" approach and only flag things that sound like they're supposed to be general metacharacters, and leave out the modifier codepoints that are ok if they're surrounded by certain codepoints. But this is a rather manual process.
Oh, right. There is no clear identification and you are just doing a manual search based on viѕual output. Yes, there's unfortunately no really good way to automate that.
PATCH 4/13 xfs_scrub: avoid potential UAF after freeing a duplicate name entry
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Change the function declaration of unicrash_add to set the caller's @new_entry to NULL if we detect an updated name entry and do not wish to continue processing. This avoids a theoretical UAF if the unicrash_add caller were to accidentally continue using the pointer.
This isn't an /actual/ UAF because the function formerly set @badflags to zero, but let's be a little defensive.
--- scrub/unicrash.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
scrub/unicrash.c +5 -4
@@ -626,10 +626,11 @@ _("Unicode name \"%s\" in %s could be confused with \"%s\"."),static void unicrash_add (struct unicrash *uc, -struct name_entry *new_entry, +struct name_entry **new_entryp,unsigned int *badflags,struct name_entry **existing_entry) { +struct name_entry *new_entry = *new_entryp;struct name_entry *entry;size_t bucket;xfs_dahash_t hash;
@@ -652,7 +653,7 @@ unicrash_add( entry->ino = new_entry->ino; uc->buckets[bucket] = new_entry->next;name_entry_free (new_entry); - *badflags =0 ; + *new_entryp =NULL ;return ; }
@@ -695,8 +696,8 @@ __unicrash_check_name(return 0 ;name_entry_examine (new_entry, &badflags); -unicrash_add (uc, new_entry, &badflags, &dup_entry); -if (badflags) +unicrash_add (uc, &new_entry, &badflags, &dup_entry); +if (new_entry && badflags)unicrash_complain (uc, dsc, namedescr, new_entry, badflags, dup_entry);
Re: [PATCH 04/13] xfs_scrub: avoid potential UAF after freeing a duplicate name entry
Looks good:
PATCH 5/13 xfs_scrub: guard against libicu returning negative buffer lengths
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The libicu functions u_strFromUTF8, unorm2_normalize, and uspoof_getSkeleton return int32_t values. Guard against negative return values, even though the library itself never does this.
--- scrub/unicrash.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
scrub/unicrash.c +3 -3
@@ -189,7 +189,7 @@ name_entry_compute_checknames(/* Convert bytestr to unistr for normalization */ u_strFromUTF8 (NULL ,0 , &unistrlen, entry->name, entry->namelen, &uerr); -if (uerr !=U_BUFFER_OVERFLOW_ERROR ) +if (uerr !=U_BUFFER_OVERFLOW_ERROR || unistrlen <0 )return false; uerr =U_ZERO_ERROR ; unistr =calloc (unistrlen +1 ,sizeof (UChar));
@@ -203,7 +203,7 @@ name_entry_compute_checknames(/* Normalize the string. */ normstrlen =unorm2_normalize (uc->normalizer, unistr, unistrlen,NULL ,0 , &uerr); -if (uerr !=U_BUFFER_OVERFLOW_ERROR ) +if (uerr !=U_BUFFER_OVERFLOW_ERROR || normstrlen <0 ) goto out_unistr; uerr =U_ZERO_ERROR ; normstr =calloc (normstrlen +1 ,sizeof (UChar));
@@ -217,7 +217,7 @@ name_entry_compute_checknames(/* Compute skeleton. */ skelstrlen =uspoof_getSkeleton (uc->spoof,0 , unistr, unistrlen,NULL ,0 , &uerr); -if (uerr !=U_BUFFER_OVERFLOW_ERROR ) +if (uerr !=U_BUFFER_OVERFLOW_ERROR || skelstrlen <0 ) goto out_normstr; uerr =U_ZERO_ERROR ; skelstr =calloc (skelstrlen +1 ,sizeof (UChar));
Re: [PATCH 05/13] xfs_scrub: guard against libicu returning negative buffer lengths
Looks good:
PATCH 6/13 xfs_scrub: hoist non-rendering character predicate
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Hoist this predicate code into its own function; we're going to use it elsewhere later on. While we're at it, document how we generated this list in the first place.
--- scrub/unicrash.c | 45 ++++++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 15 deletions(-)
scrub/unicrash.c +30 -15
@@ -170,6 +170,34 @@ remove_ignorable(return dest; } +/* +* Certain unicode codepoints are formatting hints that are not themselves +* supposed to be rendered by a display system. These codepoints can be +* encoded in file names to try to confuse users. +* +* Download https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt and +* $ grep -E '(zero width|invisible|joiner|application)' -i UnicodeData.txt +*/ +static inline bool is_nonrendering (UChar32 uchr) +{ +switch (uchr) { +case 0x034F :/* combining grapheme joiner */ +case 0x200B :/* zero width space */ +case 0x200C :/* zero width non-joiner */ +case 0x200D :/* zero width joiner */ +case 0x2060 :/* word joiner */ +case 0x2061 :/* function application */ +case 0x2062 :/* invisible times (multiply) */ +case 0x2063 :/* invisible separator (comma) */ +case 0x2064 :/* invisible plus (addition) */ +case 0x2D7F :/* tifinagh consonant joiner */ +case 0xFEFF :/* zero width non breaking space */ +return true; + } + +return false; +} +/* * Generate normalized form and skeleton of the name. If this fails, just * forget everything and return false; this is an advisory checker.
@@ -349,22 +377,9 @@ name_entry_examine(uiter_setString (&uiter, entry->normstr, entry->normstrlen);while ((uchr =uiter_next32 (&uiter)) !=U_SENTINEL ) { -/* zero width character sequences */ -switch (uchr) { -case 0x034F :/* combining grapheme joiner */ -case 0x200B :/* zero width space */ -case 0x200C :/* zero width non-joiner */ -case 0x200D :/* zero width joiner */ -case 0x2060 :/* word joiner */ -case 0x2061 :/* function application */ -case 0x2062 :/* invisible times (multiply) */ -case 0x2063 :/* invisible separator (comma) */ -case 0x2064 :/* invisible plus (addition) */ -case 0x2D7F :/* tifinagh consonant joiner */ -case 0xFEFF :/* zero width non breaking space */ +/* characters are invisible */ +if (is_nonrendering (uchr)) *badflags |=UNICRASH_ZERO_WIDTH ; -break ; - }/* control characters */ if (u_iscntrl (uchr))
Re: [PATCH 06/13] xfs_scrub: hoist non-rendering character predicate
Looks good:
PATCH 7/13 xfs_scrub: store bad flags with the name entry
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When scrub is checking unicode names, there are certain properties of the directory/attribute/label name itself that it can complain about. Store these in struct name_entry so that the confusable names detector can pick this up later.
This restructuring enables a subsequent patch to detect suspicious sequences in the NFC normalized form of the name without needing to hang on to that NFC form until the end of processing. IOWs, it's a memory usage optimization.
--- scrub/unicrash.c | 122 ++++++++++++++++++++++++++++-------------------------- 1 file changed, 64 insertions(+), 58 deletions(-)
scrub/unicrash.c +64 -58
@@ -69,6 +69,9 @@ struct name_entry {xfs_ino_t ino; +/* Everything that we don't like about this name. */ +unsigned int badflags; +/* Raw dirent name */ size_t namelen;char name[0 ];
@@ -274,6 +277,55 @@ name_entry_compute_checknames(return false; } +/* +* Check a name for suspicious elements that have appeared in filename +* spoofing attacks. This includes names that mixed directions or contain +* direction overrides control characters, both of which have appeared in +* filename spoofing attacks. +*/ +static unsigned int +name_entry_examine ( +const struct name_entry *entry) +{ +UCharIterator uiter; +UChar32 uchr; +uint8_t mask =0 ; +unsigned int ret =0 ; + +uiter_setString (&uiter, entry->normstr, entry->normstrlen); +while ((uchr =uiter_next32 (&uiter)) !=U_SENTINEL ) { +/* characters are invisible */ +if (is_nonrendering (uchr)) + ret |=UNICRASH_ZERO_WIDTH ; + +/* control characters */ +if (u_iscntrl (uchr)) + ret |=UNICRASH_CONTROL_CHAR ; + +switch (u_charDirection (uchr)) { +case U_LEFT_TO_RIGHT : + mask |=0x01 ; +break ; +case U_RIGHT_TO_LEFT : + mask |=0x02 ; +break ; +case U_RIGHT_TO_LEFT_OVERRIDE : + ret |=UNICRASH_BIDI_OVERRIDE ; +break ; +case U_LEFT_TO_RIGHT_OVERRIDE : + ret |=UNICRASH_BIDI_OVERRIDE ; +break ; +default : +break ; + } + } + +/* mixing left-to-right and right-to-left chars */ +if (mask ==0x3 ) + ret |=UNICRASH_BIDI_MIXED ; +return ret; +} +/* Create a new name entry, returns false if we could not succeed. */ static bool name_entry_create(
@@ -299,6 +351,7 @@ name_entry_create(if (!name_entry_compute_checknames (uc, new_entry)) goto out; + new_entry->badflags =name_entry_examine (new_entry); *entry = new_entry;return true;
@@ -360,54 +413,6 @@ name_entry_hash( } } -/* -* Check a name for suspicious elements that have appeared in filename -* spoofing attacks. This includes names that mixed directions or contain -* direction overrides control characters, both of which have appeared in -* filename spoofing attacks. -*/ -static void -name_entry_examine ( -struct name_entry *entry, -unsigned int *badflags) -{ -UCharIterator uiter; -UChar32 uchr; -uint8_t mask =0 ; - -uiter_setString (&uiter, entry->normstr, entry->normstrlen); -while ((uchr =uiter_next32 (&uiter)) !=U_SENTINEL ) { -/* characters are invisible */ -if (is_nonrendering (uchr)) - *badflags |=UNICRASH_ZERO_WIDTH ; - -/* control characters */ -if (u_iscntrl (uchr)) - *badflags |=UNICRASH_CONTROL_CHAR ; - -switch (u_charDirection (uchr)) { -case U_LEFT_TO_RIGHT : - mask |=0x01 ; -break ; -case U_RIGHT_TO_LEFT : - mask |=0x02 ; -break ; -case U_RIGHT_TO_LEFT_OVERRIDE : - *badflags |=UNICRASH_BIDI_OVERRIDE ; -break ; -case U_LEFT_TO_RIGHT_OVERRIDE : - *badflags |=UNICRASH_BIDI_OVERRIDE ; -break ; -default : -break ; - } - } - -/* mixing left-to-right and right-to-left chars */ -if (mask ==0x3 ) - *badflags |=UNICRASH_BIDI_MIXED ; -} -/* Initialize the collision detector. */ static int unicrash_init(
@@ -638,17 +643,17 @@ _("Unicode name \"%s\" in %s could be confused with \"%s\"."),* must be skeletonized according to Unicode TR39 to detect names that * could be visually confused with each other. */ -static void +static unsigned int unicrash_add (struct unicrash *uc,struct name_entry **new_entryp, -unsigned int *badflags,struct name_entry **existing_entry) {struct name_entry *new_entry = *new_entryp;struct name_entry *entry;size_t bucket;xfs_dahash_t hash; +unsigned int badflags = new_entry->badflags;/* Store name in hashtable. */ hash =name_entry_hash (new_entry);
@@ -669,28 +674,30 @@ unicrash_add( uc->buckets[bucket] = new_entry->next;name_entry_free (new_entry); *new_entryp =NULL ; -return ; +return 0 ; }/* Same normalization? */ if (new_entry->normstrlen == entry->normstrlen && !u_strcmp (new_entry->normstr, entry->normstr) && (uc->compare_ino ? entry->ino != new_entry->ino : true)) { - *badflags |=UNICRASH_NOT_UNIQUE ; + badflags |=UNICRASH_NOT_UNIQUE ; *existing_entry = entry; -return ; +break ; }/* Confusable? */ if (new_entry->skelstrlen == entry->skelstrlen && !u_strcmp (new_entry->skelstr, entry->skelstr) && (uc->compare_ino ? entry->ino != new_entry->ino : true)) { - *badflags |=UNICRASH_CONFUSABLE ; + badflags |=UNICRASH_CONFUSABLE ; *existing_entry = entry; -return ; +break ; } entry = entry->next; } + +return badflags; }/* Check a name for unicode normalization problems or collisions. */
@@ -704,14 +711,13 @@ __unicrash_check_name( {struct name_entry *dup_entry =NULL ;struct name_entry *new_entry =NULL ; -unsigned int badflags =0 ; +unsigned int badflags;/* If we can't create entry data, just skip it. */ if (!name_entry_create (uc, name, ino, &new_entry))return 0 ; -name_entry_examine (new_entry, &badflags); -unicrash_add (uc, &new_entry, &badflags, &dup_entry); + badflags =unicrash_add (uc, &new_entry, &dup_entry);if (new_entry && badflags)unicrash_complain (uc, dsc, namedescr, new_entry, badflags, dup_entry);
Re: [PATCH 07/13] xfs_scrub: store bad flags with the name entry
Looks good:
PATCH 8/13 xfs_scrub: rename UNICRASH_ZERO_WIDTH to UNICRASH_INVISIBLE
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
"Zero width" doesn't fully describe what the flag represents -- it gets set for any codepoint that doesn't render. Rename it accordingly.
--- scrub/unicrash.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
scrub/unicrash.c +3 -3
@@ -109,7 +109,7 @@ struct unicrash {#define UNICRASH_CONTROL_CHAR (1 << 3)/* Invisible characters. Only a problem if we have collisions. */ -#define UNICRASH_ZERO_WIDTH (1 << 4) +#define UNICRASH_INVISIBLE (1 << 4)/* Multiple names resolve to the same skeleton string. */ #define UNICRASH_CONFUSABLE (1 << 5)
@@ -296,7 +296,7 @@ name_entry_examine(while ((uchr =uiter_next32 (&uiter)) !=U_SENTINEL ) {/* characters are invisible */ if (is_nonrendering (uchr)) - ret |=UNICRASH_ZERO_WIDTH ; + ret |=UNICRASH_INVISIBLE ;/* control characters */ if (u_iscntrl (uchr))
@@ -580,7 +580,7 @@ _("Unicode name \"%s\" in %s renders identically to \"%s\"."),* confused with another name as a result, we should complain. * "moo<zerowidthspace>cow" and "moocow" are misleading. */ -if ((badflags &UNICRASH_ZERO_WIDTH ) && +if ((badflags &UNICRASH_INVISIBLE ) && (badflags &UNICRASH_CONFUSABLE )) { str_warn(uc->ctx, descr_render(dsc), _("Unicode name \"%s\" in %s could be confused with '%s' due to invisible characters."),
Re: [PATCH 08/13] xfs_scrub: rename UNICRASH_ZERO_WIDTH to UNICRASH_INVISIBLE
Looks good:
PATCH 9/13 xfs_scrub: type-coerce the UNICRASH_* flags
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Promote this type to something that we can type-check.
--- scrub/unicrash.c | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-)
scrub/unicrash.c +18 -12
@@ -4,6 +4,7 @@* Author: Darrick J. Wong <[email protected]> */ #include "xfs.h" +#include "xfs_arch.h" #include <stdint.h> #include <stdlib.h> #include <dirent.h>
@@ -56,6 +57,8 @@* In other words, skel = remove_invisible(nfd(remap_confusables(nfd(name)))). */ +typedef unsigned int __bitwise badname_t ; +struct name_entry {struct name_entry *next;
@@ -70,7 +73,7 @@ struct name_entry {xfs_ino_t ino;/* Everything that we don't like about this name. */ -unsigned int badflags; +badname_t badflags;/* Raw dirent name */ size_t namelen;
@@ -93,26 +96,29 @@ struct unicrash {/* Things to complain about in Unicode naming. */ +/* Everything is ok */ +#define UNICRASH_OK ((__force badname_t)0) +/* * Multiple names resolve to the same normalized string and therefore render * identically. */ -#define UNICRASH_NOT_UNIQUE (1 << 0) +#define UNICRASH_NOT_UNIQUE ((__force badname_t)(1U << 0))/* Name contains directional overrides. */ -#define UNICRASH_BIDI_OVERRIDE (1 << 1) +#define UNICRASH_BIDI_OVERRIDE ((__force badname_t)(1U << 1))/* Name mixes left-to-right and right-to-left characters. */ -#define UNICRASH_BIDI_MIXED (1 << 2) +#define UNICRASH_BIDI_MIXED ((__force badname_t)(1U << 2))/* Control characters in name. */ -#define UNICRASH_CONTROL_CHAR (1 << 3) +#define UNICRASH_CONTROL_CHAR ((__force badname_t)(1U << 3))/* Invisible characters. Only a problem if we have collisions. */ -#define UNICRASH_INVISIBLE (1 << 4) +#define UNICRASH_INVISIBLE ((__force badname_t)(1U << 4))/* Multiple names resolve to the same skeleton string. */ -#define UNICRASH_CONFUSABLE (1 << 5) +#define UNICRASH_CONFUSABLE ((__force badname_t)(1U << 5))/* * We only care about validating utf8 collisions if the underlying
@@ -540,7 +546,7 @@ unicrash_complain(struct descr *dsc, const char *what, struct name_entry *entry, - unsigned int badflags, + badname_t badflags, struct name_entry *dup_entry) { char *bad1 = NULL;
@@ -643,7 +649,7 @@ _("Unicode name \"%s\" in %s could be confused with \"%s\"."),* must be skeletonized according to Unicode TR39 to detect names that * could be visually confused with each other. */ -static unsigned int +static badname_t unicrash_add( struct unicrash *uc, struct name_entry **new_entryp,
@@ -653,7 +659,7 @@ unicrash_add(struct name_entry *entry;size_t bucket;xfs_dahash_t hash; -unsigned int badflags = new_entry->badflags; +badname_t badflags = new_entry->badflags;/* Store name in hashtable. */ hash =name_entry_hash (new_entry);
@@ -711,14 +717,14 @@ __unicrash_check_name( {struct name_entry *dup_entry =NULL ;struct name_entry *new_entry =NULL ; -unsigned int badflags; +badname_t badflags;/* If we can't create entry data, just skip it. */ if (!name_entry_create (uc, name, ino, &new_entry))return 0 ; badflags =unicrash_add (uc, &new_entry, &dup_entry); -if (new_entry && badflags) +if (new_entry && badflags !=UNICRASH_OK )unicrash_complain (uc, dsc, namedescr, new_entry, badflags, dup_entry);
Re: [PATCH 09/13] xfs_scrub: type-coerce the UNICRASH_* flags
Looks good:
PATCH 10/13 xfs_scrub: reduce size of struct name_entry
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
libicu doesn't support processing strings longer than 2GB in length, and we never feed the unicrash code a name longer than about 300 bytes. Rearrange the structure to reduce the head structure size from 56 bytes to 44 bytes.
--- scrub/unicrash.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
scrub/unicrash.c +12 -4
@@ -57,18 +57,20 @@* In other words, skel = remove_invisible(nfd(remap_confusables(nfd(name)))). */ -typedef unsigned int __bitwise badname_t ; +typedef uint16_t __bitwise badname_t ;struct name_entry {struct name_entry *next;/* NFKC normalized name */ UChar *normstr; -size_t normstrlen;/* Unicode skeletonized name */ UChar *skelstr; -size_t skelstrlen; + +/* Lengths for normstr and skelstr */ +int32_t normstrlen; +int32_t skelstrlen;xfs_ino_t ino;
@@ -76,7 +78,7 @@ struct name_entry {badname_t badflags;/* Raw dirent name */ -size_t namelen; +uint16_t namelen;char name[0 ]; };#define NAME_ENTRY_SZ (nl) (sizeof(struct name_entry) + 1 + \
@@ -343,6 +345,12 @@ name_entry_create(struct name_entry *new_entry;size_t namelen =strlen (name); +/* should never happen */ +if (namelen >UINT16_MAX ) { +ASSERT (namelen <=UINT16_MAX ); +return false; + } +/* Create new entry */ new_entry =calloc (NAME_ENTRY_SZ (namelen),1 );if (!new_entry)
Re: [PATCH 10/13] xfs_scrub: reduce size of struct name_entry
Looks good:
PATCH 11/13 xfs_scrub: rename struct unicrash.normalizer
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
We're about to introduce a second normalizer, so change the name of the existing one to reflect the algorithm that you'll get if you use it.
--- scrub/unicrash.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
scrub/unicrash.c +4 -4
@@ -87,7 +87,7 @@ struct name_entry {struct unicrash {struct scrub_ctx *ctx;USpoofChecker *spoof; -const UNormalizer2 *normalizer; +const UNormalizer2 *nfkc;bool compare_ino;bool is_only_root_writeable;size_t nr_buckets;
@@ -240,7 +240,7 @@ name_entry_compute_checknames( goto out_unistr;/* Normalize the string. */ - normstrlen =unorm2_normalize (uc->normalizer, unistr, unistrlen,NULL , + normstrlen =unorm2_normalize (uc->nfkc, unistr, unistrlen,NULL ,0 , &uerr);if (uerr !=U_BUFFER_OVERFLOW_ERROR || normstrlen <0 ) goto out_unistr;
@@ -248,7 +248,7 @@ name_entry_compute_checknames( normstr =calloc (normstrlen +1 ,sizeof (UChar));if (!normstr) goto out_unistr; -unorm2_normalize (uc->normalizer, unistr, unistrlen, normstr, normstrlen, +unorm2_normalize (uc->nfkc, unistr, unistrlen, normstr, normstrlen, &uerr);if (U_FAILURE (uerr)) goto out_normstr;
@@ -455,7 +455,7 @@ unicrash_init( p->ctx = ctx; p->nr_buckets = nr_buckets; p->compare_ino = compare_ino; - p->normalizer =unorm2_getNFKCInstance (&uerr); + p->nfkc =unorm2_getNFKCInstance (&uerr);if (U_FAILURE (uerr)) goto out_free; p->spoof =uspoof_open (&uerr);
Re: [PATCH 11/13] xfs_scrub: rename struct unicrash.normalizer
Looks good:
PATCH 12/13 xfs_scrub: report deceptive file extensions
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Earlier this year, ESET revealed that Linux users had been tricked into opening executables containing malware payloads. The trickery came in the form of a malicious zip file containing a filename with the string "job offer․pdf". Note that the filename does *not* denote a real pdf file, since the last four codepoints in the file name are "ONE DOT LEADER", p, d, and f. Not period (ok, FULL STOP), p, d, f like you'd normally expect.
Teach xfs_scrub to look for codepoints that could be confused with a period followed by alphanumerics.
--- scrub/unicrash.c | 215 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 214 insertions(+), 1 deletion(-)
scrub/unicrash.c +214 -1
@@ -88,6 +88,7 @@ struct unicrash {struct scrub_ctx *ctx;USpoofChecker *spoof;const UNormalizer2 *nfkc; +const UNormalizer2 *nfc;bool compare_ino;bool is_only_root_writeable;size_t nr_buckets;
@@ -122,6 +123,12 @@ struct unicrash {/* Multiple names resolve to the same skeleton string. */ #define UNICRASH_CONFUSABLE ((__force badname_t)(1U << 5)) +/* Possible phony file extension. */ +#define UNICRASH_PHONY_EXTENSION ((__force badname_t)(1U << 6)) + +/* FULL STOP (aka period), 0x2E */ +#define UCHAR_PERIOD ((UChar32)'.') +/* * We only care about validating utf8 collisions if the underlying * system configuration says we're using utf8. If the language
@@ -209,6 +216,193 @@ static inline bool is_nonrendering(UChar32 uchr)return false; } +/* +* Decide if this unicode codepoint looks similar enough to a period (".") +* to fool users into thinking that any subsequent alphanumeric sequence is +* the file extension. Most of the fullstop characters do not do this. +* +* $ grep -i 'full stop' UnicodeData.txt +*/ +static inline bool is_fullstop_lookalike (UChar32 uchr) +{ +switch (uchr) { +case 0x0701 :/* syriac supralinear full stop */ +case 0x0702 :/* syriac sublinear full stop */ +case 0x2024 :/* one dot leader */ +case 0xA4F8 :/* lisu letter tone mya ti */ +case 0xFE52 :/* small full stop */ +case 0xFF61 :/* haflwidth ideographic full stop */ +case 0xFF0E :/* fullwidth full stop */ +return true; + } + +return false; +} + +/* How many UChar do we need to fit a full UChar32 codepoint? */ +#define UCHAR_PER_UCHAR32 2 + +/* Format this UChar32 into a UChar buffer. */ +static inline int32_t +uchar32_to_uchar ( +UChar32 uchr, +UChar *buf) +{ +int32_t i =0 ; +bool err = false; + +U16_APPEND (buf, i,UCHAR_PER_UCHAR32 , uchr, err); +if (err) +return 0 ; +return i; +} + +/* Extract a single UChar32 code point from this UChar string. */ +static inline UChar32 +uchar_to_uchar32 ( +UChar *buf, +int32_t buflen) +{ +UChar32 ret; +int32_t i =0 ; + +U16_NEXT (buf, i, buflen, ret); +return ret; +} + +/* +* For characters that are not themselves a full stop (0x2E), let's see if the +* compatibility normalization (NFKC) will turn it into a full stop. If so, +* then this could be the start of a phony file extension. +*/ +static bool +is_period_lookalike ( +struct unicrash *uc, +UChar32 uchr) +{ +UChar uchrstr[UCHAR_PER_UCHAR32 ]; +UChar nfkcstr[UCHAR_PER_UCHAR32 ]; +int32_t uchrstrlen, nfkcstrlen; +UChar32 nfkc_uchr; +UErrorCode uerr =U_ZERO_ERROR ; + +if (uchr ==UCHAR_PERIOD ) +return false; + + uchrstrlen =uchar32_to_uchar (uchr, uchrstr); +if (!uchrstrlen) +return false; + +/* +* Normalize the UChar string to NFKC form, which does all the +* compatibility transformations. +*/ + nfkcstrlen =unorm2_normalize (uc->nfkc, uchrstr, uchrstrlen,NULL , +0 , &uerr); +if (uerr ==U_BUFFER_OVERFLOW_ERROR ) +return false; + + uerr =U_ZERO_ERROR ; +unorm2_normalize (uc->nfkc, uchrstr, uchrstrlen, nfkcstr, nfkcstrlen, + &uerr); +if (U_FAILURE (uerr)) +return false; + + nfkc_uchr =uchar_to_uchar32 (nfkcstr, nfkcstrlen); +return nfkc_uchr ==UCHAR_PERIOD ; +} + +/* +* Detect directory entry names that contain deceptive sequences that look like +* file extensions but are not. This we define as a sequence that begins with +* a code point that renders like a period ("full stop" in unicode parlance) +* but is not actually a period, followed by any number of alphanumeric code +* points or a period, all the way to the end. +* +* The 3cx attack used a zip file containing an executable file named "job +* offer․pdf". Note that the dot mark in the extension is /not/ a period but +* the Unicode codepoint "leader dot". The file was also marked executable +* inside the zip file, which meant that naïve file explorers could inflate +* the file and restore the execute bit. If a user double-clicked on the file, +* the binary would open a decoy pdf while infecting the system. +* +* For this check, we need to normalize with canonical (and not compatibility) +* decomposition, because compatibility mode will turn certain code points +* (e.g. one dot leader, 0x2024) into actual periods (0x2e). The NFC +* composition is not needed after this, so we save some memory by keeping this +* a separate function from name_entry_examine. +*/ +static badname_t +name_entry_phony_extension ( +struct unicrash *uc, +const UChar *unistr, +int32_t unistrlen) +{ +UCharIterator uiter; +UChar *nfcstr; +int32_t nfcstrlen; +UChar32 uchr; +bool maybe_phony_extension = false; +badname_t ret =UNICRASH_OK ; +UErrorCode uerr =U_ZERO_ERROR ; + +/* Normalize with NFC. */ + nfcstrlen =unorm2_normalize (uc->nfc, unistr, unistrlen,NULL , +0 , &uerr); +if (uerr !=U_BUFFER_OVERFLOW_ERROR || nfcstrlen <0 ) +return ret; + uerr =U_ZERO_ERROR ; + nfcstr =calloc (nfcstrlen +1 ,sizeof (UChar)); +if (!nfcstr) +return ret; +unorm2_normalize (uc->nfc, unistr, unistrlen, nfcstr, nfcstrlen, + &uerr); +if (U_FAILURE (uerr)) + goto out_nfcstr; + +/* Examine the NFC normalized string... */ +uiter_setString (&uiter, nfcstr, nfcstrlen); +while ((uchr =uiter_next32 (&uiter)) !=U_SENTINEL ) { +/* +* If this *looks* like, but is not, a full stop (0x2E), this +* could be the start of a phony file extension. +*/ +if (is_period_lookalike (uc, uchr)) { + maybe_phony_extension = true; +continue ; + } + +if (is_fullstop_lookalike (uchr)) { +/* +* The normalizer above should catch most of these +* codepoints that look like periods, but record the +* ones known to have been used in attacks. +*/ + maybe_phony_extension = true; + }else if (uchr ==UCHAR_PERIOD ) { +/* +* Due to the propensity of file explores to obscure +* file extensions in the name of "user friendliness", +* this classifier ignores periods. +*/ + }else { +/* +* File extensions (as far as the author knows) tend +* only to use ascii alphanumerics. +*/ +if (maybe_phony_extension && + !u_isalnum (uchr) && !is_nonrendering (uchr)) + maybe_phony_extension = false; + } + } +if (maybe_phony_extension) + ret |=UNICRASH_PHONY_EXTENSION ; + +out_nfcstr: +free (nfcstr); +return ret; +} +/* * Generate normalized form and skeleton of the name. If this fails, just * forget everything and return false; this is an advisory checker.
@@ -269,6 +463,11 @@ name_entry_compute_checknames( skelstrlen =remove_ignorable (skelstr, skelstrlen); +/* Check for deceptive file extensions in directory entry names. */ +if (entry->ino) + entry->badflags |=name_entry_phony_extension (uc, unistr, + unistrlen); + entry->skelstr = skelstr; entry->skelstrlen = skelstrlen; entry->normstr = normstr;
@@ -365,7 +564,7 @@ name_entry_create(if (!name_entry_compute_checknames (uc, new_entry)) goto out; - new_entry->badflags =name_entry_examine (new_entry); + new_entry->badflags |=name_entry_examine (new_entry); *entry = new_entry;return true;
@@ -456,6 +655,9 @@ unicrash_init( p->nr_buckets = nr_buckets; p->compare_ino = compare_ino; p->nfkc =unorm2_getNFKCInstance (&uerr); +if (U_FAILURE (uerr)) + goto out_free; + p->nfc =unorm2_getNFCInstance (&uerr);if (U_FAILURE (uerr)) goto out_free; p->spoof =uspoof_open (&uerr);
@@ -602,6 +804,17 @@ _("Unicode name \"%s\" in %s could be confused with '%s' due to invisible charac goto out; } +/* +* Fake looking file extensions have tricked Linux users into thinking +* that an executable is actually a pdf. See Lazarus 3cx attack. +*/ +if (badflags &UNICRASH_PHONY_EXTENSION ) { +str_warn (uc->ctx,descr_render (dsc), +_ ("Unicode name \"%s\" in %s contains a possibly deceptive file extension." ), + bad1, what); + goto out; + } +/* * Unfiltered control characters can mess up your terminal and render * invisibly in filechooser UIs.
Re: [PATCH 12/13] xfs_scrub: report deceptive file extensions
Looks good:
PATCH 13/13 xfs_scrub: dump unicode points
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add some debug functions to make it easier to query unicode character properties.
--- scrub/unicrash.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 57 insertions(+), 2 deletions(-)
scrub/unicrash.c +57 -2
@@ -5,6 +5,7 @@*/ #include "xfs.h" #include "xfs_arch.h" +#include "list.h" #include <stdint.h> #include <stdlib.h> #include <dirent.h>
@@ -1001,14 +1002,68 @@ unicrash_check_fs_label( label, 0); } +/* Dump a unicode code point and its properties. */ +static inline void dump_uchar32 (UChar32 c) +{ +UChar uchrstr[UCHAR_PER_UCHAR32 ]; +const char *descr; +char buf[16 ]; +int32_t uchrstrlen, buflen; +UProperty p; +UErrorCode uerr =U_ZERO_ERROR ; + +printf ("Unicode point 0x%x:" , c); + +/* Convert UChar32 to UTF8 representation. */ + uchrstrlen =uchar32_to_uchar (c, uchrstr); +if (!uchrstrlen) +return ; + +u_strToUTF8 (buf,sizeof (buf), &buflen, uchrstr, uchrstrlen, &uerr); +if (!U_FAILURE (uerr) && buflen >0 ) { +int32_t i; + +printf (" \"" ); +for (i =0 ; i < buflen; i++) +printf ("\\x%02x" , buf[i]); +printf ("\"" ); + } +printf ("\n" ); + +for (p =0 ; p <UCHAR_BINARY_LIMIT ; p++) { +int has; + + descr =u_getPropertyName (p,U_LONG_PROPERTY_NAME ); +if (!descr) + descr =u_getPropertyName (p,U_SHORT_PROPERTY_NAME ); + + has =u_hasBinaryProperty (c, p) ?1 :0 ; +if (descr) { +printf (" %s(%u) = %d\n" , descr, p, has); + }else { +printf (" ?(%u) = %d\n" , p, has); + } + } +} +/* Load libicu and initialize it. */ bool unicrash_load (void ) { -UErrorCode uerr =U_ZERO_ERROR ; +char *dbgstr; +UChar32 uchr; +UErrorCode uerr =U_ZERO_ERROR ;u_init (&uerr); -return U_FAILURE (uerr); +if (U_FAILURE (uerr)) +return true; + + dbgstr =getenv ("XFS_SCRUB_DUMP_CHAR" ); +if (dbgstr) { + uchr =strtol (dbgstr,NULL ,0 ); +dump_uchar32 (uchr); + } +return false; }/* Unload libicu once we're done with it. */
Re: [PATCH 13/13] xfs_scrub: dump unicode points
Looks good:
PATCH 4/16 xfs_scrub: move fstrim to a separate phase
In reply to Darrick J. WongHi all,
Back when I originally designed xfs_scrub, all filesystem metadata checks were complete by the end of phase 3, and phase 4 was where all the metadata repairs occurred. On the grounds that the filesystem should be fully consistent by then, I made a call to FITRIM at the end of phase 4 to discard empty space in the filesystem.
Unfortunately, that's no longer the case -- summary counters, link counts, and quota counters are not checked until phase 7. It's not safe to instruct the storage to unmap "empty" areas if we don't know where those empty areas are, so we need to create a phase 8 to trim the fs. While we're at it, make it more obvious that fstrim only gets to run if there are no unfixed corruptions and no other runtime errors have occurred.
Finally, reduce the latency impacts on the rest of the system by breaking up the fstrim work into a loop that targets only 16GB per call. This enables better progress reporting for interactive runs and cgroup based resource constraints for background runs.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-fstrim-phase
---
Commits in this patchset:
* xfs_scrub: move FITRIM to phase 8
* xfs_scrub: ignore phase 8 if the user disabled fstrim
* xfs_scrub: collapse trim_filesystem
* xfs_scrub: fix the work estimation for phase 8
* xfs_scrub: report FITRIM errors properly
* xfs_scrub: don't call FITRIM after runtime errors
* xfs_scrub: don't trim the first agbno of each AG for better performance
* xfs_scrub: improve progress meter for phase 8 fstrimming
--- scrub/Makefile | 1 scrub/phase4.c | 30 +--------- scrub/phase8.c | 152 +++++++++++++++++++++++++++++++++++++++++++++++++++++ scrub/vfs.c | 22 +++++--- scrub/vfs.h | 2 - scrub/xfs_scrub.c | 11 +++- scrub/xfs_scrub.h | 3 + 7 files changed, 184 insertions(+), 37 deletions(-) create mode 100644 scrub/phase8.c
PATCH 1/8 xfs_scrub: move FITRIM to phase 8
From: Darrick J. Wong <[email protected]>
Issuing discards against the filesystem should be the *last* thing that xfs_scrub does, after everything else has been checked, repaired, and found to be clean. If we can't satisfy all those conditions, we have no business telling the storage to discard itself.
--- scrub/Makefile | 1 + scrub/phase4.c | 30 ++---------------------- scrub/phase8.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++ scrub/xfs_scrub.h | 3 ++ 4 files changed, 73 insertions(+), 27 deletions(-) create mode 100644 scrub/phase8.c
scrub/Makefile +1 -0
@@ -68,6 +68,7 @@ phase4.c \ phase5.c \ phase6.c \ phase7.c \ +phase8.c \ progress.c \ read_verify.c \ repair.c \
scrub/phase4.c +3 -27
@@ -227,16 +227,6 @@ repair_everything(return action_list_process (ctx, ctx->fs_repair_list,XRM_FINAL_WARNING ); } -/* Trim the unused areas of the filesystem if the caller asked us to. */ -static void -trim_filesystem ( -struct scrub_ctx *ctx) -{ -if (want_fstrim) -fstrim (ctx); -progress_add (1 ); -} -/* Fix everything that needs fixing. */ int phase4_func(
@@ -248,7 +238,7 @@ phase4_func(if (action_list_empty (ctx->fs_repair_list) &&action_list_empty (ctx->file_repair_list)) - goto maybe_trim; +return 0 ;/* * Check the resource usage counters early. Normally we do this during
@@ -281,20 +271,7 @@ phase4_func(if (ret)return ret; - ret =repair_everything (ctx); -if (ret) -return ret; - -/* -* If errors remain on the filesystem, do not trim anything. We don't -* have any threads running, so it's ok to skip the ctx lock here. -*/ -if (ctx->corruptions_found || ctx->unfixable_errors !=0 ) -return 0 ; - -maybe_trim: -trim_filesystem (ctx); -return 0 ; +return repair_everything (ctx); }/* Estimate how much work we're going to do. */
@@ -307,10 +284,9 @@ phase4_estimate( {unsigned long long need_fixing; -/* Everything on the repair list plus FSTRIM. */ +/* Everything on the repair lis. */ need_fixing =action_list_length (ctx->fs_repair_list) +action_list_length (ctx->file_repair_list); - need_fixing++; *items = need_fixing; *nr_threads =scrub_nproc (ctx) +1 ;
scrub/phase8.c new file +66 -0
66 lines not on this page · raw message
scrub/xfs_scrub.h +3 -0
@@ -98,6 +98,7 @@ int phase4_func(struct scrub_ctx *ctx);int phase5_func (struct scrub_ctx *ctx);int phase6_func (struct scrub_ctx *ctx);int phase7_func (struct scrub_ctx *ctx); +int phase8_func (struct scrub_ctx *ctx);/* Progress estimator functions */ unsigned int scrub_estimate_ag_work (struct scrub_ctx *ctx);
@@ -112,5 +113,7 @@ int phase5_estimate(struct scrub_ctx *ctx, uint64_t *items, unsigned int *nr_threads, int *rshift);int phase6_estimate (struct scrub_ctx *ctx,uint64_t *items,unsigned int *nr_threads,int *rshift); +int phase8_estimate (struct scrub_ctx *ctx,uint64_t *items, +unsigned int *nr_threads,int *rshift);#endif /* XFS_SCRUB_XFS_SCRUB_H_ */
Re: [PATCH 1/8] xfs_scrub: move FITRIM to phase 8
Looks good:
PATCH 2/8 xfs_scrub: ignore phase 8 if the user disabled fstrim
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If the user told us to skip trimming the filesystem, don't run the phase at all.
--- scrub/xfs_scrub.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
scrub/xfs_scrub.c +10 -1
@@ -249,6 +249,7 @@ struct phase_rusage {/* Operations for each phase. */ #define DATASCAN_DUMMY_FN ((void *)1)#define REPAIR_DUMMY_FN ((void *)2) +#define FSTRIM_DUMMY_FN ((void *)3)struct phase_ops {char *descr;int (*fn)(struct scrub_ctx *ctx);
@@ -429,6 +430,11 @@ run_scrub_phases( .fn = phase7_func, .must_run = true, }, + { + .descr = _("Trim filesystem storage."), + .fn = FSTRIM_DUMMY_FN, + .estimate_work = phase8_estimate, + }, { NULL },
@@ -449,6 +455,8 @@ run_scrub_phases(/* Turn on certain phases if user said to. */ if (sp->fn ==DATASCAN_DUMMY_FN && scrub_data) { sp->fn = phase6_func; + }else if (sp->fn ==FSTRIM_DUMMY_FN && want_fstrim) { + sp->fn = phase8_func; }else if (sp->fn ==REPAIR_DUMMY_FN && ctx->mode ==SCRUB_MODE_REPAIR ) { sp->descr =_ ("Repair filesystem." );
@@ -458,7 +466,8 @@ run_scrub_phases(/* Skip certain phases unless they're turned on. */ if (sp->fn ==REPAIR_DUMMY_FN || - sp->fn ==DATASCAN_DUMMY_FN ) + sp->fn ==DATASCAN_DUMMY_FN || + sp->fn ==FSTRIM_DUMMY_FN )continue ;/* Allow debug users to force a particular phase. */
Re: [PATCH 2/8] xfs_scrub: ignore phase 8 if the user disabled fstrim
Looks good:
PATCH 3/8 xfs_scrub: collapse trim_filesystem
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Collapse this two-line helper into the main function since it's trivial.
--- scrub/phase8.c | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-)
scrub/phase8.c +2 -10
@@ -21,15 +21,6 @@/* Phase 8: Trim filesystem. */ -/* Trim the unused areas of the filesystem if the caller asked us to. */ -static void -trim_filesystem ( -struct scrub_ctx *ctx) -{ -fstrim (ctx); -progress_add (1 ); -} -/* Trim the filesystem, if desired. */ int phase8_func(
@@ -47,7 +38,8 @@ phase8_func(return 0 ; maybe_trim: -trim_filesystem (ctx); +fstrim (ctx); +progress_add (1 );return 0 ; }
Re: [PATCH 3/8] xfs_scrub: collapse trim_filesystem
Looks good:
PATCH 4/8 xfs_scrub: fix the work estimation for phase 8
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If there are latent errors on the filesystem, we aren't going to do any work during phase 8 and it makes no sense to add that into the work estimate for the progress bar.
--- scrub/phase8.c | 36 ++++++++++++++++++++++++++---------- 1 file changed, 26 insertions(+), 10 deletions(-)
scrub/phase8.c +26 -10
@@ -21,23 +21,35 @@/* Phase 8: Trim filesystem. */ -/* Trim the filesystem, if desired. */ -int -phase8_func ( +static inline bool +fstrim_ok (struct scrub_ctx *ctx) { -if (action_list_empty (ctx->fs_repair_list) && -action_list_empty (ctx->file_repair_list)) - goto maybe_trim; -/* * If errors remain on the filesystem, do not trim anything. We don't * have any threads running, so it's ok to skip the ctx lock here. */ -if (ctx->corruptions_found || ctx->unfixable_errors !=0 ) +if (!action_list_empty (ctx->fs_repair_list)) +return false; +if (!action_list_empty (ctx->file_repair_list)) +return false; + +if (ctx->corruptions_found !=0 ) +return false; +if (ctx->unfixable_errors !=0 ) +return false; + +return true; +} + +/* Trim the filesystem, if desired. */ +int +phase8_func ( +struct scrub_ctx *ctx) +{ +if (!fstrim_ok (ctx))return 0 ; -maybe_trim:fstrim (ctx);progress_add (1 );return 0 ;
@@ -51,7 +63,11 @@ phase8_estimate(unsigned int *nr_threads, int *rshift) { - *items =1 ; + *items =0 ; + +if (fstrim_ok (ctx)) + *items =1 ; + *nr_threads =1 ; *rshift =0 ;return 0 ;
Re: [PATCH 4/8] xfs_scrub: fix the work estimation for phase 8
Looks good:
PATCH 5/8 xfs_scrub: report FITRIM errors properly
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the error reporting for the FITRIM ioctl out of vfs.c and into phase8.c. This makes it so that IO errors encountered during trim are counted as runtime errors instead of being dropped silently.
--- scrub/phase8.c | 12 +++++++++++- scrub/vfs.c | 12 +++++++----- scrub/vfs.h | 2 +- 3 files changed, 19 insertions(+), 7 deletions(-)
scrub/phase8.c +11 -1
@@ -47,10 +47,20 @@ intphase8_func ( struct scrub_ctx *ctx) { +int error; +if (!fstrim_ok (ctx))return 0 ; -fstrim (ctx); + error =fstrim (ctx); +if (error ==EOPNOTSUPP ) +return 0 ; + +if (error) { +str_liberror (ctx, error,_ ("fstrim" )); +return error; + } +progress_add (1 );return 0 ; }
scrub/vfs.c +7 -5
@@ -296,15 +296,17 @@ struct fstrim_range {#endif /* Call FITRIM to trim all the unused space in a filesystem. */ -void +int fstrim (struct scrub_ctx *ctx) {struct fstrim_range range = {0 }; -int error; range.len =ULLONG_MAX ; - error =ioctl (ctx->mnt.fd,FITRIM , &range); -if (error && errno !=EOPNOTSUPP && errno !=ENOTTY ) -perror (_ ("fstrim" )); +if (ioctl (ctx->mnt.fd,FITRIM , &range) ==0 ) +return 0 ; +if (errno ==EOPNOTSUPP || errno ==ENOTTY ) +return EOPNOTSUPP ; + +return errno; }
scrub/vfs.h +1 -1
@@ -24,6 +24,6 @@ typedef int (*scan_fs_tree_dirent_fn)(struct scrub_ctx *, const char *,int scan_fs_tree (struct scrub_ctx *ctx,scan_fs_tree_dir_fn dir_fn,scan_fs_tree_dirent_fn dirent_fn,void *arg); -void fstrim (struct scrub_ctx *ctx); +int fstrim (struct scrub_ctx *ctx);#endif /* XFS_SCRUB_VFS_H_ */
Re: [PATCH 5/8] xfs_scrub: report FITRIM errors properly
Looks good:
PATCH 6/8 xfs_scrub: don't call FITRIM after runtime errors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Don't call FITRIM if there have been runtime errors -- we don't want to touch anything after any kind of unfixable problem.
--- scrub/phase8.c | 3 +++ 1 file changed, 3 insertions(+)
scrub/phase8.c +3 -0
@@ -39,6 +39,9 @@ fstrim_ok(if (ctx->unfixable_errors !=0 )return false; +if (ctx->runtime_errors !=0 ) +return false; +return true; }
Re: [PATCH 6/8] xfs_scrub: don't call FITRIM after runtime errors
Looks good:
PATCH 7/8 xfs_scrub: don't trim the first agbno of each AG for better performance
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
On a 10TB filesystem where the free space in each AG is heavily fragmented, I noticed some very high runtimes on a FITRIM call for the entire filesystem. xfs_scrub likes to report progress information on each phase of the scrub, which means that a strace for the entire filesystem:
ioctl(3, FITRIM, {start=0x0, len=10995116277760, minlen=0}) = 0 <686.209839>
shows that scrub is uncommunicative for the entire duration. Reducing the size of the FITRIM requests to a single AG at a time produces lower times for each individual call, but even this isn't quite acceptable, because the time between progress reports are still very high:
Strace for the first 4x 1TB AGs looks like (2):ioctl(3, FITRIM, {start=0x0, len=1099511627776, minlen=0}) = 0 <68.352033> ioctl(3, FITRIM, {start=0x10000000000, len=1099511627776, minlen=0}) = 0 <68.760323> ioctl(3, FITRIM, {start=0x20000000000, len=1099511627776, minlen=0}) = 0 <67.235226> ioctl(3, FITRIM, {start=0x30000000000, len=1099511627776, minlen=0}) = 0 <69.465744>
I then had the idea to limit the length parameter of each call to a smallish amount (~11GB) so that we could report progress relatively quickly, but much to my surprise, each FITRIM call still took ~68 seconds!
Unfortunately, the by-length fstrim implementation handles this poorly because it walks the entire free space by length index (cntbt), which is a very inefficient way to walk a subset of an AG.
Therefore, we created a second implementation that will walk the bnobt and perform the trims in block number order. This implementation avoids the worst problems of the original code, though it lacks the desirable attribute of freeing the biggest chunks first.
On the other hand, this second implementation will be much easier to constrain the system call latency, and makes it much easier to report fstrim progress to anyone who's running xfs_scrub. Skip the first block of each AG to ensure that we get the sub-AG algorithm.
--- scrub/phase8.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++--------- scrub/vfs.c | 10 ++++++--- scrub/vfs.h | 2 +- 3 files changed, 62 insertions(+), 14 deletions(-)
scrub/phase8.c +54 -10
@@ -45,29 +45,73 @@ fstrim_ok(return true; } -/* Trim the filesystem, if desired. */ -int -phase8_func ( -struct scrub_ctx *ctx) +/* Trim a certain range of the filesystem. */ +static int +fstrim_fsblocks ( +struct scrub_ctx *ctx, +uint64_t start_fsb, +uint64_t fsbcount) { +uint64_t start =cvt_off_fsb_to_b (&ctx->mnt, start_fsb); +uint64_t len =cvt_off_fsb_to_b (&ctx->mnt, fsbcount);int error; -if (!fstrim_ok (ctx)) -return 0 ; - - error =fstrim (ctx); + error =fstrim (ctx, start, len);if (error ==EOPNOTSUPP )return 0 ; -if (error) { -str_liberror (ctx, error,_ ("fstrim" )); +char descr[DESCR_BUFSZ ]; + +snprintf (descr,sizeof (descr) -1 , +_ ("fstrim start 0x%llx len 0x%llx" ), + (unsigned long long )start, + (unsigned long long )len); +str_liberror (ctx, error, descr);return error; } +return 0 ; +} + +/* Trim each AG on the data device. */ +static int +fstrim_datadev ( +struct scrub_ctx *ctx) +{ +struct xfs_fsop_geom *geo = &ctx->mnt.fsgeom; +uint64_t fsbno; +int error; + +for (fsbno =0 ; fsbno < geo->datablocks; fsbno += geo->agblocks) { +uint64_t fsbcount; + +/* +* Skip the first block of each AG to ensure that we get the +* partial-AG discard implementation. This means that we can +* report trim progress to userspace in units smaller than +* entire AGs. +*/ + fsbcount =min (geo->datablocks - (fsbno +1 ), geo->agblocks -1 ); + error =fstrim_fsblocks (ctx, fsbno +1 , fsbcount); +if (error) +return error; + } +progress_add (1 );return 0 ; } +/* Trim the filesystem, if desired. */ +int +phase8_func ( +struct scrub_ctx *ctx) +{ +if (!fstrim_ok (ctx)) +return 0 ; + +return fstrim_datadev (ctx); +} +/* Estimate how much work we're going to do. */ int phase8_estimate(
scrub/vfs.c +7 -3
@@ -298,11 +298,15 @@ struct fstrim_range {/* Call FITRIM to trim all the unused space in a filesystem. */ int fstrim ( -struct scrub_ctx *ctx) +struct scrub_ctx *ctx, +uint64_t start, +uint64_t len) { -struct fstrim_range range = {0 }; +struct fstrim_range range = { + .start = start, + .len = len, + }; - range.len =ULLONG_MAX ;if (ioctl (ctx->mnt.fd,FITRIM , &range) ==0 )return 0 ;if (errno ==EOPNOTSUPP || errno ==ENOTTY )
scrub/vfs.h +1 -1
@@ -24,6 +24,6 @@ typedef int (*scan_fs_tree_dirent_fn)(struct scrub_ctx *, const char *,int scan_fs_tree (struct scrub_ctx *ctx,scan_fs_tree_dir_fn dir_fn,scan_fs_tree_dirent_fn dirent_fn,void *arg); -int fstrim (struct scrub_ctx *ctx); +int fstrim (struct scrub_ctx *ctx,uint64_t start,uint64_t len);#endif /* XFS_SCRUB_VFS_H_ */
Re: [PATCH 7/8] xfs_scrub: don't trim the first agbno of each AG for better performance
Quoted 9 lines · Darrick J. Wong
Therefore, we created a second implementation that will walk the bnobt and perform the trims in block number order. This implementation avoids the worst problems of the original code, though it lacks the desirable attribute of freeing the biggest chunks first.
On the other hand, this second implementation will be much easier to constrain the system call latency, and makes it much easier to report fstrim progress to anyone who's running
xfs_scrub. Skip the first block of each AG to ensure that we get the sub-AG algorithm.
I completely fail to understand how skipping the first block improves performance and is otherwise a good idea. What am I missing?
Re: [PATCH 7/8] xfs_scrub: don't trim the first agbno of each AG for better performance
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Therefore, we created a second implementation that will walk the bnobt and perform the trims in block number order. This implementation avoids the worst problems of the original code, though it lacks the desirable attribute of freeing the biggest chunks first.
Quoted 7 lines
Quoted 4 lines
On the other hand, this second implementation will be much easier to constrain the system call latency, and makes it much easier to report fstrim progress to anyone who's running
xfs_scrub. Skip the first block of each AG to ensure that we get the sub-AG algorithm.I completely fail to understand how skipping the first block improves performance and is otherwise a good idea. What am I missing?
Actually, I think this patch doesn't have a good reason to exist on its own anymore. The goal of this patch and the next one is to improve responsiveness to signals and smoothness of the progress bar by reducing the number of bytes per FITRIM call, but I think limiting that to 11GB per call is sufficient without the "skip the first block" games.
Those games once was the magic method for getting the kernel to use the by-block discard algorithm instead of the by-length algorithm, but most of the deficiencies in both algorithsm have been fixed now.
So in the end the only reason for this patch to continue existing is so that we only issue one log force and lock one AGF per FITRIM call. The next patch exists to constrain latencies.
I think I'll combine these two patches into a single patch that avoids having FITRIM requests cross AGs and breaks the requests into 11G chunks to improve latency.
--D
PATCH 7/8 xfs_scrub: improve responsiveness while trimming the filesystem
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
On a 10TB filesystem where the free space in each AG is heavily fragmented, I noticed some very high runtimes on a FITRIM call for the entire filesystem. xfs_scrub likes to report progress information on each phase of the scrub, which means that a strace for the entire filesystem:
ioctl(3, FITRIM, {start=0x0, len=10995116277760, minlen=0}) = 0 <686.209839>
shows that scrub is uncommunicative for the entire duration. We can't report any progress for the duration of the call, and the program is not responsive to signals. Reducing the size of the FITRIM requests to a single AG at a time produces lower times for each individual call, but even this isn't quite acceptable, because the time between progress reports are still very high:
Strace for the first 4x 1TB AGs looks like (2):ioctl(3, FITRIM, {start=0x0, len=1099511627776, minlen=0}) = 0 <68.352033> ioctl(3, FITRIM, {start=0x10000000000, len=1099511627776, minlen=0}) = 0 <68.760323> ioctl(3, FITRIM, {start=0x20000000000, len=1099511627776, minlen=0}) = 0 <67.235226> ioctl(3, FITRIM, {start=0x30000000000, len=1099511627776, minlen=0}) = 0 <69.465744>
I then had the idea to limit the length parameter of each call to a smallish amount (~11GB) so that we could report progress relatively quickly, but much to my surprise, each FITRIM call still took ~68 seconds!
Unfortunately, the by-length fstrim implementation handles this poorly because it walks the entire free space by length index (cntbt), which is a very inefficient way to walk a subset of an AG when the free space is fragmented.
To fix that, I created a second implementation in the kernel that will walk the bnobt and perform the trims in block number order. This algorithm constrains the amount of btree scanning to something resembling the range passed in, which reduces the amount of time it takes to respond to a signal.
Therefore, break up the FITRIM calls so they don't scan more than 11GB of space at a time. Break the calls up by AG so that each call only has to take one AGF per call, because each AG that we traverse causes a log force.
--- scrub/phase8.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++---------- scrub/vfs.c | 10 ++++- scrub/vfs.h | 2 + 3 files changed, 91 insertions(+), 23 deletions(-)
scrub/phase8.c +83 -19
@@ -45,27 +45,90 @@ fstrim_ok(return true; } +/* +* Limit the amount of fstrim scanning that we let the kernel do in a single +* call so that we can implement decent progress reporting and CPU resource +* control. Pick a prime number of gigabytes for interest. +*/ +#define FSTRIM_MAX_BYTES (11ULL << 30) + +/* Trim a certain range of the filesystem. */ +static int +fstrim_fsblocks ( +struct scrub_ctx *ctx, +uint64_t start_fsb, +uint64_t fsbcount) +{ +uint64_t start =cvt_off_fsb_to_b (&ctx->mnt, start_fsb); +uint64_t len =cvt_off_fsb_to_b (&ctx->mnt, fsbcount); +int error; + +while (len >0 ) { +uint64_t run; + + run =min (len,FSTRIM_MAX_BYTES ); + + error =fstrim (ctx, start, run); +if (error ==EOPNOTSUPP ) { +/* Pretend we finished all the work. */ +progress_add (len); +return 0 ; + } +if (error) { +char descr[DESCR_BUFSZ ]; + +snprintf (descr,sizeof (descr) -1 , +_ ("fstrim start 0x%llx run 0x%llx" ), + (unsigned long long )start, + (unsigned long long )run); +str_liberror (ctx, error, descr); +return error; + } + +progress_add (run); + len -= run; + start += run; + } + +return 0 ; +} + +/* Trim each AG on the data device. */ +static int +fstrim_datadev ( +struct scrub_ctx *ctx) +{ +struct xfs_fsop_geom *geo = &ctx->mnt.fsgeom; +uint64_t fsbno; +int error; + +for (fsbno =0 ; fsbno < geo->datablocks; fsbno += geo->agblocks) { +uint64_t fsbcount; + +/* +* Make sure that trim calls do not cross AG boundaries so that +* the kernel only performs one log force (and takes one AGF +* lock) per call. +*/ +progress_add (geo->blocksize); + fsbcount =min (geo->datablocks - fsbno, geo->agblocks); + error =fstrim_fsblocks (ctx, fsbno, fsbcount); +if (error) +return error; + } + +return 0 ; +} +/* Trim the filesystem, if desired. */ int phase8_func (struct scrub_ctx *ctx) { -int error; -if (!fstrim_ok (ctx))return 0 ; - error =fstrim (ctx); -if (error ==EOPNOTSUPP ) -return 0 ; - -if (error) { -str_liberror (ctx, error,_ ("fstrim" )); -return error; - } - -progress_add (1 ); -return 0 ; +return fstrim_datadev (ctx); }/* Estimate how much work we're going to do. */
@@ -76,12 +139,13 @@ phase8_estimate(unsigned int *nr_threads, int *rshift) { - *items =0 ; - -if (fstrim_ok (ctx)) - *items =1 ; - + if (fstrim_ok(ctx)) { + *items =cvt_off_fsb_to_b (&ctx->mnt, + ctx->mnt.fsgeom.datablocks); + } else { + *items =0 ; + } *nr_threads =1 ; - *rshift =0 ; + *rshift =30 ;/* GiB */ return 0 ; }
scrub/vfs.c +7 -3
@@ -298,11 +298,15 @@ struct fstrim_range {/* Call FITRIM to trim all the unused space in a filesystem. */ int fstrim ( -struct scrub_ctx *ctx) +struct scrub_ctx *ctx, +uint64_t start, +uint64_t len) { -struct fstrim_range range = {0 }; +struct fstrim_range range = { + .start = start, + .len = len, + }; - range.len =ULLONG_MAX ;if (ioctl (ctx->mnt.fd,FITRIM , &range) ==0 )return 0 ;if (errno ==EOPNOTSUPP || errno ==ENOTTY )
scrub/vfs.h +1 -1
@@ -24,6 +24,6 @@ typedef int (*scan_fs_tree_dirent_fn)(struct scrub_ctx *, const char *,int scan_fs_tree (struct scrub_ctx *ctx,scan_fs_tree_dir_fn dir_fn,scan_fs_tree_dirent_fn dirent_fn,void *arg); -int fstrim (struct scrub_ctx *ctx); +int fstrim (struct scrub_ctx *ctx,uint64_t start,uint64_t len);#endif /* XFS_SCRUB_VFS_H_ */
Re: [PATCH v30.7.1 7/8] xfs_scrub: improve responsiveness while trimming the filesystem
Quoted 4 lines · Darrick J. Wong
I then had the idea to limit the length parameter of each call to a smallish amount (~11GB) so that we could report progress relatively quickly, but much to my surprise, each FITRIM call still took ~68 seconds!
Where do those magic 11GB come from?
Quoted 4 lines
+/*
+ * Limit the amount of fstrim scanning that we let the kernel do in a single
+ * call so that we can implement decent progress reporting and CPU resource
+ * control. Pick a prime number of gigabytes for interest.
... this explains it somehow, but not really :)
The code itself looks fine, so with a better explanation or more round number:
Re: [PATCH v30.7.1 7/8] xfs_scrub: improve responsiveness while trimming the filesystem
Quoted 6 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
I then had the idea to limit the length parameter of each call to a smallish amount (~11GB) so that we could report progress relatively quickly, but much to my surprise, each FITRIM call still took ~68 seconds!
Quoted 8 lines
Where do those magic 11GB come from?
Quoted 4 lines
+/*
+ * Limit the amount of fstrim scanning that we let the kernel do in a single
+ * call so that we can implement decent progress reporting and CPU resource
+ * control. Pick a prime number of gigabytes for interest.... this explains it somehow, but not really :)
It's entirely arbitrary -- big enough to exceed MAXEXTLEN*4k, rounded up to the next prime number of gigabytes.
Quoted 4 lines
The code itself looks fine, so with a better explanation or more round number:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 8/8 xfs_scrub: improve progress meter for phase 8 fstrimming
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, progress reporting in phase 8 is awful, because we stall at 0% until jumping to 100%. Since we're now performing sub-AG fstrim calls to limit the latency impacts to the rest of the system, we might as well limit the FSTRIM scan size so that we can report status updates to the user more regularly. Doing so also facilitates CPU usage control during phase 8.
--- scrub/phase8.c | 59 ++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 40 insertions(+), 19 deletions(-)
scrub/phase8.c +40 -19
@@ -45,6 +45,13 @@ fstrim_ok(return true; } +/* +* Limit the amount of fstrim scanning that we let the kernel do in a single +* call so that we can implement decent progress reporting and CPU resource +* control. Pick a prime number of gigabytes for interest. +*/ +#define FSTRIM_MAX_BYTES (11ULL << 30) +/* Trim a certain range of the filesystem. */ static int fstrim_fsblocks(
@@ -56,18 +63,31 @@ fstrim_fsblocks(uint64_t len =cvt_off_fsb_to_b (&ctx->mnt, fsbcount);int error; - error =fstrim (ctx, start, len); -if (error ==EOPNOTSUPP ) -return 0 ; -if (error) { -char descr[DESCR_BUFSZ ]; - -snprintf (descr,sizeof (descr) -1 , -_ ("fstrim start 0x%llx len 0x%llx" ), - (unsigned long long )start, - (unsigned long long )len); -str_liberror (ctx, error, descr); -return error; +while (len >0 ) { +uint64_t run; + + run =min (len,FSTRIM_MAX_BYTES ); + + error =fstrim (ctx, start, run); +if (error ==EOPNOTSUPP ) { +/* Pretend we finished all the work. */ +progress_add (len); +return 0 ; + } +if (error) { +char descr[DESCR_BUFSZ ]; + +snprintf (descr,sizeof (descr) -1 , +_ ("fstrim start 0x%llx run 0x%llx" ), + (unsigned long long )start, + (unsigned long long )run); +str_liberror (ctx, error, descr); +return error; + } + +progress_add (run); + len -= run; + start += run; }return 0 ;
@@ -91,13 +111,13 @@ fstrim_datadev(* report trim progress to userspace in units smaller than * entire AGs. */ +progress_add (geo->blocksize); fsbcount =min (geo->datablocks - (fsbno +1 ), geo->agblocks -1 ); error =fstrim_fsblocks (ctx, fsbno +1 , fsbcount);if (error)return error; } -progress_add (1 );return 0 ; }
@@ -120,12 +140,13 @@ phase8_estimate(unsigned int *nr_threads, int *rshift) { - *items =0 ; - -if (fstrim_ok (ctx)) - *items =1 ; - + if (fstrim_ok(ctx)) { + *items =cvt_off_fsb_to_b (&ctx->mnt, + ctx->mnt.fsgeom.datablocks); + } else { + *items =0 ; + } *nr_threads =1 ; - *rshift =0 ; + *rshift =30 ;/* GiB */ return 0 ; }
PATCH 5/16 xfs_scrub: use free space histograms to reduce fstrim runtime
In reply to Darrick J. WongHi all,
This patchset dramatically reduces the runtime of the FITRIM calls made during phase 8 of xfs_scrub. It turns out that phase 8 can really get bogged down if the free space contains a large number of very small extents. In these cases, the runtime can increase by an order of magnitude to free less than 1% of the free space. This is not worth the time, since we're spending a lot of time to do very little work. The FITRIM ioctl allows us to specify a minimum extent length, so we can use statistical methods to compute a minlen parameter.
It turns out xfs_db/spaceman already have the code needed to create histograms of free space extent lengths. We add the ability to compute a CDF of the extent lengths, which make it easy to pick a minimum length corresponding to 99% of the free space. In most cases, this results in dramatic reductions in phase 8 runtime. Hence, move the histogram code to libfrog, and wire up xfs_scrub, since phase 7 already walks the fsmap.
We also add a new -o suboption to xfs_scrub so that people who /do/ want to examine every free extent can do so.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-fstrim-minlen-freesp-histogram
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=scrub-fstrim-minlen-freesp-histogram
---
Commits in this patchset:
* libfrog: hoist free space histogram code
* libfrog: print wider columns for free space histogram
* libfrog: print cdf of free space buckets
* xfs_scrub: don't close stdout when closing the progress bar
* xfs_scrub: remove pointless spacemap.c arguments
* xfs_scrub: collect free space histograms during phase 7
* xfs_scrub: tune fstrim minlen parameter based on free space histograms
--- db/freesp.c | 83 +++------------- libfrog/Makefile | 2 libfrog/histogram.c | 252 ++++++++++++++++++++++++++++++++++++++++++++++++++ libfrog/histogram.h | 54 +++++++++++ man/man8/xfs_scrub.8 | 16 +++ scrub/phase7.c | 47 +++++++++ scrub/phase8.c | 75 ++++++++++++++- scrub/spacemap.c | 11 +- scrub/vfs.c | 4 + scrub/vfs.h | 2 scrub/xfs_scrub.c | 45 +++++++++ scrub/xfs_scrub.h | 16 +++ spaceman/freesp.c | 93 +++++------------- 13 files changed, 544 insertions(+), 156 deletions(-) create mode 100644 libfrog/histogram.c create mode 100644 libfrog/histogram.h
PATCH 1/7 libfrog: hoist free space histogram code
From: Darrick J. Wong <[email protected]>
Combine the two free space histograms in xfs_db and xfs_spaceman into a single implementation.
--- db/freesp.c | 83 +++++-------------------------- libfrog/Makefile | 2 + libfrog/histogram.c | 135 +++++++++++++++++++++++++++++++++++++++++++++++++++ libfrog/histogram.h | 50 +++++++++++++++++++ spaceman/freesp.c | 93 +++++++++-------------------------- 5 files changed, 225 insertions(+), 138 deletions(-) create mode 100644 libfrog/histogram.c create mode 100644 libfrog/histogram.h
db/freesp.c +14 -69
@@ -12,14 +12,7 @@#include "output.h" #include "init.h" #include "malloc.h" - -typedef struct histent -{ -int low; -int high; -long long count; -long long blocks; -}histent_t ; +#include "libfrog/histogram.h" static void addhistent (int h); static void addtohist(xfs_agnumber_t agno, xfs_agblock_t agbno,
@@ -46,13 +39,10 @@ static int alignment;static int countflag;static int dumpflag;static int equalsize; -static histent_t *hist; -static int histcount; +static struct histogram freesp_hist;static int multsize;static int seen1;static int summaryflag; -static long long totblocks; -static long long totexts;static const cmdinfo_t freesp_cmd = {"freesp" ,NULL , freesp_f,0 ,-1 ,0 ,
@@ -93,18 +83,13 @@ freesp_f(if (inaglist (agno))scan_ag (agno); } -if (histcount) +if (hist_buckets (&freesp_hist))printhist (); -if (summaryflag) { -dbprintf (_ ("total free extents %lld\n" ), totexts); -dbprintf (_ ("total free blocks %lld\n" ), totblocks); -dbprintf (_ ("average free extent size %g\n" ), - (double )totblocks / (double )totexts); - } +if (summaryflag) +hist_summarize (&freesp_hist);if (aglist)xfree (aglist); -if (hist) -xfree (hist); +hist_free (&freesp_hist);return 0 ; }
@@ -132,10 +117,9 @@ init(int speced =0 ; agcount = countflag = dumpflag = equalsize = multsize = optind =0 ; - histcount = seen1 = summaryflag =0 ; - totblocks = totexts =0 ; + seen1 = summaryflag =0 ; aglist =NULL ; - hist =NULL ; +while ((c =getopt (argc, argv,"A:a:bcde:h:m:s" )) !=EOF ) {switch (c) {case 'A' :
@@ -163,7 +147,7 @@ init( speced =1 ;break ;case 'h' : -if (speced && !histcount) +if (speced &&hist_buckets (&freesp_hist) ==0 )return usage ();addhistent (atoi (optarg)); speced =1 ;
@@ -339,14 +323,7 @@ static voidaddhistent ( int h) { - hist =xrealloc (hist, (histcount +1 ) *sizeof (*hist)); -if (h ==0 ) - h =1 ; - hist[histcount].low = h; - hist[histcount].count = hist[histcount].blocks =0 ; - histcount++; -if (h ==1 ) - seen1 =1 ; +hist_add_bucket (&freesp_hist, h); } static void
@@ -355,30 +332,12 @@ addtohist( xfs_agblock_t agbno, xfs_extlen_t len) { - int i; -if (alignment && (XFS_AGB_TO_FSB (mp,agno,agbno) % alignment))return ;if (dumpflag)dbprintf ("%8d %8d %8d\n" , agno, agbno, len); - totexts++; - totblocks += len; -for (i =0 ; i < histcount; i++) { -if (hist[i].high >= len) { - hist[i].count++; - hist[i].blocks += len; -break ; - } - } -} - -static int -hcmp ( -const void *a, -const void *b) -{ -return ((histent_t *)a)->low - ((histent_t *)b)->low; +hist_add (&freesp_hist, len); } static void
@@ -387,6 +346,7 @@ histinit( {int i; +hist_init (&freesp_hist);if (equalsize) {for (i =1 ; i < maxlen; i += equalsize)addhistent (i);
@@ -396,27 +356,12 @@ histinit( }else {if (!seen1)addhistent (1 ); -qsort (hist, histcount,sizeof (*hist), hcmp); - } -for (i =0 ; i < histcount; i++) { -if (i < histcount -1 ) - hist[i].high = hist[i +1 ].low -1 ; -else - hist[i].high = maxlen; } +hist_prepare (&freesp_hist, maxlen); }static void printhist (void ) { -int i; - -dbprintf ("%7s %7s %7s %7s %6s\n" , -_ ("from" ),_ ("to" ),_ ("extents" ),_ ("blocks" ),_ ("pct" )); -for (i =0 ; i < histcount; i++) { -if (hist[i].count) -dbprintf ("%7d %7d %7lld %7lld %6.2f\n" , hist[i].low, - hist[i].high, hist[i].count, hist[i].blocks, - hist[i].blocks *100.0 / totblocks); - } +hist_print (&freesp_hist); }
libfrog/Makefile +2 -0
@@ -20,6 +20,7 @@ convert.c \ crc32.c \ file_exchange.c \ fsgeom.c \ +histogram.c \ list_sort.c \ linux.c \ logging.c \
@@ -45,6 +46,7 @@ dahashselftest.h \ div64.h \ file_exchange.h \ fsgeom.h \ +histogram.h \ logging.h \ paths.h \ projects.h \
libfrog/histogram.c new file +135 -0
135 lines not on this page · raw message
libfrog/histogram.h new file +50 -0
50 lines not on this page · raw message
spaceman/freesp.c +24 -69
170 lines not on this page · raw message
Re: [PATCH 1/7] libfrog: hoist free space histogram code
Review
Quoted 2 lines
(quoted diff) +2
-0+struct histent +{
The braces goes to the previous line for our normal coding style.
Also the naming with histend/histogram the naming seems a bit too generic for something very block specific. Should the naming be adjusted a bit?
Re: [PATCH 1/7] libfrog: hoist free space histogram code
Quoted 8 lines · Christoph Hellwig
Review
Quoted 2 lines
(quoted diff) +2
-0+struct histent +{The braces goes to the previous line for our normal coding style.
Also the naming with histend/histogram the naming seems a bit too generic for something very block specific. Should the naming be adjusted a bit?
Hmm. Either we prefix everything with space, e.g. "struct space_histogram" and "int spacehist_add(...)"...
Or change "blocks" to "value" and "extents" to "observations":
struct histent
{
/* Low and high size of this bucket */
long long low;
long long high;
/* Count of observations recorded */
long long nr_observations;
/* Sum of values recorded */
long long sum_values;
};struct histogram {
/* Sum of all values recorded */
long long tot_values;
/* Count of all observations recorded */
long long tot_observations;
struct histent *buckets;
/* Number of buckets */
unsigned int nr_buckets;
};int hist_add_bucket(struct histogram *hs, long long bucket_low); void hist_add(struct histogram *hs, long long value); void hist_prepare(struct histogram *hs, long long maxvalue);
and then hist_print/hist_summarize would have to be told the units of the values ("blocks") and the units of the observations ("extents") to print to stdout.
The first option is a bit lazy since there's nothing really diskspace specific about the histogram other than the printf labels; and the second option is more generic but maybe we should let the first non-space histogram user figure out how to do that?
<shrug> Your thoughts?
--D
Re: [PATCH 1/7] libfrog: hoist free space histogram code
Quoted 6 lines · Darrick J. Wong
Or change "blocks" to "value" and "extents" to "observations":
The first option is a bit lazy since there's nothing really diskspace specific about the histogram other than the printf labels; and the second option is more generic but maybe we should let the first non-space histogram user figure out how to do that?
Actually the second sounds easy enough even if we never end up using it for anything but space tracking.
Re: [PATCH 1/7] libfrog: hoist free space histogram code
Quoted 10 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
Or change "blocks" to "value" and "extents" to "observations":
The first option is a bit lazy since there's nothing really diskspace specific about the histogram other than the printf labels; and the second option is more generic but maybe we should let the first non-space histogram user figure out how to do that?
Actually the second sounds easy enough even if we never end up using it for anything but space tracking.
Ok, will do that tomorrow.
--D
PATCH 2/7 libfrog: print wider columns for free space histogram
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The values reported here can reach very large values, so compute the column width dynamically.
--- libfrog/histogram.c | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-)
libfrog/histogram.c +29 -5
@@ -108,17 +108,41 @@ voidhist_print ( const struct histogram *hs) { +unsigned int from_w, to_w, extents_w, blocks_w;unsigned int i; -printf ("%7s %7s %7s %7s %6s\n" , -_ ("from" ),_ ("to" ),_ ("extents" ),_ ("blocks" ),_ ("pct" )); + from_w = to_w = extents_w = blocks_w =7 ; +for (i =0 ; i < hs->nr_buckets; i++) { +char buf[256 ]; + +if (!hs->buckets[i].count) +continue ; + +snprintf (buf,sizeof (buf) -1 ,"%lld" , hs->buckets[i].low); + from_w =max (from_w,strlen (buf)); + +snprintf (buf,sizeof (buf) -1 ,"%lld" , hs->buckets[i].high); + to_w =max (to_w,strlen (buf)); + +snprintf (buf,sizeof (buf) -1 ,"%lld" , hs->buckets[i].count); + extents_w =max (extents_w,strlen (buf)); + +snprintf (buf,sizeof (buf) -1 ,"%lld" , hs->buckets[i].blocks); + blocks_w =max (blocks_w,strlen (buf)); + } + +printf ("%*s %*s %*s %*s %6s\n" , + from_w,_ ("from" ), to_w,_ ("to" ), extents_w,_ ("extents" ), + blocks_w,_ ("blocks" ),_ ("pct" ));for (i =0 ; i < hs->nr_buckets; i++) {if (hs->buckets[i].count ==0 )continue ; -printf ("%7lld %7lld %7lld %7lld %6.2f\n" , - hs->buckets[i].low, hs->buckets[i].high, - hs->buckets[i].count, hs->buckets[i].blocks, +printf ("%*lld %*lld %*lld %*lld %6.2f\n" , + from_w, hs->buckets[i].low, + to_w, hs->buckets[i].high, + extents_w, hs->buckets[i].count, + blocks_w, hs->buckets[i].blocks, hs->buckets[i].blocks *100.0 / hs->totblocks); } }
Re: [PATCH 2/7] libfrog: print wider columns for free space histogram
Looks good:
PATCH 3/7 libfrog: print cdf of free space buckets
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Print the cumulative distribution function of the free space buckets in reverse order.
--- libfrog/histogram.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 59 insertions(+), 4 deletions(-)
libfrog/histogram.c +59 -4
@@ -103,13 +103,64 @@ hist_free(memset (hs,0 ,sizeof (struct histogram )); } +/* +* Compute the CDF of the free space in decreasing order of extent length. +* This enables users to determine how much free space is not in the long tail +* of small extents, e.g. 98% of the free space extents are larger than 31 +* blocks. +*/ +static int +hist_cdf ( +const struct histogram *hs, +struct histogram *cdf) +{ +struct histent *buckets; +int i = hs->nr_buckets -1 ; + +ASSERT (cdf->nr_buckets ==0 ); +ASSERT (hs->nr_buckets <INT_MAX ); + +if (hs->nr_buckets ==0 ) +return 0 ; + + buckets =calloc (hs->nr_buckets,sizeof (struct histent )); +if (!buckets) +return errno; + +memset (cdf,0 ,sizeof (struct histogram )); + cdf->buckets = buckets; + + cdf->buckets[i].count = hs->buckets[i].count; + cdf->buckets[i].blocks = hs->buckets[i].blocks; + i--; + +while (i >=0 ) { + cdf->buckets[i].count = hs->buckets[i].count + + cdf->buckets[i +1 ].count; + + cdf->buckets[i].blocks = hs->buckets[i].blocks + + cdf->buckets[i +1 ].blocks; + i--; + } + +return 0 ; +} +/* Dump a histogram to stdout. */ void hist_print (const struct histogram *hs) { +struct histogram cdf = { };unsigned int from_w, to_w, extents_w, blocks_w;unsigned int i; +int error; + + error =hist_cdf (hs, &cdf); +if (error) { +printf (_ ("histogram cdf: %s\n" ),strerror (error)); +return ; + } from_w = to_w = extents_w = blocks_w =7 ;for (i =0 ; i < hs->nr_buckets; i++) {
@@ -131,20 +182,24 @@ hist_print( blocks_w =max (blocks_w,strlen (buf)); } -printf ("%*s %*s %*s %*s %6s\n" , +printf ("%*s %*s %*s %*s %6s %6s %6s\n" , from_w,_ ("from" ), to_w,_ ("to" ), extents_w,_ ("extents" ), - blocks_w,_ ("blocks" ),_ ("pct" )); + blocks_w,_ ("blocks" ),_ ("pct" ),_ ("blkcdf" ),_ ("extcdf" ));for (i =0 ; i < hs->nr_buckets; i++) {if (hs->buckets[i].count ==0 )continue ; -printf ("%*lld %*lld %*lld %*lld %6.2f\n" , +printf ("%*lld %*lld %*lld %*lld %6.2f %6.2f %6.2f\n" , from_w, hs->buckets[i].low, to_w, hs->buckets[i].high, extents_w, hs->buckets[i].count, blocks_w, hs->buckets[i].blocks, - hs->buckets[i].blocks *100.0 / hs->totblocks); + hs->buckets[i].blocks *100.0 / hs->totblocks, + cdf.buckets[i].blocks *100.0 / hs->totblocks, + cdf.buckets[i].count *100.0 / hs->totexts); } + +hist_free (&cdf); }/* Summarize the contents of the histogram. */
Re: [PATCH 3/7] libfrog: print cdf of free space buckets
Looks good:
PATCH 4/7 xfs_scrub: don't close stdout when closing the progress bar
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we're tearing down the progress bar file stream, check that it's not an alias of stdout before closing it.
--- scrub/xfs_scrub.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
scrub/xfs_scrub.c +1 -1
@@ -878,7 +878,7 @@ main(if (ctx.runtime_errors) ret |=SCRUB_RET_OPERROR ;phase_end (&all_pi,0 ); -if (progress_fp) +if (progress_fp &&fileno (progress_fp) !=1 )fclose (progress_fp); out_unicrash:unicrash_unload ();
Re: [PATCH 4/7] xfs_scrub: don't close stdout when closing the progress bar
Looks good:
PATCH 5/7 xfs_scrub: remove pointless spacemap.c arguments
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Remove unused parameters from the full-device spacemap scan functions.
--- scrub/spacemap.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-)
scrub/spacemap.c +4 -7
@@ -132,7 +132,6 @@ scan_ag_rmaps(static void scan_dev_rmaps (struct scrub_ctx *ctx, -int idx,dev_t dev,struct scan_blocks *sbx) {
@@ -170,7 +169,7 @@ scan_rt_rmaps( {struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx; -scan_dev_rmaps (ctx, agno, ctx->fsinfo.fs_rtdev, arg); +scan_dev_rmaps (ctx, ctx->fsinfo.fs_rtdev, arg); }/* Iterate all the reverse mappings of the log device. */
@@ -182,7 +181,7 @@ scan_log_rmaps( {struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx; -scan_dev_rmaps (ctx, agno, ctx->fsinfo.fs_logdev, arg); +scan_dev_rmaps (ctx, ctx->fsinfo.fs_logdev, arg); }/*
@@ -210,8 +209,7 @@ scrub_scan_all_spacemaps(return ret; }if (ctx->fsinfo.fs_rt) { - ret = -workqueue_add (&wq, scan_rt_rmaps, - ctx->mnt.fsgeom.agcount +1 , &sbx); + ret = -workqueue_add (&wq, scan_rt_rmaps,0 , &sbx);if (ret) { sbx.aborted = true;str_liberror (ctx, ret,_ ("queueing rtdev fsmap work" ));
@@ -219,8 +217,7 @@ scrub_scan_all_spacemaps( } }if (ctx->fsinfo.fs_log) { - ret = -workqueue_add (&wq, scan_log_rmaps, - ctx->mnt.fsgeom.agcount +2 , &sbx); + ret = -workqueue_add (&wq, scan_log_rmaps,0 , &sbx);if (ret) { sbx.aborted = true;str_liberror (ctx, ret,_ ("queueing logdev fsmap work" ));
Re: [PATCH 5/7] xfs_scrub: remove pointless spacemap.c arguments
Looks good:
PATCH 6/7 xfs_scrub: collect free space histograms during phase 7
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Collect a histogram of free space observed during phase 7. We'll put this information to use in the next patch.
--- libfrog/histogram.c | 38 ++++++++++++++++++++++++++++++++++++++ libfrog/histogram.h | 3 +++ scrub/phase7.c | 47 +++++++++++++++++++++++++++++++++++++++++++++-- scrub/xfs_scrub.c | 5 +++++ scrub/xfs_scrub.h | 4 ++++ 5 files changed, 95 insertions(+), 2 deletions(-)
libfrog/histogram.c +38 -0
@@ -212,3 +212,41 @@ hist_summarize(printf (_ ("average free extent size %g\n" ), (double )hs->totblocks / (double )hs->totexts); } + +/* Copy the contents of src to dest. */ +void +hist_import ( +struct histogram *dest, +const struct histogram *src) +{ +unsigned int i; + +ASSERT (dest->nr_buckets == src->nr_buckets); + + dest->totblocks += src->totblocks; + dest->totexts += src->totexts; + +for (i =0 ; i < dest->nr_buckets; i++) { +ASSERT (dest->buckets[i].low == src->buckets[i].low); +ASSERT (dest->buckets[i].high == src->buckets[i].high); + + dest->buckets[i].count += src->buckets[i].count; + dest->buckets[i].blocks += src->buckets[i].blocks; + } +} + +/* +* Move the contents of src to dest and reinitialize src. dst must not +* contain any observations or buckets. +*/ +void +hist_move ( +struct histogram *dest, +struct histogram *src) +{ +ASSERT (dest->nr_buckets ==0 ); +ASSERT (dest->totexts ==0 ); + +memcpy (dest, src,sizeof (struct histogram )); +hist_init (src); +}
libfrog/histogram.h +3 -0
@@ -47,4 +47,7 @@ static inline unsigned int hist_buckets(const struct histogram *hs) return hs->nr_buckets; } +void hist_import (struct histogram *dest,const struct histogram *src); +void hist_move (struct histogram *dest,struct histogram *src); +#endif /* __LIBFROG_HISTOGRAM_H__ */
scrub/phase7.c +45 -2
92 lines not on this page · raw message
scrub/xfs_scrub.c +5 -0
@@ -18,6 +18,7 @@#include "descr.h" #include "unicrash.h" #include "progress.h" +#include "libfrog/histogram.h" /* * XFS Online Metadata Scrub (and Repair)
@@ -669,6 +670,8 @@ main(int ret =SCRUB_RET_SUCCESS ;int error; +hist_init (&ctx.datadev_hist); +fprintf (stdout,"EXPERIMENTAL xfs_scrub program in use! Use at your own risk!\n" );fflush (stdout);
@@ -883,6 +886,8 @@ main( out_unicrash:unicrash_unload (); +hist_free (&ctx.datadev_hist); +/* * If we're being run as a service, the return code must fit the LSB * init script action error guidelines, which is to say that we
scrub/xfs_scrub.h +4 -0
@@ -7,6 +7,7 @@#define XFS_SCRUB_XFS_SCRUB_H_ #include "libfrog/fsgeom.h" +#include "libfrog/histogram.h" extern char *progname;
@@ -86,6 +87,9 @@ struct scrub_ctx {unsigned long long preens;bool scrub_setup_succeeded;bool preen_triggers[XFS_SCRUB_TYPE_NR ]; + +/* Free space histograms, in fsb */ +struct histogram datadev_hist; };/* Phase helper functions */
Re: [PATCH 6/7] xfs_scrub: collect free space histograms during phase 7
Looks good:
PATCH 7/7 xfs_scrub: tune fstrim minlen parameter based on free space histograms
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, phase 8 runs very slowly on filesystems with a lot of small free space extents. To reduce the amount of time spent on fstrim activities during phase 8, we want to balance estimated runtime against completeness of the trim. In short, the goal is to reduce runtime by avoiding small trim requests.
At the start of phase 8, a CDF is computed in decreasing order of extent length from the histogram buckets created during the fsmap scan in phase
7. A point corresponding to the fstrim percentage target is chosen from the CDF and mapped back to a histogram bucket, and free space extents smaller than that amount are ommitted from fstrim.
On my aging /home filesystem, the free space histogram reported by xfs_spaceman looks like this:
from to extents blocks pct blkcdf extcdf
1 1 121953 121953 0.04 100.00 100.00
2 3 124741 299694 0.09 99.96 81.16
4 7 113492 593763 0.18 99.87 61.89
8 15 109215 1179524 0.36 99.69 44.36
16 31 76972 1695455 0.52 99.33 27.48
32 63 48655 2219667 0.68 98.82 15.59
64 127 31398 2876898 0.88 98.14 8.08
128 255 8014 1447920 0.44 97.27 3.23
256 511 4142 1501758 0.46 96.82 1.99
512 1023 2433 1768732 0.54 96.37 1.35
1024 2047 1795 2648460 0.81 95.83 0.97
2048 4095 1429 4206103 1.28 95.02 0.69
4096 8191 1045 6162111 1.88 93.74 0.47
8192 16383 791 9242745 2.81 91.87 0.31
16384 32767 473 10883977 3.31 89.06 0.19
32768 65535 272 12385566 3.77 85.74 0.12
65536 131071 192 18098739 5.51 81.98 0.07
131072 262143 108 20675199 6.29 76.47 0.04
262144 524287 80 29061285 8.84 70.18 0.03
524288 1048575 39 29002829 8.83 61.33 0.02
1048576 2097151 25 36824985 11.21 52.51 0.01
2097152 4194303 32 101727192 30.95 41.30 0.01
4194304 8388607 7 34007410 10.35 10.35 0.00From this table, we see that free space extents that are 16 blocks or longer constitute 99.3% of the free space in the filesystem but only 27.5% of the extents. If we set the fstrim minlen parameter to 16 blocks, that means that we can trim over 99% of the space in one third of the time it would take to trim everything.
Add a new -o fstrim_pct= option to xfs_scrub just in case there are users out there who want a different percentage. For example, accepting a 95% trim would net us a speed increase of nearly two orders of magnitude, ignoring system call overhead. Setting it to 100% will trim everything, just like fstrim(8).
--- libfrog/histogram.c | 2 + libfrog/histogram.h | 1 + man/man8/xfs_scrub.8 | 16 +++++++++++ scrub/phase8.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++--- scrub/vfs.c | 4 ++- scrub/vfs.h | 2 + scrub/xfs_scrub.c | 38 +++++++++++++++++++++++++ scrub/xfs_scrub.h | 12 ++++++++ 8 files changed, 141 insertions(+), 9 deletions(-)
libfrog/histogram.c +1 -1
@@ -109,7 +109,7 @@ hist_free(* of small extents, e.g. 98% of the free space extents are larger than 31 * blocks. */ -static int +int hist_cdf (const struct histogram *hs,struct histogram *cdf)
libfrog/histogram.h +1 -0
@@ -39,6 +39,7 @@ void hist_add(struct histogram *hs, long long len);void hist_init (struct histogram *hs);void hist_prepare (struct histogram *hs,long long maxlen);void hist_free (struct histogram *hs); +int hist_cdf (const struct histogram *hs,struct histogram *cdf);void hist_print (const struct histogram *hs);void hist_summarize (const struct histogram *hs);
man/man8/xfs_scrub.8 +16 -0
@@ -100,6 +100,22 @@ The supported are: .RS 1.0i .TP +.BI fstrim_pct= percentage +To constrain the amount of time spent on fstrim activities during phase 8, +this program tries to balance estimated runtime against completeness of the +trim. +In short, the program avoids small trim requests to save time. + +During phase 7, a log-scale histogram of free space extents is constructed. +At the start of phase 8, a CDF is computed in decreasing order of extent +length from the histogram buckets. +A point corresponding to the fstrim percentage target is chosen from the CDF +and mapped back to a histogram bucket. +Free space extents at least as long as the bucket size are trimmed. +Smaller extents are ignored. + +By default, the percentage threshold is 99%. +.TP .BI iwarn Treat informational messages as warnings. This will result in a nonzero return code, and a higher logging level.
scrub/phase8.c +70 -5
123 lines not on this page · raw message
scrub/vfs.c +3 -1
@@ -300,11 +300,13 @@ intfstrim ( struct scrub_ctx *ctx, uint64_t start, - uint64_t len) + uint64_t len, + uint64_t minlen) { struct fstrim_range range = { .start = start, .len = len, + .minlen = minlen, };if (ioctl (ctx->mnt.fd,FITRIM , &range) ==0 )
scrub/vfs.h +1 -1
@@ -24,6 +24,6 @@ typedef int (*scan_fs_tree_dirent_fn)(struct scrub_ctx *, const char *,int scan_fs_tree (struct scrub_ctx *ctx,scan_fs_tree_dir_fn dir_fn,scan_fs_tree_dirent_fn dirent_fn,void *arg); -int fstrim (struct scrub_ctx *ctx,uint64_t start,uint64_t len); +int fstrim (struct scrub_ctx *ctx,uint64_t start,uint64_t len,uint64_t minlen);#endif /* XFS_SCRUB_VFS_H_ */
scrub/xfs_scrub.c +37 -1
@@ -622,11 +622,13 @@ report_outcome(*/ enum o_opt_nums {IWARN =0 , +FSTRIM_PCT ,O_MAX_OPTS , };static char *o_opts[] = { [IWARN ] ="iwarn" , + [FSTRIM_PCT ] ="fstrim_pct" , [O_MAX_OPTS ] =NULL , };
@@ -635,8 +637,11 @@ parse_o_opts(struct scrub_ctx *ctx, char *p) { + double dval; +while (*p !='\0' ) {char *val; +char *endp;switch (getsubopt (&p, o_opts, &val)) {case IWARN :
@@ -647,6 +652,35 @@ parse_o_opts( } info_is_warning = true;break ; +case FSTRIM_PCT : +if (!val) { +fprintf (stderr, +_ ("-o fstrim_pct requires a parameter\n" )); +usage (); + } + + errno =0 ; + dval =strtod (val, &endp); + +if (*endp) { +fprintf (stderr, +_ ("-o fstrim_pct must be a floating point number\n" )); +usage (); + } +if (errno) { +fprintf (stderr, +_ ("-o fstrim_pct: %s\n" ), +strerror (errno)); +usage (); + } +if (dval <=0 || dval >100 ) { +fprintf (stderr, +_ ("-o fstrim_pct must be larger than 0 and less than 100\n" )); +usage (); + } + + ctx->fstrim_block_pct = dval /100.0 ; +break ;default :usage ();break ;
@@ -659,7 +693,9 @@ main(int argc, char **argv) { - struct scrub_ctx ctx = {0}; + struct scrub_ctx ctx = { + .fstrim_block_pct =FSTRIM_BLOCK_PCT_DEFAULT , + };struct phase_rusage all_pi;char *mtab =NULL ;FILE *progress_fp =NULL ;
scrub/xfs_scrub.h +12 -0
@@ -90,8 +90,20 @@ struct scrub_ctx {/* Free space histograms, in fsb */ struct histogram datadev_hist; + +/* +* Pick the largest value for fstrim minlen such that we trim at least +* this much space per volume. +*/ +double fstrim_block_pct; }; +/* +* Trim only enough free space extents (in order of decreasing length) to +* ensure that this percentage of the free space is trimmed. +*/ +#define FSTRIM_BLOCK_PCT_DEFAULT (99.0 / 100.0) +/* Phase helper functions */ void xfs_shutdown_fs (struct scrub_ctx *ctx);int scrub_cleanup (struct scrub_ctx *ctx);
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 5 lines · Darrick J. Wong
Add a new -o fstrim_pct= option to
xfs_scrubjust in case there are users out there who want a different percentage. For example, accepting a 95% trim would net us a speed increase of nearly two orders of magnitude, ignoring system call overhead. Setting it to 100% will trim everything, just like fstrim(8).
It might also make sense to default the parameter to the discard_granularity reported in sysfs. While a lot of devices don't report a useful value there, it avoids pointless work for those that do.
Otherwise this looks good:
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 11 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Add a new -o fstrim_pct= option to
xfs_scrubjust in case there are users out there who want a different percentage. For example, accepting a 95% trim would net us a speed increase of nearly two orders of magnitude, ignoring system call overhead. Setting it to 100% will trim everything, just like fstrim(8).It might also make sense to default the parameter to the
discard_granularityreported in sysfs. While a lot of devices don't report a useful value there, it avoids pointless work for those that do.
Oooh, that's a good idea. Let me fiddle with that & tack it on the end?
Hmm. How do we query the discard granularity from a userspace program? I can try to guess the /sys/block/XXX root from the devices passed in, or maybe libblkid will tell me? And then I'd have to go open queue/discard_granularity underneath that to read that.
That's going to take a day or so, I suspect. :/
Quoted 3 lines
Otherwise this looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 6 lines · Darrick J. Wong
Oooh, that's a good idea. Let me fiddle with that & tack it on the end?
Hmm. How do we query the discard granularity from a userspace program? I can try to guess the
/sys/block/XXXroot from the devices passed in, or maybe libblkid will tell me? And then I'd have to go open queue/discard_granularity underneath that to read that.
Good question. As far as I can tell there is no simply ioctl for it. I really wonder if we need an extensible block topology ioctl that we can keep adding files for new queue limits, to make it easy to query them from userspace without all that sysfs mess..
Quoted 1 line
That's going to take a day or so, I suspect. :/
No rush, just noticed it. Note that for the discard granularity we should also look at the alignment and not just the size.
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 8 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
Oooh, that's a good idea. Let me fiddle with that & tack it on the end?
Hmm. How do we query the discard granularity from a userspace program? I can try to guess the
/sys/block/XXXroot from the devices passed in, or maybe libblkid will tell me? And then I'd have to go open queue/discard_granularity underneath that to read that.
Quoted 4 lines
Good question. As far as I can tell there is no simply ioctl for it. I really wonder if we need an extensible block topology ioctl that we can keep adding files for new queue limits, to make it easy to query them from userspace without all that sysfs mess..
Yeah. Or implement FS_IOC_GETSYSFSPATH for block devices? :P
Quoted 4 lines
Quoted 1 line
That's going to take a day or so, I suspect. :/
No rush, just noticed it. Note that for the discard granularity we should also look at the alignment and not just the size.
<nod> AFAICT the xfs discard code doesn't check the alignment. Maybe the block layer does, but ... weirdly we've now refactored xfs_discard_extents so that it /never/ reports errors of any kind in the submit loop because __blkdev_issue_discard always returns 0, and the endio doesn't check the bio status either.
--D
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 6 lines · Darrick J. Wong
Quoted 4 lines
Good question. As far as I can tell there is no simply ioctl for it. I really wonder if we need an extensible block topology ioctl that we can keep adding files for new queue limits, to make it easy to query them from userspace without all that sysfs mess..
Yeah. Or implement
FS_IOC_GETSYSFSPATHfor block devices? :P
I know people like to fetishize file access (and to be honest from a shell it is really nice), but from a C program would you rather do one ioctl to find a sysfs base path, then do string manipulation to find the actual attribute, then open + read + close it, or do a single ioctl and read a bunch of values from a struct?
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
That's going to take a day or so, I suspect. :/
No rush, just noticed it. Note that for the discard granularity we should also look at the alignment and not just the size.
<nod> AFAICT the xfs discard code doesn't check the alignment. Maybe the block layer does, but ..
The block layer checks the alignment and silently skips anything not matching it. So not adhering it isn't an error, it might just cause pointless work.
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Quoted 4 lines
Good question. As far as I can tell there is no simply ioctl for it. I really wonder if we need an extensible block topology ioctl that we can keep adding files for new queue limits, to make it easy to query them from userspace without all that sysfs mess..
Quoted 7 lines
Quoted 1 line
Yeah. Or implement
FS_IOC_GETSYSFSPATHfor block devices? :PI know people like to fetishize file access (and to be honest from a shell it is really nice), but from a C program would you rather do one ioctl to find a sysfs base path, then do string manipulation to find the actual attribute, then open + read + close it, or do a single ioctl and read a bunch of values from a struct?
Single ioctl and read from a struct.
Or single ioctl and read a bunch of json (LOL)
I wish the BLK* ioctls had kept pace with the spread of queue limits.
Quoted 11 lines
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
That's going to take a day or so, I suspect. :/
No rush, just noticed it. Note that for the discard granularity we should also look at the alignment and not just the size.
<nod> AFAICT the xfs discard code doesn't check the alignment. Maybe the block layer does, but ..
The block layer checks the alignment and silently skips anything not matching it. So not adhering it isn't an error, it might just cause pointless work.
<nod>
--D
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 11 lines · Darrick J. Wong
Quoted 5 lines
I know people like to fetishize file access (and to be honest from a shell it is really nice), but from a C program would you rather do one ioctl to find a sysfs base path, then do string manipulation to find the actual attribute, then open + read + close it, or do a single ioctl and read a bunch of values from a struct?
Single ioctl and read from a struct.
Or single ioctl and read a bunch of json (LOL)
I wish the BLK* ioctls had kept pace with the spread of queue limits.
Let me propose a new BLKLIMITS ioctl, and then we'll work from there?
Re: [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms
Quoted 7 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
Quoted 5 lines
I know people like to fetishize file access (and to be honest from a shell it is really nice), but from a C program would you rather do one ioctl to find a sysfs base path, then do string manipulation to find the actual attribute, then open + read + close it, or do a single ioctl and read a bunch of values from a struct?
Quoted 7 lines
Quoted 5 lines
Single ioctl and read from a struct.
Or single ioctl and read a bunch of json (LOL)
I wish the BLK* ioctls had kept pace with the spread of queue limits.
Let me propose a new BLKLIMITS ioctl, and then we'll work from there?
Ok!
--D
PATCH 6/16 xfs_scrub: tighten security of systemd services
In reply to Darrick J. WongHi all,
To reduce the risk of the online fsck service suffering some sort of catastrophic breach that results in attackers reconfiguring the running system, I embarked on a security audit of the systemd service files. The result should be that all elements of the background service (individual scrub jobs, the scrub_all initiator, and the failure reporting) run with as few privileges and within as strong of a sandbox as possible.
Granted, this does nothing about the potential for the /kernel/ screwing up, but at least we could prevent obvious container escapes.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-service-security
---
Commits in this patchset:
* xfs_scrub: allow auxiliary pathnames for sandboxing
* xfs_scrub.service: reduce background CPU usage to less than one core if possible
* xfs_scrub: use dynamic users when running as a systemd service
* xfs_scrub: tighten up the security on the background systemd service
* xfs_scrub_fail: tighten up the security on the background systemd service
* xfs_scrub_all: tighten up the security on the background systemd service
--- man/man8/xfs_scrub.8 | 9 +++- scrub/Makefile | 7 ++- scrub/phase1.c | 4 +- scrub/system-xfs_scrub.slice | 30 ++++++++++++ scrub/vfs.c | 2 - scrub/xfs_scrub.c | 11 +++- scrub/xfs_scrub.h | 5 ++ scrub/[email protected] | 97 ++++++++++++++++++++++++++++++++++---- scrub/xfs_scrub_all.service.in | 66 ++++++++++++++++++++++++++ scrub/[email protected] | 59 +++++++++++++++++++++++ 10 files changed, 270 insertions(+), 20 deletions(-) create mode 100644 scrub/system-xfs_scrub.slice
PATCH 1/6 xfs_scrub: allow auxiliary pathnames for sandboxing
From: Darrick J. Wong <[email protected]>
In the next patch, we'll tighten up the security on the xfs_scrub service so that it can't escape. However, sandboxing the service involves making the host filesystem as inaccessible as possible, with the filesystem to scrub bind mounted onto a known location within the sandbox. Hence we need one path for reporting and a new -M argument to tell scrub what it should actually be trying to open.
--- man/man8/xfs_scrub.8 | 9 ++++++++- scrub/phase1.c | 4 ++-- scrub/vfs.c | 2 +- scrub/xfs_scrub.c | 11 ++++++++--- scrub/xfs_scrub.h | 5 ++++- 5 files changed, 23 insertions(+), 8 deletions(-)
man/man8/xfs_scrub.8 +8 -1
@@ -4,7 +4,7 @@ xfs_scrub \- check and repair the contents of a mounted XFS filesystem .SH SYNOPSIS .B xfs_scrub [ -.B \-abCemnTvx +.B \-abCeMmnTvx ] .I mount-point .br
@@ -79,6 +79,13 @@ behavior. .B \-k Do not call TRIM on the free space. .TP +.BI \-M " real-mount-point" +Open the this path for issuing scrub system calls to the kernel. +The positional +.I mount-point +parameter will be used for displaying informational messages and logging. +This parameter exists to enable process sandboxing for service mode. +.TP .BI \-m " file" Search this file for mounted filesystems instead of /etc/mtab. .TP
scrub/phase1.c +2 -2
@@ -146,7 +146,7 @@ phase1_func(* CAP_SYS_ADMIN, which we probably need to do anything fancy * with the (XFS driver) kernel. */ - error = -xfd_open (&ctx->mnt, ctx->mntpoint, + error = -xfd_open (&ctx->mnt, ctx->actual_mntpoint,O_RDONLY |O_NOATIME |O_DIRECTORY );if (error) {if (error ==EPERM )
@@ -199,7 +199,7 @@ _("Not an XFS filesystem."));return error; } - error =path_to_fshandle (ctx->mntpoint, &ctx->fshandle, + error =path_to_fshandle (ctx->actual_mntpoint, &ctx->fshandle, &ctx->fshandle_len);if (error) {str_errno (ctx,_ ("getting fshandle" ));
scrub/vfs.c +1 -1
@@ -249,7 +249,7 @@ scan_fs_tree( goto out_cond; } - ret =queue_subdir (ctx, &sft, &wq, ctx->mntpoint, true); + ret =queue_subdir (ctx, &sft, &wq, ctx->actual_mntpoint, true);if (ret) {str_liberror (ctx, ret,_ ("queueing directory scan" )); goto out_wq;
scrub/xfs_scrub.c +8 -3
@@ -725,7 +725,7 @@ main(pthread_mutex_init (&ctx.lock,NULL ); ctx.mode =SCRUB_MODE_REPAIR ; ctx.error_action =ERRORS_CONTINUE ; -while ((c =getopt (argc, argv,"a:bC:de:km:no:TvxV" )) !=EOF ) { +while ((c =getopt (argc, argv,"a:bC:de:kM:m:no:TvxV" )) !=EOF ) {switch (c) {case 'a' : ctx.max_errors =cvt_u64 (optarg,10 );
@@ -769,6 +769,9 @@ main(case 'k' : want_fstrim = false;break ; +case 'M' : + ctx.actual_mntpoint = optarg; +break ;case 'm' : mtab = optarg;break ;
@@ -823,6 +826,8 @@ main(usage (); ctx.mntpoint = argv[optind]; +if (!ctx.actual_mntpoint) + ctx.actual_mntpoint = ctx.mntpoint; stdout_isatty =isatty (STDOUT_FILENO ); stderr_isatty =isatty (STDERR_FILENO );
@@ -840,7 +845,7 @@ main(return SCRUB_RET_OPERROR ;/* Find the mount record for the passed-in argument. */ -if (stat (argv[optind], &ctx.mnt_sb) <0 ) { +if (stat (ctx.actual_mntpoint, &ctx.mnt_sb) <0 ) {fprintf (stderr,_ ("%s: could not stat: %s: %s\n" ), progname, argv[optind],strerror (errno));
@@ -863,7 +868,7 @@ main( }fs_table_initialise (0 ,NULL ,0 ,NULL ); - fsp =fs_table_lookup_mount (ctx.mntpoint); + fsp =fs_table_lookup_mount (ctx.actual_mntpoint);if (!fsp) {fprintf (stderr,_ ("%s: Not a XFS mount point.\n" ), ctx.mntpoint);
scrub/xfs_scrub.h +4 -1
@@ -38,9 +38,12 @@ enum error_action {struct scrub_ctx {/* Immutable scrub state. */ -/* Strings we need for presentation */ +/* Mountpoint we use for presentation */ char *mntpoint; +/* Actual VFS path to the filesystem */ +char *actual_mntpoint; +/* Mountpoint info */ struct stat mnt_sb;struct statvfs mnt_sv;
Re: [PATCH 1/6] xfs_scrub: allow auxiliary pathnames for sandboxing
Looks good:
PATCH 2/6 xfs_scrub.service: reduce background CPU usage to less than one core if possible
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, the xfs_scrub background service is configured to use -b, which means that the program runs completely serially. However, even using all of one CPU core with idle priority may be enough to cause thermal throttling and unwanted fan noise on smaller systems (e.g. laptops) with fast IO systems.
Let's try to avoid this (at least on systemd) by using cgroups to limit the program's usage to slghtly more than half of one CPU and lowering the nice priority in the scheduler. What we /really/ want is to run steadily on an efficiency core, but there doesn't seem to be a means to ask the scheduler not to ramp up the CPU frequency for a particular task.
While we're at it, group the resource limit directives together.
--- scrub/Makefile | 7 ++++++- scrub/system-xfs_scrub.slice | 30 ++++++++++++++++++++++++++++++ scrub/[email protected] | 12 ++++++++++-- scrub/xfs_scrub_all.service.in | 4 ++++ scrub/[email protected] | 4 ++++ 5 files changed, 54 insertions(+), 3 deletions(-) create mode 100644 scrub/system-xfs_scrub.slice
scrub/Makefile +6 -1
@@ -18,7 +18,12 @@ XFS_SCRUB_FAIL_PROG = xfs_scrub_fail XFS_SCRUB_ARGS = -b -n ifeq ($(HAVE_SYSTEMD),yes) INSTALL_SCRUB += install-systemd -SYSTEMD_SERVICES = $(scrub_svcname) xfs_scrub_all.service xfs_scrub_all.timer [email protected] +SYSTEMD_SERVICES=\ + $(scrub_svcname) \ + [email protected] \ + xfs_scrub_all.service \ + xfs_scrub_all.timer \ + system-xfs_scrub.slice OPTIONAL_TARGETS += $(SYSTEMD_SERVICES) endif ifeq ($(HAVE_CROND),yes)
scrub/system-xfs_scrub.slice new file +30 -0
@@ -0,0 +1,30 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (c) 2022-2024 Oracle. All Rights Reserved. +# Author: Darrick J. Wong <[email protected]> + +[Unit] +Description=xfs_scrub background service slice +Before=slices.target + +[Slice] + +# If the CPU usage cgroup controller is available, don't use more than 60% of a +# single core for all background processes. +CPUQuota=60% +CPUAccounting=true + +[Install] +# As of systemd 249, the systemd cgroupv2 configuration code will drop resource +# controllers from the root and system.slice cgroups at startup if it doesn't +# find any direct dependencies that require a given controller. Newly +# activated units with resource control directives are created under the system +# slice but do not cause a reconfiguration of the slice's resource controllers. +# Hence we cannot put CPUQuota= into the xfs_scrub service units directly. +# +# For the CPUQuota directive to have any effect, we must therefore create an +# explicit definition file for the slice that systemd creates to contain the +# xfs_scrub instance units (e.g. [email protected]) and we must configure this +# slice as a dependency of the system slice to establish the direct dependency +# relation. +WantedBy=system.slice
scrub/[email protected] +10 -2
@@ -18,8 +18,16 @@ PrivateTmp=no AmbientCapabilities=CAP_SYS_ADMIN CAP_FOWNER CAP_DAC_OVERRIDE CAP_DAC_READ_SEARCH CAP_SYS_RAWIO NoNewPrivileges=yes User=nobody -IOSchedulingClass=idle -CPUSchedulingPolicy=idle Environment=SERVICE_MODE=1 ExecStart=@sbindir@/xfs_scrub @scrub_args@ %f SyslogIdentifier=%N + +# Run scrub with minimal CPU and IO priority so that nothing else will starve. +IOSchedulingClass=idle +CPUSchedulingPolicy=idle +CPUAccounting=true +Nice=19 + +# Create the service underneath the scrub background service slice so that we +# can control resource usage. +Slice=system-xfs_scrub.slice
scrub/xfs_scrub_all.service.in +4 -0
@@ -14,3 +14,7 @@ Type=oneshot Environment=SERVICE_MODE=1 ExecStart=@sbindir@/xfs_scrub_all SyslogIdentifier=xfs_scrub_all + +# Create the service underneath the scrub background service slice so that we +# can control resource usage. +Slice=system-xfs_scrub.slice
scrub/[email protected] +4 -0
@@ -14,3 +14,7 @@ ExecStart=@pkg_libexec_dir@/xfs_scrub_fail "${EMAIL_ADDR}" %f User=mail Group=mail SupplementaryGroups=systemd-journal + +# Create the service underneath the scrub background service slice so that we +# can control resource usage. +Slice=system-xfs_scrub.slice
PATCH 3/6 xfs_scrub: use dynamic users when running as a systemd service
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Five years ago, systemd introduced the DynamicUser directive that allocates a new unique user/group id, runs a service with those ids, and deletes them after the service exits. This is a good replacement for User=nobody, since it eliminates the threat of nobody-services messing with each other.
Make this transition ahead of all the other security tightenings that will land in the next few patches, and add credits for the people who suggested the change and reviewed it.
--- scrub/[email protected] | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
scrub/[email protected] +3 -1
@@ -17,7 +17,6 @@ ProtectHome=read-only PrivateTmp=no AmbientCapabilities=CAP_SYS_ADMIN CAP_FOWNER CAP_DAC_OVERRIDE CAP_DAC_READ_SEARCH CAP_SYS_RAWIO NoNewPrivileges=yes -User=nobody Environment=SERVICE_MODE=1 ExecStart=@sbindir@/xfs_scrub @scrub_args@ %f SyslogIdentifier=%N
@@ -31,3 +30,6 @@ Nice=19 # Create the service underneath the scrub background service slice so that we # can control resource usage. Slice=system-xfs_scrub.slice + +# Dynamically create a user that isn't root +DynamicUser=true
PATCH 4/6 xfs_scrub: tighten up the security on the background systemd service
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, xfs_scrub has to run with some elevated privileges. Minimize the risk of xfs_scrub escaping its service container or contaminating the rest of the system by using systemd's sandboxing controls to prohibit as much access as possible.
The directives added by this patch were recommended by the command 'systemd-analyze security [email protected]' in systemd 249.
--- scrub/[email protected] | 81 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 73 insertions(+), 8 deletions(-)
scrub/[email protected] +73 -8
@@ -8,17 +8,21 @@ Description=Online XFS Metadata Check for %f OnFailure=xfs_scrub_fail@%i.service Documentation=man:xfs_scrub(8) +# Explicitly require the capabilities that this program needs +ConditionCapability=CAP_SYS_ADMIN +ConditionCapability=CAP_FOWNER +ConditionCapability=CAP_DAC_OVERRIDE +ConditionCapability=CAP_DAC_READ_SEARCH +ConditionCapability=CAP_SYS_RAWIO + +# Must be a mountpoint +ConditionPathIsMountPoint=%f +RequiresMountsFor=%f + [Service] Type=oneshot -PrivateNetwork=true -ProtectSystem=full -ProtectHome=read-only -# Disable private /tmp just in case %f is a path under /tmp. -PrivateTmp=no -AmbientCapabilities=CAP_SYS_ADMIN CAP_FOWNER CAP_DAC_OVERRIDE CAP_DAC_READ_SEARCH CAP_SYS_RAWIO -NoNewPrivileges=yes Environment=SERVICE_MODE=1 -ExecStart=@sbindir@/xfs_scrub @scrub_args@ %f +ExecStart=@sbindir@/xfs_scrub @scrub_args@ -M /tmp/scrub/ %f SyslogIdentifier=%N # Run scrub with minimal CPU and IO priority so that nothing else will starve.
@@ -31,5 +35,66 @@ Nice=19 # can control resource usage. Slice=system-xfs_scrub.slice +# No realtime CPU scheduling +RestrictRealtime=true + # Dynamically create a user that isn't root DynamicUser=true + +# Make the entire filesystem readonly and /home inaccessible, then bind mount +# the filesystem we're supposed to be checking into our private /tmp dir. +# 'norbind' means that we don't bind anything under that original mount. +ProtectSystem=strict +ProtectHome=yes +PrivateTmp=true +BindPaths=%f:/tmp/scrub:norbind + +# Don't let scrub complain about paths in /etc/projects that have been hidden +# by our sandboxing. scrub doesn't care about project ids anyway. +InaccessiblePaths=-/etc/projects + +# No network access +PrivateNetwork=true +ProtectHostname=true +RestrictAddressFamilies=none +IPAddressDeny=any + +# Don't let the program mess with the kernel configuration at all +ProtectKernelLogs=true +ProtectKernelModules=true +ProtectKernelTunables=true +ProtectControlGroups=true +ProtectProc=invisible +RestrictNamespaces=true + +# Hide everything in /proc, even /proc/mounts +ProcSubset=pid + +# Only allow the default personality Linux +LockPersonality=true + +# No writable memory pages +MemoryDenyWriteExecute=true + +# Don't let our mounts leak out to the host +PrivateMounts=true + +# Restrict system calls to the native arch and only enough to get things going +SystemCallArchitectures=native +SystemCallFilter=@system-service +SystemCallFilter=~@privileged +SystemCallFilter=~@resources +SystemCallFilter=~@mount + +# xfs_scrub needs these privileges to run, and no others +CapabilityBoundingSet=CAP_SYS_ADMIN CAP_FOWNER CAP_DAC_OVERRIDE CAP_DAC_READ_SEARCH CAP_SYS_RAWIO +AmbientCapabilities=CAP_SYS_ADMIN CAP_FOWNER CAP_DAC_OVERRIDE CAP_DAC_READ_SEARCH CAP_SYS_RAWIO +NoNewPrivileges=true + +# xfs_scrub doesn't create files +UMask=7777 + +# No access to hardware /dev files except for block devices +ProtectClock=true +DevicePolicy=closed +DeviceAllow=block-*
PATCH 5/6 xfs_scrub_fail: tighten up the security on the background systemd service
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, xfs_scrub_fail has to run with enough privileges to access the journal contents for a given scrub run and to send a report via email. Minimize the risk of xfs_scrub_fail escaping its service container or contaminating the rest of the system by using systemd's sandboxing controls to prohibit as much access as possible.
The directives added by this patch were recommended by the command 'systemd-analyze security [email protected]' in systemd 249.
--- scrub/[email protected] | 55 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+)
scrub/[email protected] +55 -0
@@ -18,3 +18,58 @@ SupplementaryGroups=systemd-journal # Create the service underneath the scrub background service slice so that we # can control resource usage. Slice=system-xfs_scrub.slice + +# No realtime scheduling +RestrictRealtime=true + +# Make the entire filesystem readonly and /home inaccessible. +ProtectSystem=full +ProtectHome=yes +PrivateTmp=true +RestrictSUIDSGID=true + +# Emailing reports requires network access, but not the ability to change the +# hostname. +ProtectHostname=true + +# Don't let the program mess with the kernel configuration at all +ProtectKernelLogs=true +ProtectKernelModules=true +ProtectKernelTunables=true +ProtectControlGroups=true +ProtectProc=invisible +RestrictNamespaces=true + +# Can't hide /proc because journalctl needs it to find various pieces of log +# information +#ProcSubset=pid + +# Only allow the default personality Linux +LockPersonality=true + +# No writable memory pages +MemoryDenyWriteExecute=true + +# Don't let our mounts leak out to the host +PrivateMounts=true + +# Restrict system calls to the native arch and only enough to get things going +SystemCallArchitectures=native +SystemCallFilter=@system-service +SystemCallFilter=~@privileged +SystemCallFilter=~@resources +SystemCallFilter=~@mount + +# xfs_scrub needs these privileges to run, and no others +CapabilityBoundingSet= +NoNewPrivileges=true + +# Failure reporting shouldn't create world-readable files +UMask=0077 + +# Clean up any IPC objects when this unit stops +RemoveIPC=true + +# No access to hardware device files +PrivateDevices=true +ProtectClock=true
Re: [PATCH 5/6] xfs_scrub_fail: tighten up the security on the background systemd service
Looks good:
PATCH 6/6 xfs_scrub_all: tighten up the security on the background systemd service
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Currently, xfs_scrub_all has to run with enough privileges to find mounted XFS filesystems and the device associated with that mount and to start xfs_scrub@<mountpoint> sub-services. Minimize the risk of xfs_scrub_all escaping its service container or contaminating the rest of the system by using systemd's sandboxing controls to prohibit as much access as possible.
The directives added by this patch were recommended by the command 'systemd-analyze security xfs_scrub_all.service' in systemd 249.
--- scrub/xfs_scrub_all.service.in | 62 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+)
scrub/xfs_scrub_all.service.in +62 -0
@@ -18,3 +18,65 @@ SyslogIdentifier=xfs_scrub_all # Create the service underneath the scrub background service slice so that we # can control resource usage. Slice=system-xfs_scrub.slice + +# Run scrub_all with minimal CPU and IO priority so that nothing will starve. +IOSchedulingClass=idle +CPUSchedulingPolicy=idle +CPUAccounting=true +Nice=19 + +# No realtime scheduling +RestrictRealtime=true + +# No special privileges, but we still have to run as root so that we can +# contact the service manager to start the sub-units. +CapabilityBoundingSet= +NoNewPrivileges=true +RestrictSUIDSGID=true + +# Make the entire filesystem readonly. We don't want to hide anything because +# we need to find all mounted XFS filesystems in the host. +ProtectSystem=strict +ProtectHome=read-only +PrivateTmp=false + +# No network access except to the systemd control socket +PrivateNetwork=true +ProtectHostname=true +RestrictAddressFamilies=AF_UNIX +IPAddressDeny=any + +# Don't let the program mess with the kernel configuration at all +ProtectKernelLogs=true +ProtectKernelModules=true +ProtectKernelTunables=true +ProtectControlGroups=true +ProtectProc=invisible +RestrictNamespaces=true + +# Hide everything in /proc, even /proc/mounts +ProcSubset=pid + +# Only allow the default personality Linux +LockPersonality=true + +# No writable memory pages +MemoryDenyWriteExecute=true + +# Don't let our mounts leak out to the host +PrivateMounts=true + +# Restrict system calls to the native arch and only enough to get things going +SystemCallArchitectures=native +SystemCallFilter=@system-service +SystemCallFilter=~@privileged +SystemCallFilter=~@resources +SystemCallFilter=~@mount + +# Media scan stamp file shouldn't be readable by regular users +UMask=0077 + +# lsblk ignores mountpoints if it can't find the device files, so we cannot +# hide them +#ProtectClock=true +#PrivateDevices=true
Re: [PATCH 6/6] xfs_scrub_all: tighten up the security on the background systemd service
Looks good:
PATCH 7/16 xfs_scrub_all: automatic media scan service
In reply to Darrick J. WongHi all,
Now that we've completed the online fsck functionality, there are a few things that could be improved in the automatic service. Specifically, we would like to perform a more intensive metadata + media scan once per month, to give the user confidence that the filesystem isn't losing data silently. To accomplish this, enhance xfs_scrub_all to be able to trigger media scans. Next, add a duplicate set of system services that start the media scans automatically.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-media-scan-service
---
Commits in this patchset:
* xfs_scrub_all: only use the xfs_scrub@ systemd services in service mode
* xfs_scrub_all: remove journalctl background process
* xfs_scrub_all: support metadata+media scans of all filesystems
* xfs_scrub_all: enable periodic file data scrubs automatically
* xfs_scrub_all: trigger automatic media scans once per month
* xfs_scrub_all: failure reporting for the xfs_scrub_all job
--- debian/rules | 3 + include/builddefs.in | 3 + man/man8/Makefile | 7 ++ man/man8/xfs_scrub_all.8.in | 20 +++++ scrub/Makefile | 21 +++++- scrub/[email protected] | 2 - scrub/xfs_scrub_all.cron.in | 2 - scrub/xfs_scrub_all.in | 122 ++++++++++++++++++++++++++------ scrub/xfs_scrub_all.service.in | 9 ++ scrub/xfs_scrub_all_fail.service.in | 71 +++++++++++++++++++ scrub/xfs_scrub_fail.in | 46 +++++++++--- scrub/[email protected] | 2 - scrub/[email protected] | 100 ++++++++++++++++++++++++++ scrub/[email protected] | 76 ++++++++++++++++++++ 14 files changed, 439 insertions(+), 45 deletions(-) rename man/man8/{xfs_scrub_all.8 => xfs_scrub_all.8.in} (59%) create mode 100644 scrub/xfs_scrub_all_fail.service.in create mode 100644 scrub/[email protected] create mode 100644 scrub/[email protected]
PATCH 1/6 xfs_scrub_all: only use the xfs_scrub@ systemd services in service mode
From: Darrick J. Wong <[email protected]>
Since the per-mount [email protected] definition includes a bunch of resource usage constraints, we no longer want to use those services if xfs_scrub_all is being run directly by the sysadmin (aka not in service mode) on the presumption that sysadmins want answers as quickly as possible.
Therefore, only try to call the systemd service from xfs_scrub_all if SERVICE_MODE is set in the environment. If reaching out to systemd fails and we're in service mode, we still want to run xfs_scrub directly. Split the makefile variables as necessary so that we only pass -b to xfs_scrub in service mode.
--- scrub/Makefile | 5 ++++- scrub/[email protected] | 2 +- scrub/xfs_scrub_all.in | 11 ++++++++--- 3 files changed, 13 insertions(+), 5 deletions(-)
scrub/Makefile +4 -1
@@ -15,7 +15,8 @@ LTCOMMAND = xfs_scrub INSTALL_SCRUB = install-scrub XFS_SCRUB_ALL_PROG = xfs_scrub_all XFS_SCRUB_FAIL_PROG = xfs_scrub_fail -XFS_SCRUB_ARGS = -b -n +XFS_SCRUB_ARGS = -n +XFS_SCRUB_SERVICE_ARGS = -b ifeq ($(HAVE_SYSTEMD),yes) INSTALL_SCRUB += install-systemd SYSTEMD_SERVICES=\
@@ -113,6 +114,7 @@ xfs_scrub_all: xfs_scrub_all.in $(builddefs) $(Q)$(SED) -e "s|@sbindir@|$(PKG_SBIN_DIR)|g" \ -e "s|@scrub_svcname@|$(scrub_svcname)|g" \ -e "s|@pkg_version@|$(PKG_VERSION)|g" \ + -e "s|@scrub_service_args@|$(XFS_SCRUB_SERVICE_ARGS)|g" \ -e "s|@scrub_args@|$(XFS_SCRUB_ARGS)|g" < $< > $@ $(Q)chmod a+x $@
@@ -132,6 +134,7 @@ install: $(INSTALL_SCRUB) %.service: %.service.in $(builddefs) @echo " [SED] $@" $(Q)$(SED) -e "s|@sbindir@|$(PKG_SBIN_DIR)|g" \ + -e "s|@scrub_service_args@|$(XFS_SCRUB_SERVICE_ARGS)|g" \ -e "s|@scrub_args@|$(XFS_SCRUB_ARGS)|g" \ -e "s|@pkg_libexec_dir@|$(PKG_LIBEXEC_DIR)|g" \ < $< > $@
scrub/[email protected] +1 -1
@@ -22,7 +22,7 @@ RequiresMountsFor=%f [Service] Type=oneshot Environment=SERVICE_MODE=1 -ExecStart=@sbindir@/xfs_scrub @scrub_args@ -M /tmp/scrub/ %f +ExecStart=@sbindir@/xfs_scrub @scrub_service_args@ @scrub_args@ -M /tmp/scrub/ %f SyslogIdentifier=%N # Run scrub with minimal CPU and IO priority so that nothing else will starve.
scrub/xfs_scrub_all.in +8 -3
@@ -162,9 +162,10 @@ def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): if terminate: return - # Try it the systemd way + # Run per-mount systemd xfs_scrub service only if we ourselves + # are running as a systemd service. unitname = path_to_serviceunit(path) - if unitname is not None: + if unitname is not None and 'SERVICE_MODE' in os.environ: ret = systemctl_start(unitname, killfuncs) if ret == 0 or ret == 1: print("Scrubbing %s done, (err=%d)" % (mnt, ret))
@@ -175,8 +176,12 @@ def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): if terminate: return - # Invoke xfs_scrub manually + # Invoke xfs_scrub manually if we're running in the foreground. + # We also permit this if we're running as a cronjob where + # systemd services are unavailable. cmd = ['@sbindir@/xfs_scrub'] + if 'SERVICE_MODE' in os.environ: + cmd += '@scrub_service_args@'.split() cmd += '@scrub_args@'.split() cmd += [mnt] ret = run_killable(cmd, None, killfuncs)
Re: [PATCH 1/6] xfs_scrub_all: only use the xfs_scrub@ systemd services in service mode
Looks good:
PATCH 2/6 xfs_scrub_all: remove journalctl background process
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we only start systemd services if we're running in service mode, there's no need for the background journalctl process that only ran if we had started systemd services in non-service mode.
--- scrub/xfs_scrub_all.in | 14 -------------- 1 file changed, 14 deletions(-)
scrub/xfs_scrub_all.in +0 -14
@@ -261,17 +261,6 @@ def main(): fs = find_mounts() - # Tail the journal if we ourselves aren't a service... - journalthread = None - if 'SERVICE_MODE' not in os.environ: - try: - cmd=['journalctl', '--no-pager', '-q', '-S', 'now', \ - '-f', '-u', 'xfs_scrub@*', '-o', \ - 'cat'] - journalthread = subprocess.Popen(cmd) - except: - pass - # Schedule scrub jobs... running_devs = set() killfuncs = set()
@@ -308,9 +297,6 @@ def main(): while len(killfuncs) > 0: wait_for_termination(cond, killfuncs) - if journalthread is not None: - journalthread.terminate() - # See the service mode comments in xfs_scrub.c for why we do this. if 'SERVICE_MODE' in os.environ: time.sleep(2)
Re: [PATCH 2/6] xfs_scrub_all: remove journalctl background process
Looks good:
PATCH 3/6 xfs_scrub_all: support metadata+media scans of all filesystems
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add the necessary systemd services and control bits so that xfs_scrub_all can kick off a metadata+media scan of a filesystem.
--- man/man8/xfs_scrub_all.8 | 5 +- scrub/Makefile | 4 + scrub/xfs_scrub_all.in | 23 +++++-- scrub/xfs_scrub_fail.in | 13 +++- scrub/[email protected] | 2 - scrub/[email protected] | 100 ++++++++++++++++++++++++++++++++ scrub/[email protected] | 76 ++++++++++++++++++++++++ 7 files changed, 210 insertions(+), 13 deletions(-) create mode 100644 scrub/[email protected] create mode 100644 scrub/[email protected]
man/man8/xfs_scrub_all.8 +4 -1
@@ -4,7 +4,7 @@ xfs_scrub_all \- scrub all mounted XFS filesystems .SH SYNOPSIS .B xfs_scrub_all [ -.B \-hV +.B \-hxV ] .SH DESCRIPTION .B xfs_scrub_all
@@ -21,6 +21,9 @@ the same device simultaneously. .B \-h Display help. .TP +.B \-x +Read all file data extents to look for disk errors. +.TP .B \-V Prints the version number and exits. .SH EXIT CODE
scrub/Makefile +4 -0
@@ -9,6 +9,7 @@ include $(builddefs) SCRUB_PREREQS=$(HAVE_GETFSMAP) [email protected] [email protected] ifeq ($(SCRUB_PREREQS),yes) LTCOMMAND = xfs_scrub
@@ -22,6 +23,8 @@ INSTALL_SCRUB += install-systemd SYSTEMD_SERVICES=\ $(scrub_svcname) \ [email protected] \ + $(scrub_media_svcname) \ + [email protected] \ xfs_scrub_all.service \ xfs_scrub_all.timer \ system-xfs_scrub.slice
@@ -113,6 +116,7 @@ xfs_scrub_all: xfs_scrub_all.in $(builddefs) @echo " [SED] $@" $(Q)$(SED) -e "s|@sbindir@|$(PKG_SBIN_DIR)|g" \ -e "s|@scrub_svcname@|$(scrub_svcname)|g" \ + -e "s|@scrub_media_svcname@|$(scrub_media_svcname)|g" \ -e "s|@pkg_version@|$(PKG_VERSION)|g" \ -e "s|@scrub_service_args@|$(XFS_SCRUB_SERVICE_ARGS)|g" \ -e "s|@scrub_args@|$(XFS_SCRUB_ARGS)|g" < $< > $@
scrub/xfs_scrub_all.in +17 -6
@@ -19,6 +19,7 @@ from io import TextIOWrapper retcode = 0 terminate = False +scrub_media = False def DEVNULL(): '''Return /dev/null in subprocess writable format.'''
@@ -88,11 +89,15 @@ def run_killable(cmd, stdout, killfuncs): # systemd doesn't like unit instance names with slashes in them, so it # replaces them with dashes when it invokes the service. Filesystem paths # need a special --path argument so that dashes do not get mangled. -def path_to_serviceunit(path): +def path_to_serviceunit(path, scrub_media): '''Convert a pathname into a systemd service unit name.''' - cmd = ['systemd-escape', '--template', '@scrub_svcname@', - '--path', path] + if scrub_media: + svcname = '@scrub_media_svcname@' + else: + svcname = '@scrub_svcname@' + cmd = ['systemd-escape', '--template', svcname, '--path', path] + try: proc = subprocess.Popen(cmd, stdout = subprocess.PIPE) proc.wait()
@@ -153,7 +158,7 @@ def systemctl_start(unitname, killfuncs): def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): '''Run a scrub process.''' - global retcode, terminate + global retcode, terminate, scrub_media print("Scrubbing %s..." % mnt) sys.stdout.flush()
@@ -164,7 +169,7 @@ def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): # Run per-mount systemd xfs_scrub service only if we ourselves # are running as a systemd service. - unitname = path_to_serviceunit(path) + unitname = path_to_serviceunit(path, scrub_media) if unitname is not None and 'SERVICE_MODE' in os.environ: ret = systemctl_start(unitname, killfuncs) if ret == 0 or ret == 1:
@@ -183,6 +188,8 @@ def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): if 'SERVICE_MODE' in os.environ: cmd += '@scrub_service_args@'.split() cmd += '@scrub_args@'.split() + if scrub_media: + cmd += '-x' cmd += [mnt] ret = run_killable(cmd, None, killfuncs) if ret >= 0:
@@ -247,18 +254,22 @@ def main(): a = (mnt, cond, running_devs, devs, killfuncs) thr = threading.Thread(target = run_scrub, args = a) thr.start() - global retcode, terminate + global retcode, terminate, scrub_media parser = argparse.ArgumentParser( \ description = "Scrub all mounted XFS filesystems.") parser.add_argument("-V", help = "Report version and exit.", \ action = "store_true") + parser.add_argument("-x", help = "Scrub file data after filesystem metadata.", \ + action = "store_true") args = parser.parse_args() if args.V: print("xfs_scrub_all version @pkg_version@") sys.exit(0) + scrub_media = args.x + fs = find_mounts() # Schedule scrub jobs...
scrub/xfs_scrub_fail.in +8 -5
@@ -9,8 +9,11 @@ recipient="$1" test -z "${recipient}" && exit 0 -mntpoint="$2" +service="$2" +test -z "${service}" && exit 0 +mntpoint="$3" test -z "${mntpoint}" && exit 0 + hostname="$(hostname -f 2>/dev/null)" test -z "${hostname}" && hostname="${HOSTNAME}"
@@ -21,16 +24,16 @@ if [ ! -x "${mailer}" ]; then fi # Turn the mountpoint into a properly escaped systemd instance name -scrub_svc="$(systemd-escape --template "@scrub_svcname@" --path "${mntpoint}")" +scrub_svc="$(systemd-escape --template "${service}@.service" --path "${mntpoint}")" (cat << ENDL To: $1 -From: <xfs_scrub@${hostname}> -Subject: xfs_scrub failure on ${mntpoint} +From: <${service}@${hostname}> +Subject: ${service} failure on ${mntpoint} Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset=UTF-8 -So sorry, the automatic xfs_scrub of ${mntpoint} on ${hostname} failed. +So sorry, the automatic ${service} of ${mntpoint} on ${hostname} failed. Please do not reply to this mesage. A log of what happened follows:
scrub/[email protected] +1 -1
@@ -10,7 +10,7 @@ Documentation=man:xfs_scrub(8) [Service] Type=oneshot Environment=EMAIL_ADDR=root -ExecStart=@pkg_libexec_dir@/xfs_scrub_fail "${EMAIL_ADDR}" %f +ExecStart=@pkg_libexec_dir@/xfs_scrub_fail "${EMAIL_ADDR}" xfs_scrub %f User=mail Group=mail SupplementaryGroups=systemd-journal
scrub/[email protected] new file +100 -0
100 lines not on this page · raw message
scrub/[email protected] new file +76 -0
76 lines not on this page · raw message
Re: [PATCH 3/6] xfs_scrub_all: support metadata+media scans of all filesystems
Looks good:
PATCH 4/6 xfs_scrub_all: enable periodic file data scrubs automatically
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enhance xfs_scrub_all with the ability to initiate a file data scrub periodically. The user must specify the period, and they may optionally specify the path to a file that will record the last time the file data was scrubbed.
---
debian/rules | 3 +-
include/builddefs.in | 3 ++
man/man8/Makefile | 7 +++-
man/man8/xfs_scrub_all.8.in | 15 ++++++++
scrub/Makefile | 3 ++
scrub/xfs_scrub_all.in | 76 +++++++++++++++++++++++++++++++++++++++-
scrub/xfs_scrub_all.service.in | 6 ++-
7 files changed, 108 insertions(+), 5 deletions(-)
rename man/man8/{xfs_scrub_all.8 => xfs_scrub_all.8.in} (63%)debian/rules +2 -1
@@ -38,7 +38,8 @@ configure_options = \ --disable-ubsan \ --disable-addrsan \ --disable-threadsan \ - --enable-lto + --enable-lto \ + --localstatedir=/var options = export DEBUG=-DNDEBUG DISTRIBUTION=debian \ INSTALL_USER=root INSTALL_GROUP=root \
include/builddefs.in +3 -0
@@ -57,6 +57,9 @@ PKG_DOC_DIR = @datadir@/doc/@pkg_name@ PKG_LOCALE_DIR = @datadir@/locale PKG_DATA_DIR = @datadir@/@pkg_name@ MKFS_CFG_DIR = @datadir@/@pkg_name@/mkfs +PKG_STATE_DIR = @localstatedir@/lib/@pkg_name@ + +XFS_SCRUB_ALL_AUTO_MEDIA_SCAN_STAMP=$(PKG_STATE_DIR)/xfs_scrub_all_media.stamp CC = @cc@ BUILD_CC = @BUILD_CC@
man/man8/Makefile +6 -1
@@ -11,11 +11,12 @@ ifneq ("$(ENABLE_SCRUB)","yes") MAN_PAGES = $(filter-out xfs_scrub%,$(shell echo *.$(MAN_SECTION))) else MAN_PAGES = $(shell echo *.$(MAN_SECTION)) + MAN_PAGES += xfs_scrub_all.8 endif MAN_PAGES += mkfs.xfs.8 MAN_DEST = $(PKG_MAN_DIR)/man$(MAN_SECTION) LSRCFILES = $(MAN_PAGES) -DIRT = mkfs.xfs.8 +DIRT = mkfs.xfs.8 xfs_scrub_all.8 default : $(MAN_PAGES)
@@ -29,4 +30,8 @@ mkfs.xfs.8: mkfs.xfs.8.in @echo " [SED] $@" $(Q)$(SED) -e 's|@mkfs_cfg_dir@|$(MKFS_CFG_DIR)|g' < $^ > $@ +xfs_scrub_all.8: xfs_scrub_all.8.in + @echo " [SED] $@" + $(Q)$(SED) -e 's|@stampfile@|$(XFS_SCRUB_ALL_AUTO_MEDIA_SCAN_STAMP)|g' < $^ > $@ + install-dev :
man/man8/xfs_scrub_all.8.in renamed from man/man8/xfs_scrub_all.8 +15 -0
@@ -18,6 +18,21 @@ operations can be run in parallel so long as no two scrubbers access the same device simultaneously. .SH OPTIONS .TP +.B \--auto-media-scan-interval +Automatically enable the file data scan (i.e. the +.B -x +flag) if it has not been run in the specified interval. +The interval must be a floating point number with an optional unit suffix. +Supported unit suffixes are +.IR y ", " q ", " mo ", " w ", " d ", " h ", " m ", and " s +for years, 90-day quarters, 30-day months, weeks, days, hours, minutes, and +seconds, respectively. +If no units are specified, the default is seconds. +.TP +.B \--auto-media-scan-stamp +Path to a file that will record the last time the media scan was run. +Defaults to @stampfile@. +.TP .B \-h Display help. .TP
scrub/Makefile +3 -0
@@ -118,6 +118,7 @@ xfs_scrub_all: xfs_scrub_all.in $(builddefs) -e "s|@scrub_svcname@|$(scrub_svcname)|g" \ -e "s|@scrub_media_svcname@|$(scrub_media_svcname)|g" \ -e "s|@pkg_version@|$(PKG_VERSION)|g" \ + -e "s|@stampfile@|$(XFS_SCRUB_ALL_AUTO_MEDIA_SCAN_STAMP)|g" \ -e "s|@scrub_service_args@|$(XFS_SCRUB_SERVICE_ARGS)|g" \ -e "s|@scrub_args@|$(XFS_SCRUB_ARGS)|g" < $< > $@ $(Q)chmod a+x $@
@@ -141,6 +142,7 @@ install: $(INSTALL_SCRUB) -e "s|@scrub_service_args@|$(XFS_SCRUB_SERVICE_ARGS)|g" \ -e "s|@scrub_args@|$(XFS_SCRUB_ARGS)|g" \ -e "s|@pkg_libexec_dir@|$(PKG_LIBEXEC_DIR)|g" \ + -e "s|@pkg_state_dir@|$(PKG_STATE_DIR)|g" \ < $< > $@ %.cron: %.cron.in $(builddefs)
@@ -161,6 +163,7 @@ install-scrub: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) $(INSTALL) -m 755 $(XFS_SCRUB_ALL_PROG) $(PKG_SBIN_DIR) + $(INSTALL) -m 755 -d $(PKG_STATE_DIR) install-udev: $(UDEV_RULES) $(INSTALL) -m 755 -d $(UDEV_RULE_DIR)
scrub/xfs_scrub_all.in +75 -1
100 lines not on this page · raw message
scrub/xfs_scrub_all.service.in +4 -2
@@ -34,11 +34,13 @@ CapabilityBoundingSet= NoNewPrivileges=true RestrictSUIDSGID=true -# Make the entire filesystem readonly. We don't want to hide anything because -# we need to find all mounted XFS filesystems in the host. +# Make the entire filesystem readonly except for the media scan stamp file +# directory. We don't want to hide anything because we need to find all +# mounted XFS filesystems in the host. ProtectSystem=strict ProtectHome=read-only PrivateTmp=false +BindPaths=@pkg_state_dir@ # No network access except to the systemd control socket PrivateNetwork=true
Re: [PATCH 4/6] xfs_scrub_all: enable periodic file data scrubs automatically
Looks good:
PATCH 5/6 xfs_scrub_all: trigger automatic media scans once per month
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Teach the xfs_scrub_all background service to trigger an automatic scan of all file data once per month.
--- scrub/Makefile | 8 +++++++- scrub/xfs_scrub_all.cron.in | 2 +- scrub/xfs_scrub_all.service.in | 2 +- 3 files changed, 9 insertions(+), 3 deletions(-)
scrub/Makefile +7 -1
@@ -108,6 +108,9 @@ CFILES += unicrash.c LCFLAGS += -DHAVE_LIBICU $(LIBICU_CFLAGS) endif +# Automatically trigger a media scan once per month +XFS_SCRUB_ALL_AUTO_MEDIA_SCAN_INTERVAL=1mo + LDIRT = $(XFS_SCRUB_ALL_PROG) $(XFS_SCRUB_FAIL_PROG) *.service *.cron default: depend $(LTCOMMAND) $(XFS_SCRUB_ALL_PROG) $(XFS_SCRUB_FAIL_PROG) $(OPTIONAL_TARGETS)
@@ -143,11 +146,14 @@ install: $(INSTALL_SCRUB) -e "s|@scrub_args@|$(XFS_SCRUB_ARGS)|g" \ -e "s|@pkg_libexec_dir@|$(PKG_LIBEXEC_DIR)|g" \ -e "s|@pkg_state_dir@|$(PKG_STATE_DIR)|g" \ + -e "s|@media_scan_interval@|$(XFS_SCRUB_ALL_AUTO_MEDIA_SCAN_INTERVAL)|g" \ < $< > $@ %.cron: %.cron.in $(builddefs) @echo " [SED] $@" - $(Q)$(SED) -e "s|@sbindir@|$(PKG_SBIN_DIR)|g" < $< > $@ + $(Q)$(SED) -e "s|@sbindir@|$(PKG_SBIN_DIR)|g" \ + -e "s|@media_scan_interval@|$(XFS_SCRUB_ALL_AUTO_MEDIA_SCAN_INTERVAL)|g" \ + < $< > $@ install-systemd: default $(SYSTEMD_SERVICES) $(INSTALL) -m 755 -d $(SYSTEMD_SYSTEM_UNIT_DIR)
scrub/xfs_scrub_all.cron.in +1 -1
@@ -3,4 +3,4 @@ # Copyright (C) 2018-2024 Oracle. All Rights Reserved. # Author: Darrick J. Wong <[email protected]> # -10 3 * * 0 root test -e /run/systemd/system || @sbindir@/xfs_scrub_all +10 3 * * 0 root test -e /run/systemd/system || @sbindir@/xfs_scrub_all --auto-media-scan-interval @media_scan_interval@
scrub/xfs_scrub_all.service.in +1 -1
@@ -12,7 +12,7 @@ After=paths.target multi-user.target network.target network-online.target system [Service] Type=oneshot Environment=SERVICE_MODE=1 -ExecStart=@sbindir@/xfs_scrub_all +ExecStart=@sbindir@/xfs_scrub_all --auto-media-scan-interval @media_scan_interval@ SyslogIdentifier=xfs_scrub_all # Create the service underneath the scrub background service slice so that we
Re: [PATCH 5/6] xfs_scrub_all: trigger automatic media scans once per month
Looks good:
PATCH 6/6 xfs_scrub_all: failure reporting for the xfs_scrub_all job
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a failure reporting service for when xfs_scrub_all fails. This shouldn't happen often, but let's report anyways.
--- scrub/Makefile | 1 scrub/xfs_scrub_all.service.in | 1 scrub/xfs_scrub_all_fail.service.in | 71 +++++++++++++++++++++++++++++++++++ scrub/xfs_scrub_fail.in | 35 ++++++++++++++--- 4 files changed, 101 insertions(+), 7 deletions(-) create mode 100644 scrub/xfs_scrub_all_fail.service.in
scrub/Makefile +1 -0
@@ -26,6 +26,7 @@ SYSTEMD_SERVICES=\ $(scrub_media_svcname) \ [email protected] \ xfs_scrub_all.service \ + xfs_scrub_all_fail.service \ xfs_scrub_all.timer \ system-xfs_scrub.slice OPTIONAL_TARGETS += $(SYSTEMD_SERVICES)
scrub/xfs_scrub_all.service.in +1 -0
@@ -5,6 +5,7 @@ [Unit] Description=Online XFS Metadata Check for All Filesystems +OnFailure=xfs_scrub_all_fail.service ConditionACPower=true Documentation=man:xfs_scrub_all(8) After=paths.target multi-user.target network.target network-online.target systemd-networkd.service NetworkManager.service connman.service
scrub/xfs_scrub_all_fail.service.in new file +71 -0
71 lines not on this page · raw message
scrub/xfs_scrub_fail.in +28 -7
@@ -5,14 +5,13 @@ # Copyright (C) 2018-2024 Oracle. All Rights Reserved. # Author: Darrick J. Wong <[email protected]> -# Email logs of failed xfs_scrub unit runs +# Email logs of failed xfs_scrub and xfs_scrub_all unit runs recipient="$1" test -z "${recipient}" && exit 0 service="$2" test -z "${service}" && exit 0 mntpoint="$3" -test -z "${mntpoint}" && exit 0 hostname="$(hostname -f 2>/dev/null)" test -z "${hostname}" && hostname="${HOSTNAME}"
@@ -23,11 +22,13 @@ if [ ! -x "${mailer}" ]; then exit 1 fi -# Turn the mountpoint into a properly escaped systemd instance name -scrub_svc="$(systemd-escape --template "${service}@.service" --path "${mntpoint}")" +fail_mail_mntpoint() { + local scrub_svc -(cat << ENDL -To: $1 + # Turn the mountpoint into a properly escaped systemd instance name + scrub_svc="$(systemd-escape --template "${service}@.service" --path "${mntpoint}")" + cat << ENDL +To: ${recipient} From: <${service}@${hostname}> Subject: ${service} failure on ${mntpoint} Content-Transfer-Encoding: 8bit
@@ -38,5 +39,25 @@ Please do not reply to this mesage. A log of what happened follows: ENDL -systemctl status --full --lines 4294967295 "${scrub_svc}") | "${mailer}" -t -i + systemctl status --full --lines 4294967295 "${scrub_svc}" +} + +fail_mail() { + cat << ENDL +To: ${recipient} +From: <${service}@${hostname}> +Subject: ${service} failure + +So sorry, the automatic ${service} on ${hostname} failed. + +A log of what happened follows: +ENDL + systemctl status --full --lines 4294967295 "${service}" +} + +if [ -n "${mntpoint}" ]; then + fail_mail_mntpoint | "${mailer}" -t -i +else + fail_mail | "${mailer}" -t -i +fi exit "${PIPESTATUS[1]}"
Re: [PATCH 6/6] xfs_scrub_all: failure reporting for the xfs_scrub_all job
Looks good:
PATCH 8/16 xfs_scrub_all: improve systemd handling
In reply to Darrick J. WongHi all,
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-all-improve-systemd-handling
---
Commits in this patchset:
* xfs_scrub_all: encapsulate all the subprocess code in an object
* xfs_scrub_all: encapsulate all the systemctl code in an object
* xfs_scrub_all: add CLI option for easier debugging
* xfs_scrub_all: convert systemctl calls to dbus
* xfs_scrub_all: implement retry and backoff for dbus calls
--- debian/control | 2 scrub/xfs_scrub_all.in | 279 ++++++++++++++++++++++++++++++++++++------------ 2 files changed, 209 insertions(+), 72 deletions(-)
PATCH 1/5 xfs_scrub_all: encapsulate all the subprocess code in an object
From: Darrick J. Wong <[email protected]>
Move all the xfs_scrub subprocess handling code to an object so that we can contain all the details in a single place. This also simplifies the background state management.
--- scrub/xfs_scrub_all.in | 68 ++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 54 insertions(+), 14 deletions(-)
scrub/xfs_scrub_all.in +54 -14
@@ -78,15 +78,62 @@ def remove_killfunc(killfuncs, fn): except: pass -def run_killable(cmd, stdout, killfuncs): +class scrub_control(object): + '''Control object for xfs_scrub.''' + def __init__(self): + pass + + def start(self): + '''Start scrub and wait for it to complete. Returns -1 if the + service was not started, 0 if it succeeded, or 1 if it + failed.''' + assert False + + def stop(self): + '''Stop scrub.''' + assert False + +class scrub_subprocess(scrub_control): + '''Control object for xfs_scrub subprocesses.''' + def __init__(self, mnt, scrub_media): + cmd = ['@sbindir@/xfs_scrub'] + if 'SERVICE_MODE' in os.environ: + cmd += '@scrub_service_args@'.split() + cmd += '@scrub_args@'.split() + if scrub_media: + cmd += '-x' + cmd += [mnt] + self.cmdline = cmd + self.proc = None + + def start(self): + '''Start xfs_scrub and wait for it to complete. Returns -1 if + the service was not started, 0 if it succeeded, or 1 if it + failed.''' + try: + self.proc = subprocess.Popen(self.cmdline) + self.proc.wait() + except: + return -1 + + proc = self.proc + self.proc = None + return proc.returncode + + def stop(self): + '''Stop xfs_scrub.''' + if self.proc is not None: + self.proc.terminate() + +def run_subprocess(mnt, scrub_media, killfuncs): '''Run a killable program. Returns program retcode or -1 if we can't start it.''' try: - proc = subprocess.Popen(cmd, stdout = stdout) - killfuncs.add(proc.terminate) - proc.wait() - remove_killfunc(killfuncs, proc.terminate) - return proc.returncode + p = scrub_subprocess(mnt, scrub_media) + killfuncs.add(p.stop) + ret = p.start() + remove_killfunc(killfuncs, p.stop) + return ret except: return -1
@@ -188,14 +235,7 @@ def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): # Invoke xfs_scrub manually if we're running in the foreground. # We also permit this if we're running as a cronjob where # systemd services are unavailable. - cmd = ['@sbindir@/xfs_scrub'] - if 'SERVICE_MODE' in os.environ: - cmd += '@scrub_service_args@'.split() - cmd += '@scrub_args@'.split() - if scrub_media: - cmd += '-x' - cmd += [mnt] - ret = run_killable(cmd, None, killfuncs) + ret = run_subprocess(mnt, scrub_media, killfuncs) if ret >= 0: print("Scrubbing %s done, (err=%d)" % (mnt, ret)) sys.stdout.flush()
Re: [PATCH 1/5] xfs_scrub_all: encapsulate all the subprocess code in an object
Looks good:
PATCH 2/5 xfs_scrub_all: encapsulate all the systemctl code in an object
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move all the systemd service handling code to an object so that we can contain all the insanity^Wdetails in a single place. This also makes the killfuncs handling similar to starting background processes.
--- scrub/xfs_scrub_all.in | 113 ++++++++++++++++++++++++++---------------------- 1 file changed, 61 insertions(+), 52 deletions(-)
scrub/xfs_scrub_all.in +61 -52
@@ -149,63 +149,73 @@ def path_to_serviceunit(path, scrub_media): svcname = '@scrub_svcname@' cmd = ['systemd-escape', '--template', svcname, '--path', path] - try: - proc = subprocess.Popen(cmd, stdout = subprocess.PIPE) - proc.wait() - for line in proc.stdout: - return line.decode(sys.stdout.encoding).strip() - except: - return None + proc = subprocess.Popen(cmd, stdout = subprocess.PIPE) + proc.wait() + for line in proc.stdout: + return line.decode(sys.stdout.encoding).strip() -def systemctl_stop(unitname): - '''Stop a systemd unit.''' - cmd = ['systemctl', 'stop', unitname] - x = subprocess.Popen(cmd) - x.wait() +class scrub_service(scrub_control): + '''Control object for xfs_scrub systemd service.''' + def __init__(self, mnt, scrub_media): + self.unitname = path_to_serviceunit(mnt, scrub_media) -def systemctl_start(unitname, killfuncs): - '''Start a systemd unit and wait for it to complete.''' - stop_fn = None - cmd = ['systemctl', 'start', unitname] - try: - proc = subprocess.Popen(cmd, stdout = DEVNULL()) - stop_fn = lambda: systemctl_stop(unitname) - killfuncs.add(stop_fn) - proc.wait() - ret = proc.returncode - except: - if stop_fn is not None: - remove_killfunc(killfuncs, stop_fn) - return -1 + def wait(self, interval = 1): + '''Wait until the service finishes.''' - if ret != 1: - remove_killfunc(killfuncs, stop_fn) - return ret + # As of systemd 249, the is-active command returns any of the + # following states: active, reloading, inactive, failed, + # activating, deactivating, or maintenance. Apparently these + # strings are not localized. + while True: + try: + for l in backtick(['systemctl', 'is-active', self.unitname]): + if l == 'failed': + return 1 + if l == 'inactive': + return 0 + except: + return -1 - # If systemctl-start returns 1, it's possible that the service failed - # or that dbus/systemd restarted and the client program lost its - # connection -- according to the systemctl man page, 1 means "unit not - # failed". - # - # Either way, we switch to polling the service status to try to wait - # for the service to end. As of systemd 249, the is-active command - # returns any of the following states: active, reloading, inactive, - # failed, activating, deactivating, or maintenance. Apparently these - # strings are not localized. - while True: + time.sleep(interval) + + def start(self): + '''Start the service and wait for it to complete. Returns -1 + if the service was not started, 0 if it succeeded, or 1 if it + failed.''' + cmd = ['systemctl', 'start', self.unitname] try: - for l in backtick(['systemctl', 'is-active', unitname]): - if l == 'failed': - remove_killfunc(killfuncs, stop_fn) - return 1 - if l == 'inactive': - remove_killfunc(killfuncs, stop_fn) - return 0 + proc = subprocess.Popen(cmd, stdout = DEVNULL()) + proc.wait() + ret = proc.returncode except: - remove_killfunc(killfuncs, stop_fn) return -1 - time.sleep(1) + if ret != 1: + return ret + + # If systemctl-start returns 1, it's possible that the service + # failed or that dbus/systemd restarted and the client program + # lost its connection -- according to the systemctl man page, 1 + # means "unit not failed". + return self.wait() + + def stop(self): + '''Stop the service.''' + cmd = ['systemctl', 'stop', self.unitname] + x = subprocess.Popen(cmd) + x.wait() + +def run_service(mnt, scrub_media, killfuncs): + '''Run scrub as a service.''' + try: + svc = scrub_service(mnt, scrub_media) + except: + return -1 + + killfuncs.add(svc.stop) + retcode = svc.start() + remove_killfunc(killfuncs, svc.stop) + return retcode def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): '''Run a scrub process.'''
@@ -220,9 +230,8 @@ def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): # Run per-mount systemd xfs_scrub service only if we ourselves # are running as a systemd service. - unitname = path_to_serviceunit(path, scrub_media) - if unitname is not None and 'SERVICE_MODE' in os.environ: - ret = systemctl_start(unitname, killfuncs) + if 'SERVICE_MODE' in os.environ: + ret = run_service(mnt, scrub_media, killfuncs) if ret == 0 or ret == 1: print("Scrubbing %s done, (err=%d)" % (mnt, ret)) sys.stdout.flush()
Re: [PATCH 2/5] xfs_scrub_all: encapsulate all the systemctl code in an object
Looks good:
PATCH 3/5 xfs_scrub_all: add CLI option for easier debugging
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a new CLI argument to make it easier to figure out what exactly the program is doing.
--- scrub/xfs_scrub_all.in | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-)
scrub/xfs_scrub_all.in +24 -1
@@ -24,6 +24,7 @@ from datetime import timezone retcode = 0 terminate = False scrub_media = False +debug = False def DEVNULL(): '''Return /dev/null in subprocess writable format.'''
@@ -110,6 +111,11 @@ class scrub_subprocess(scrub_control): '''Start xfs_scrub and wait for it to complete. Returns -1 if the service was not started, 0 if it succeeded, or 1 if it failed.''' + global debug + + if debug: + print('run ', ' '.join(self.cmdline)) + try: self.proc = subprocess.Popen(self.cmdline) self.proc.wait()
@@ -122,6 +128,10 @@ class scrub_subprocess(scrub_control): def stop(self): '''Stop xfs_scrub.''' + global debug + + if debug: + print('kill ', ' '.join(self.cmdline)) if self.proc is not None: self.proc.terminate()
@@ -182,8 +192,12 @@ class scrub_service(scrub_control): '''Start the service and wait for it to complete. Returns -1 if the service was not started, 0 if it succeeded, or 1 if it failed.''' + global debug + cmd = ['systemctl', 'start', self.unitname] try: + if debug: + print(' '.join(cmd)) proc = subprocess.Popen(cmd, stdout = DEVNULL()) proc.wait() ret = proc.returncode
@@ -201,7 +215,11 @@ class scrub_service(scrub_control): def stop(self): '''Stop the service.''' + global debug + cmd = ['systemctl', 'stop', self.unitname] + if debug: + print(' '.join(cmd)) x = subprocess.Popen(cmd) x.wait()
@@ -366,10 +384,12 @@ def main(): a = (mnt, cond, running_devs, devs, killfuncs) thr = threading.Thread(target = run_scrub, args = a) thr.start() - global retcode, terminate, scrub_media + global retcode, terminate, scrub_media, debug parser = argparse.ArgumentParser( \ description = "Scrub all mounted XFS filesystems.") + parser.add_argument("--debug", help = "Enabling debugging messages.", \ + action = "store_true") parser.add_argument("-V", help = "Report version and exit.", \ action = "store_true") parser.add_argument("-x", help = "Scrub file data after filesystem metadata.", \
@@ -384,6 +404,9 @@ def main(): print("xfs_scrub_all version @pkg_version@") sys.exit(0) + if args.debug: + debug = True + if args.auto_media_scan_interval is not None: try: scrub_media = enable_automatic_media_scan(args)
Re: [PATCH 3/5] xfs_scrub_all: add CLI option for easier debugging
Looks good:
PATCH 4/5 xfs_scrub_all: convert systemctl calls to dbus
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert the systemctl invocations to direct dbus calls, which decouples us from the CLI in favor of direct API calls. This spares us from some of the insanity of divining service state from program outputs.
--- debian/control | 2 + scrub/xfs_scrub_all.in | 96 +++++++++++++++++++++++++++++++----------------- 2 files changed, 63 insertions(+), 35 deletions(-)
debian/control +1 -1
@@ -8,7 +8,7 @@ Standards-Version: 4.0.0 Homepage: https://xfs.wiki.kernel.org/ Package: xfsprogs -Depends: ${shlibs:Depends}, ${misc:Depends}, python3:any +Depends: ${shlibs:Depends}, ${misc:Depends}, python3-dbus, python3:any Provides: fsck-backend Suggests: xfsdump, acl, attr, quota Breaks: xfsdump (<< 3.0.0)
scrub/xfs_scrub_all.in +62 -34
127 lines not on this page · raw message
Re: [PATCH 4/5] xfs_scrub_all: convert systemctl calls to dbus
Looks good:
PATCH 5/5 xfs_scrub_all: implement retry and backoff for dbus calls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Calls to systemd across dbus are remote procedure calls, which means that they're subject to transitory connection failures (e.g. systemd re-exec itself). We don't want to fail at the *first* sign of what could be temporary trouble, so implement a limited retry with fibonacci backoff before we resort to invoking xfs_scrub as a subprocess.
--- scrub/xfs_scrub_all.in | 43 ++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 40 insertions(+), 3 deletions(-)
scrub/xfs_scrub_all.in +40 -3
@@ -165,6 +165,22 @@ def path_to_serviceunit(path, scrub_media): for line in proc.stdout: return line.decode(sys.stdout.encoding).strip() +def fibonacci(max_ret): + '''Yield fibonacci sequence up to but not including max_ret.''' + if max_ret < 1: + return + + x = 0 + y = 1 + yield 1 + + z = x + y + while z <= max_ret: + yield z + x = y + y = z + z = x + y + class scrub_service(scrub_control): '''Control object for xfs_scrub systemd service.''' def __init__(self, mnt, scrub_media):
@@ -188,6 +204,25 @@ class scrub_service(scrub_control): self.unit = dbus.Interface(svc_obj, 'org.freedesktop.systemd1.Unit') + def __dbusrun(self, lambda_fn): + '''Call the lambda function to execute something on dbus. dbus + exceptions result in retries with Fibonacci backoff, and the + bindings will be rebuilt every time.''' + global debug + + fatal_ex = None + + for i in fibonacci(30): + try: + return lambda_fn() + except dbus.exceptions.DBusException as e: + if debug: + print(e) + fatal_ex = e + time.sleep(i) + self.bind() + raise fatal_ex + def state(self): '''Retrieve the active state for a systemd service. As of systemd 249, this is supposed to be one of the following:
@@ -195,8 +230,10 @@ class scrub_service(scrub_control): or "deactivating". These strings are not localized.''' global debug + l = lambda: self.prop.Get('org.freedesktop.systemd1.Unit', + 'ActiveState') try: - return self.prop.Get('org.freedesktop.systemd1.Unit', 'ActiveState') + return self.__dbusrun(l) except Exception as e: if debug: print(e, file = sys.stderr)
@@ -231,7 +268,7 @@ class scrub_service(scrub_control): print('starting %s' % self.unitname) try: - self.unit.Start('replace') + self.__dbusrun(lambda: self.unit.Start('replace')) return self.wait() except Exception as e: print(e, file = sys.stderr)
@@ -245,7 +282,7 @@ class scrub_service(scrub_control): print('stopping %s' % self.unitname) try: - self.unit.Stop('replace') + self.__dbusrun(lambda: self.unit.Stop('replace')) return self.wait() except Exception as e: print(e, file = sys.stderr)
Re: [PATCH 5/5] xfs_scrub_all: implement retry and backoff for dbus calls
Looks good:
PATCH 9/16 xfs_scrub: automatic optimization by default
In reply to Darrick J. WongHi all,
This final patchset in the online fsck series enables the background service to optimize filesystems by default. This is the first step towards enabling repairs by default.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=scrub-optimize-by-default
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=scrub-optimize-by-default
---
Commits in this patchset:
* xfs_scrub: automatic downgrades to dry-run mode in service mode
* xfs_scrub: add an optimization-only mode
* debian: enable xfs_scrub_all systemd timer services by default
--- debian/rules | 2 +- man/man8/xfs_scrub.8 | 6 +++++- scrub/Makefile | 2 +- scrub/phase1.c | 13 +++++++++++++ scrub/phase4.c | 6 ++++++ scrub/repair.c | 37 ++++++++++++++++++++++++++++++++++++- scrub/repair.h | 2 ++ scrub/scrub.c | 4 ++-- scrub/xfs_scrub.c | 21 +++++++++++++++++++-- scrub/xfs_scrub.h | 1 + 10 files changed, 86 insertions(+), 8 deletions(-)
PATCH 1/3 xfs_scrub: automatic downgrades to dry-run mode in service mode
From: Darrick J. Wong <[email protected]>
When service mode is enabled, xfs_scrub is being run within the context of a systemd service. The service description language doesn't have any particularly good constructs for adding in a '-n' argument if the filesystem is readonly, which means that xfs_scrub is passed a path, and needs to switch to dry-run mode on its own if the fs is mounted readonly or the kernel doesn't support repairs.
--- scrub/phase1.c | 13 +++++++++++++ scrub/repair.c | 33 +++++++++++++++++++++++++++++++++ scrub/repair.h | 2 ++ 3 files changed, 48 insertions(+)
scrub/phase1.c +13 -0
@@ -216,6 +216,19 @@ _("Kernel metadata scrubbing facility is not available."));return ECANCELED ; } +/* +* Normally, callers are required to pass -n if the provided path is a +* readonly filesystem or the kernel wasn't built with online repair +* enabled. However, systemd services are not scripts and cannot +* determine either of these conditions programmatically. Change the +* behavior to dry-run mode if either condition is detected. +*/ +if (repair_want_service_downgrade (ctx)) { +str_info (ctx, ctx->mntpoint, +_ ("Filesystem cannot be repaired in service mode, downgrading to dry-run mode." )); + ctx->mode =SCRUB_MODE_DRY_RUN ; + } +/* Do we need kernel-assisted metadata repair? */ if (ctx->mode !=SCRUB_MODE_DRY_RUN && !can_repair (ctx)) { str_error(ctx, ctx->mntpoint,
scrub/repair.c +33 -0
@@ -45,6 +45,39 @@ static const unsigned int repair_deps[XFS_SCRUB_TYPE_NR] = { };#undef DEP +/* +* Decide if we want an automatic downgrade to dry-run mode. This is only +* for service mode, where we are fed a path and have to figure out if the fs +* is repairable or not. +*/ +bool +repair_want_service_downgrade ( +struct scrub_ctx *ctx) +{ +struct xfs_scrub_metadata meta = { + .sm_type =XFS_SCRUB_TYPE_PROBE , + .sm_flags =XFS_SCRUB_IFLAG_REPAIR , + }; +int error; + +if (ctx->mode ==SCRUB_MODE_DRY_RUN ) +return false; +if (!is_service) +return false; +if (debug_tweak_on ("XFS_SCRUB_NO_KERNEL" )) +return false; + + error = -xfrog_scrub_metadata (&ctx->mnt, &meta); +switch (error) { +case EROFS : +case ENOTRECOVERABLE : +case EOPNOTSUPP : +return true; + } + +return false; +} +/* Repair some metadata. */ static int xfs_repair_metadata(
scrub/repair.h +2 -0
@@ -102,4 +102,6 @@ repair_item_completely( return repair_item(ctx, sri, XRM_FINAL_WARNING | XRM_NOPROGRESS); } +bool repair_want_service_downgrade (struct scrub_ctx *ctx); +#endif /* XFS_SCRUB_REPAIR_H_ */
Re: [PATCH 1/3] xfs_scrub: automatic downgrades to dry-run mode in service mode
Looks good:
PATCH 2/3 xfs_scrub: add an optimization-only mode
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a "preen" mode in which we only optimize filesystem metadata. Repairs will result in early exits.
--- man/man8/xfs_scrub.8 | 6 +++++- scrub/Makefile | 2 +- scrub/phase4.c | 6 ++++++ scrub/repair.c | 4 +++- scrub/scrub.c | 4 ++-- scrub/xfs_scrub.c | 21 +++++++++++++++++++-- scrub/xfs_scrub.h | 1 + 7 files changed, 37 insertions(+), 7 deletions(-)
man/man8/xfs_scrub.8 +5 -1
@@ -4,7 +4,7 @@ xfs_scrub \- check and repair the contents of a mounted XFS filesystem .SH SYNOPSIS .B xfs_scrub [ -.B \-abCeMmnTvx +.B \-abCeMmnpTvx ] .I mount-point .br
@@ -128,6 +128,10 @@ Treat informational messages as warnings. This will result in a nonzero return code, and a higher logging level. .RE .TP +.B \-p +Only optimize filesystem metadata. +If repairs are required, report them and exit. +.TP .BI \-T Print timing and memory usage information for each phase. .TP
scrub/Makefile +1 -1
@@ -16,7 +16,7 @@ LTCOMMAND = xfs_scrub INSTALL_SCRUB = install-scrub XFS_SCRUB_ALL_PROG = xfs_scrub_all XFS_SCRUB_FAIL_PROG = xfs_scrub_fail -XFS_SCRUB_ARGS = -n +XFS_SCRUB_ARGS = -p XFS_SCRUB_SERVICE_ARGS = -b ifeq ($(HAVE_SYSTEMD),yes) INSTALL_SCRUB += install-systemd
scrub/phase4.c +6 -0
@@ -240,6 +240,12 @@ phase4_func( action_list_empty(ctx->file_repair_list))return 0 ; +if (ctx->mode ==SCRUB_MODE_PREEN && ctx->corruptions_found) { +str_info (ctx, ctx->mntpoint, +_ ("Corruptions found; will not optimize. Re-run without -p.\n" )); +return 0 ; + } +/* * Check the resource usage counters early. Normally we do this during * phase 7, but some of the cross-referencing requires fairly accurate
scrub/repair.c +3 -1
@@ -651,7 +651,9 @@ repair_item_class(unsigned int scrub_type;int error =0 ; -if (ctx->mode <SCRUB_MODE_REPAIR ) +if (ctx->mode ==SCRUB_MODE_DRY_RUN ) +return 0 ; +if (ctx->mode ==SCRUB_MODE_PREEN && !(repair_mask &SCRUB_ITEM_PREEN ))return 0 ;/*
scrub/scrub.c +2 -2
@@ -174,7 +174,7 @@ _("Filesystem is shut down, aborting."));* repair if desired, otherwise complain. */ if (is_corrupt (&meta) ||xref_disagrees (&meta)) { -if (ctx->mode <SCRUB_MODE_REPAIR ) { +if (ctx->mode !=SCRUB_MODE_REPAIR ) {/* Dry-run mode, so log an error and forget it. */ str_corrupt (ctx,descr_render (&dsc),_ ("Repairs are required." ));
@@ -192,7 +192,7 @@ _("Repairs are required."));* otherwise complain. */ if (is_unoptimized (&meta)) { -if (ctx->mode !=SCRUB_MODE_REPAIR ) { +if (ctx->mode ==SCRUB_MODE_DRY_RUN ) {/* Dry-run mode, so log an error and forget it. */ if (group !=XFROG_SCRUB_GROUP_INODE ) {/* AG or FS metadata, always warn. */
scrub/xfs_scrub.c +19 -2
@@ -183,6 +183,7 @@ usage(void)fprintf (stderr,_ (" -k Do not FITRIM the free space.\n" ));fprintf (stderr,_ (" -m path Path to /etc/mtab.\n" ));fprintf (stderr,_ (" -n Dry run. Do not modify anything.\n" )); +fprintf (stderr,_ (" -p Only optimize, do not fix corruptions.\n" ));fprintf (stderr,_ (" -T Display timing/usage information.\n" ));fprintf (stderr,_ (" -v Verbose output.\n" ));fprintf (stderr,_ (" -V Print version.\n" ));
@@ -463,6 +464,11 @@ run_scrub_phases( sp->descr =_ ("Repair filesystem." ); sp->fn = phase4_func; sp->must_run = true; + }else if (sp->fn ==REPAIR_DUMMY_FN && + ctx->mode ==SCRUB_MODE_PREEN ) { + sp->descr =_ ("Optimize filesystem." ); + sp->fn = phase4_func; + sp->must_run = true; }/* Skip certain phases unless they're turned on. */
@@ -601,7 +607,7 @@ report_outcome(if (ctx->scrub_setup_succeeded && actionable_errors >0 ) {char *msg; -if (ctx->mode ==SCRUB_MODE_DRY_RUN ) +if (ctx->mode !=SCRUB_MODE_REPAIR ) msg =_ ("%s: Re-run xfs_scrub without -n.\n" );else msg =_ ("%s: Unmount and run xfs_repair.\n" );
@@ -725,7 +731,7 @@ main(pthread_mutex_init (&ctx.lock,NULL ); ctx.mode =SCRUB_MODE_REPAIR ; ctx.error_action =ERRORS_CONTINUE ; -while ((c =getopt (argc, argv,"a:bC:de:kM:m:no:TvxV" )) !=EOF ) { +while ((c =getopt (argc, argv,"a:bC:de:kM:m:no:pTvxV" )) !=EOF ) {switch (c) {case 'a' : ctx.max_errors =cvt_u64 (optarg,10 );
@@ -776,11 +782,22 @@ main( mtab = optarg;break ;case 'n' : +if (ctx.mode !=SCRUB_MODE_REPAIR ) { +fprintf (stderr,_ ("Cannot use -n with -p.\n" )); +usage (); + } ctx.mode =SCRUB_MODE_DRY_RUN ;break ;case 'o' :parse_o_opts (&ctx, optarg);break ; +case 'p' : +if (ctx.mode !=SCRUB_MODE_REPAIR ) { +fprintf (stderr,_ ("Cannot use -p with -n.\n" )); +usage (); + } + ctx.mode =SCRUB_MODE_PREEN ; +break ;case 'T' : display_rusage = true;break ;
scrub/xfs_scrub.h +1 -0
@@ -27,6 +27,7 @@ extern bool info_is_warning;enum scrub_mode {SCRUB_MODE_DRY_RUN , +SCRUB_MODE_PREEN ,SCRUB_MODE_REPAIR , };
Re: [PATCH 2/3] xfs_scrub: add an optimization-only mode
Looks good:
PATCH 3/3 debian: enable xfs_scrub_all systemd timer services by default
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we're finished building online fsck, enable the periodic background scrub service by default. This involves the postinst script starting the resource management slice and the timer.
No other sub-services need to be enabled or unmasked explicitly. They also shouldn't be started or restarted because that might interrupt background operation unnecessarily.
--- debian/rules | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
debian/rules +1 -1
@@ -114,7 +114,7 @@ binary-arch: checkroot built dh_compress dh_fixperms dh_makeshlibs - dh_installsystemd -p xfsprogs --no-enable --no-start --no-restart-after-upgrade --no-stop-on-upgrade + dh_installsystemd -p xfsprogs --no-restart-after-upgrade --no-stop-on-upgrade system-xfs_scrub.slice xfs_scrub_all.timer dh_installdeb dh_shlibdeps dh_gencontrol
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that we're finished building online fsck, enable the periodic background scrub service by default. This involves the postinst script starting the resource management slice and the timer.
No other sub-services need to be enabled or unmasked explicitly. They also shouldn't be started or restarted because that might interrupt background operation unnecessarily.
I'm still not sure we quite want to run this by default on all debian systems. Are you ready to handle all the bug reports from people complaining about the I/O load?
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 7 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that we're finished building online fsck, enable the periodic background scrub service by default. This involves the postinst script starting the resource management slice and the timer.
Quoted 7 lines
Quoted 3 lines
No other sub-services need to be enabled or unmasked explicitly. They also shouldn't be started or restarted because that might interrupt background operation unnecessarily.
I'm still not sure we quite want to run this by default on all debian systems. Are you ready to handle all the bug reports from people complaining about the I/O load?
CONFIG_XFS_ONLINE_SCRUB isn't turned on for the 6.9.7 kernel in sid, so there shouldn't be any complaints until we ask the kernel team to enable it. I don't think we should ask Debian to do that until after they lift the debian 13 freeze next year/summer/whenever.
--D
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 4 lines · Darrick J. Wong
CONFIG_XFS_ONLINE_SCRUBisn't turned on for the 6.9.7 kernel in sid, so there shouldn't be any complaints until we ask the kernel team to enable it. I don't think we should ask Debian to do that until after they lift the debian 13 freeze next year/summer/whenever.
I'm not entirely sure if we should ever do this by default. The right fit to me would be on of those questions asked during apt-get upgrade to enable/disable things. But don't ask me how those are implemented or even called.
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 10 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
CONFIG_XFS_ONLINE_SCRUBisn't turned on for the 6.9.7 kernel in sid, so there shouldn't be any complaints until we ask the kernel team to enable it. I don't think we should ask Debian to do that until after they lift the debian 13 freeze next year/summer/whenever.I'm not entirely sure if we should ever do this by default. The right fit to me would be on of those questions asked during apt-get upgrade to enable/disable things. But don't ask me how those are implemented or even called.
Some debconf magicks that I don't understand. :(
A more declarative-happy way would be to make a subpackage that turns on the background service, so the people that want it on by default can add "Depends: xfsprogs-background-scrub" to their ... uh ... ansible? puppet? orchestration system.
--D
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 7 lines · Darrick J. Wong
Quoted 6 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
CONFIG_XFS_ONLINE_SCRUBisn't turned on for the 6.9.7 kernel in sid, so there shouldn't be any complaints until we ask the kernel team to enable it. I don't think we should ask Debian to do that until after they lift the debian 13 freeze next year/summer/whenever.
Quoted 6 lines
Quoted 4 lines
I'm not entirely sure if we should ever do this by default. The right fit to me would be on of those questions asked during apt-get upgrade to enable/disable things. But don't ask me how those are implemented or even called.
Some debconf magicks that I don't understand. :(
A week's worth of digging later:
Actually, no debconf magic -- Debian policy is to enable any service shipped in a package, by default:
https://www.debian.org/doc/debian-policy/ch-opersys.html#starting-system-services
"Debian packages that provide system services should arrange for those services to be automatically started and stopped by the init system or service manager."
It's up to the sysadmin to disable this behavior, either by installing their own systemd preset file:
https://manpages.debian.org/bookworm/systemd/systemd.preset.5.en.html
that shuts off the services they don't want (or more likely enables only the ones they do want). Other people have proposed rc.d hacks:
https://packages.debian.org/bookworm/policy-rcd-declarative-deny-all
which prevent the postinst scripts from actually triggering the service.
Quoted 4 lines
A more declarative-happy way would be to make a subpackage that turns on the background service, so the people that want it on by default can add "Depends: xfsprogs-background-scrub" to their ... uh ... ansible? puppet? orchestration system.
Though I guess we /could/ decide to ship only the xfs_scrub_all.{service,timer} files in a totally separate package. But that will make packaging more difficult because now we have to have per-package .install files so that debconf knows where to put the files, and then we have to split the package scripts too.
On Fedora it's apparently the other way 'round where one has to turn on services manually.
--D
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 8 lines · Darrick J. Wong
Though I guess we /could/ decide to ship only the xfs_scrub_all.{service,timer} files in a totally separate package. But that will make packaging more difficult because now we have to have per-package .install files so that debconf knows where to put the files, and then we have to split the package scripts too.
On Fedora it's apparently the other way 'round where one has to turn on services manually.
Heh. I'm still worried about scrub just being automatically run without the user asking for it.
How about something different: add a new autoscrub mount option, which the kernel simply ignores, but which the scrub daemon uses to figure out if it should scrub a file system?
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 10 lines · Christoph Hellwig
Quoted 8 lines · Darrick J. Wong
Though I guess we /could/ decide to ship only the xfs_scrub_all.{service,timer} files in a totally separate package. But that will make packaging more difficult because now we have to have per-package .install files so that debconf knows where to put the files, and then we have to split the package scripts too.
On Fedora it's apparently the other way 'round where one has to turn on services manually.
Quoted 6 lines
Heh. I'm still worried about scrub just being automatically run without the user asking for it.
How about something different: add a new autoscrub mount option, which the kernel simply ignores, but which the scrub daemon uses to figure out if it should scrub a file system?
Hm, xfs could do that, but that would clutter up the mount options. Or perhaps the systemd service could look for $mountpoint/.autoheal or something.
It might be easier still to split the packages, let me send an RFC of what that looks like.
--D
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 6 lines · Darrick J. Wong
Hm, xfs could do that, but that would clutter up the mount options. Or perhaps the systemd service could look for $mountpoint/.autoheal or something.
It might be easier still to split the packages, let me send an RFC of what that looks like.
So I think the package split makes sense no matter what we do, but I really want a per file system choice and not a global one.
As a fіle system developer I always have scratch file systems around that I definitely never want checked. I'd also prefer scrub to not randomly start checking external file system that are only temporarily mounted and that I want to remove again.
Maybe we'll indeed want some kind of marker in the file system.
Btw, the code in scrub_all that parses lsblk output to find file systems also looks a bit odd. I'd expect it to use whatever is the python equivalent of setmntent/getmntent on /proc/self/mounts.
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 10 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
Hm, xfs could do that, but that would clutter up the mount options. Or perhaps the systemd service could look for $mountpoint/.autoheal or something.
It might be easier still to split the packages, let me send an RFC of what that looks like.
So I think the package split makes sense no matter what we do, but I really want a per file system choice and not a global one.
<nod> How might we do that?
1. touch $mnt/.selfheal to opt-in to online fsck?
2. touch $mnt/.noselfheal to opt-out?
3. attr -s system.selfheal to opt in?
4. attr -s system.noselfheal to opt out?
5. compat feature to opt-in
6. compat feature to opt-out?
7. filesystem property that we stuff in the metadir?
1-2 most resemble the old /.forcefsck knob, and systemd has ConditionPathExists= that we could use to turn an xfs_scrub@<path> service invocation into a nop.
3-4 don't clutter up the root filesystem with dotfiles, but then if we ever reset the root directory then the selfheal property is lost.
5-6 might be my preferred way, but then I think I have to add a fsgeom flag so that userspace can detect the selfheal preferences.
7 is a special snowflake currently :P
Other issues:
a. Are there really two bits that we might want to store in the *heal attribute?
00 == never allow online fsck at all
01 == allow invocations of xfs_scrub but don't let xfs_scrub_all
invoke it
11 == allow all invocations of online fsck
and probably useless:
10 == allow invocations of xfs_scrub only from xfs_scrub_all
b. Adding these knobs means more userspace code to manage them. 1-4 can be done easily in xfs_admin, 5-8 involve a new ioctl and io/db code.
c. 1-4 can be lost if something torches the root directory. Is that ok? 7 also has that problem, but as nobody's really designed a filesystem properties feature, I don't know if that's acceptable.
Quoted 4 lines
As a fіle system developer I always have scratch file systems around that I definitely never want checked. I'd also prefer scrub to not randomly start checking external file system that are only temporarily mounted and that I want to remove again.
Another thing I need to figure out if systemd has a handy way of terminating a service as a "prerequisite" to "stopping" a mount. Right now you can unmount an fs that's being scrubbed from your mount hierarchy, but the service keeps running and the mount is still active.
Quoted 5 lines
Maybe we'll indeed want some kind of marker in the file system.
Btw, the code in
scrub_allthat parses lsblk output to find file systems also looks a bit odd. I'd expect it to use whatever is the python equivalent of setmntent/getmntent on/proc/self/mounts.
It parses the lsblk json output so that it can trace all the xfs mounts back to raw block devices so that it can try to kick off as many scrubs in parallel as it can so long as no two scrubs will hit the same bdev.
--D
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 13 lines · Darrick J. Wong
Quoted 2 lines
So I think the package split makes sense no matter what we do, but I really want a per file system choice and not a global one.
<nod> How might we do that?
1. touch $mnt/.selfheal to opt-in to online fsck?
2. touch $mnt/.noselfheal to opt-out?
3. attr -s system.selfheal to opt in?
4. attr -s system.noselfheal to opt out?
5. compat feature to opt-in
6. compat feature to opt-out?
7. filesystem property that we stuff in the metadir?
Quoted 6 lines
1-2 most resemble the old /.forcefsck knob, and systemd has ConditionPathExists= that we could use to turn an xfs_scrub@<path> service invocation into a nop.
3-4 don't clutter up the root filesystem with dotfiles, but then if we ever reset the root directory then the selfheal property is lost.
All four of of them are kinda scary that the contents of the file systems affects policy. Now maybe we should never chown the root directory to an untrusted or not fully trusted user, but..
Quoted 2 lines
5-6 might be my preferred way, but then I think I have to add a fsgeom flag so that userspace can detect the selfheal preferences.
These actually sound like the most sensible to me, even if the flags are of course a little annoying.
Quoted 2 lines
b. Adding these knobs means more userspace code to manage them. 1-4 can be done easily in
xfs_admin, 5-8 involve a new ioctl and io/db code.
Yeah, that's kindof the downside.
The other option would of course be some kind of global table in /etc.
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 31 lines · Christoph Hellwig
Quoted 13 lines · Darrick J. Wong
Quoted 2 lines
So I think the package split makes sense no matter what we do, but I really want a per file system choice and not a global one.
<nod> How might we do that?
1. touch $mnt/.selfheal to opt-in to online fsck?
2. touch $mnt/.noselfheal to opt-out?
3. attr -s system.selfheal to opt in?
4. attr -s system.noselfheal to opt out?
5. compat feature to opt-in
6. compat feature to opt-out?
7. filesystem property that we stuff in the metadir?Quoted 6 lines
1-2 most resemble the old /.forcefsck knob, and systemd has ConditionPathExists= that we could use to turn an xfs_scrub@<path> service invocation into a nop.
3-4 don't clutter up the root filesystem with dotfiles, but then if we ever reset the root directory then the selfheal property is lost.
All four of of them are kinda scary that the contents of the file systems affects policy. Now maybe we should never chown the root directory to an untrusted or not fully trusted user, but..
Quoted 2 lines
5-6 might be my preferred way, but then I think I have to add a fsgeom flag so that userspace can detect the selfheal preferences.
These actually sound like the most sensible to me, even if the flags are of course a little annoying.
Quoted 6 lines
Quoted 2 lines
b. Adding these knobs means more userspace code to manage them. 1-4 can be done easily in
xfs_admin, 5-8 involve a new ioctl and io/db code.Yeah, that's kindof the downside.
The other option would of course be some kind of global table in /etc.
You could also do:
for x in <ephemeral mountpoints>; do
systemctl mask xfs_scrub@$(systemd-escape --path $x)
done
(Though iirc xfs_scrub_all currently treats masked services as failures; maybe it shouldn't.)
--D
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 5 lines · Darrick J. Wong
You could also do:
for x in <ephemeral mountpoints>; do
systemctl mask xfs_scrub@$(systemd-escape --path $x)done
That assumes I actually know about them.
Quoted 2 lines
(Though iirc
xfs_scrub_allcurrently treats masked services as failures; maybe it shouldn't.)
Independent of the rest of the discussion it probably shouldn't.
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 8 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
You could also do:
for x in <ephemeral mountpoints>; do
systemctl mask xfs_scrub@$(systemd-escape --path $x)done
That assumes I actually know about them.
True. So, do we want a compat flag to opt in to online fsck? Or one to opt out? Or perhaps filesystems without rmap or pptrs aren't worth autoscrubbing?
Quoted 4 lines
Quoted 2 lines
(Though iirc
xfs_scrub_allcurrently treats masked services as failures; maybe it shouldn't.)Independent of the rest of the discussion it probably shouldn't.
Fixed; will have a patch out shortly.
--D
Re: [PATCH 3/3] debian: enable xfs_scrub_all systemd timer services by default
Quoted 8 lines · Darrick J. Wong
Quoted 7 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
You could also do:
for x in <ephemeral mountpoints>; do
systemctl mask xfs_scrub@$(systemd-escape --path $x)done
Quoted 5 lines
Quoted 1 line
That assumes I actually know about them.
True. So, do we want a compat flag to opt in to online fsck? Or one to opt out? Or perhaps filesystems without rmap or pptrs aren't worth autoscrubbing?
I think an explicit flag is definitively the right interface, and it seems like a compat flag is so far the least bad variant. Note that the flag should just be about automatic online fsck - any explicit user call to xfs_scrub should not be affected.
Quoted 1 line
RFC PATCH 1/2 misc: shift install targets
In reply to Christoph HellwigFrom: Darrick J. Wong <[email protected]>
Modify each Makefile so that "install-pkg" installs the main package contents, and "install" just invokes "install-pkg". We'll need this indirection for the next patch where we add an install-selfheal target to build the xfsprogs-self-healing package but will still want 'make install' to install everything on a developer's workstation.
--- Makefile | 8 +++++--- copy/Makefile | 4 +++- db/Makefile | 4 +++- debian/Makefile | 4 +++- debian/rules | 2 +- doc/Makefile | 4 +++- estimate/Makefile | 4 +++- fsck/Makefile | 4 +++- fsr/Makefile | 4 +++- growfs/Makefile | 4 +++- include/Makefile | 4 +++- io/Makefile | 4 +++- libfrog/Makefile | 2 +- libhandle/Makefile | 4 +++- libxcmd/Makefile | 2 +- libxfs/Makefile | 4 +++- libxlog/Makefile | 2 +- logprint/Makefile | 4 +++- m4/Makefile | 2 +- man/Makefile | 8 +++++--- man/man2/Makefile | 4 +++- man/man3/Makefile | 4 +++- man/man5/Makefile | 5 ++++- man/man8/Makefile | 4 +++- mdrestore/Makefile | 4 +++- mkfs/Makefile | 4 +++- po/Makefile | 4 +++- quota/Makefile | 4 +++- repair/Makefile | 4 +++- rtcp/Makefile | 4 +++- scrub/Makefile | 4 +++- spaceman/Makefile | 4 +++- 32 files changed, 91 insertions(+), 36 deletions(-)
Makefile +5 -3
@@ -116,15 +116,17 @@ configure: configure.ac include/builddefs: configure ./configure $$LOCAL_CONFIGURE_OPTIONS -install: $(addsuffix -install,$(SUBDIRS)) +install: install-pkg + +install-pkg: $(addsuffix -install-pkg,$(SUBDIRS)) $(INSTALL) -m 755 -d $(PKG_DOC_DIR) $(INSTALL) -m 644 README $(PKG_DOC_DIR) install-dev: $(addsuffix -install-dev,$(SUBDIRS)) -%-install: +%-install-pkg: @echo "Installing $@" - $(Q)$(MAKE) $(MAKEOPTS) -C $* install + $(Q)$(MAKE) $(MAKEOPTS) -C $* install-pkg %-install-dev: @echo "Installing $@"
copy/Makefile +3 -1
@@ -18,7 +18,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
db/Makefile +3 -1
@@ -81,7 +81,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) $(INSTALL) -m 755 xfs_admin.sh $(PKG_SBIN_DIR)/xfs_admin
debian/Makefile +3 -1
@@ -15,7 +15,9 @@ default: include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default ifeq ($(PKG_DISTRIBUTION), debian) $(INSTALL) -m 755 -d $(PKG_DOC_DIR) $(INSTALL) -m 644 changelog $(PKG_DOC_DIR)/changelog.Debian
debian/rules +1 -1
@@ -100,7 +100,7 @@ binary-arch: checkroot built @echo "== dpkg-buildpackage: binary-arch" 1>&2 $(checkdir) -rm -rf $(dirme) $(dirdev) $(dirdi) - $(pkgme) $(MAKE) -C . install + $(pkgme) $(MAKE) -C . install-pkg $(pkgdev) $(MAKE) -C . install-dev $(pkgdi) $(MAKE) -C debian install-d-i #$(pkgme) $(MAKE) dist
doc/Makefile +3 -1
@@ -16,7 +16,9 @@ CHANGES.gz: @echo " [ZIP] $@" $(Q)$(ZIP) --best -c < CHANGES > $@ -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_DOC_DIR) $(INSTALL) -m 644 CHANGES.gz CREDITS $(PKG_DOC_DIR) ifeq ($(PKG_DISTRIBUTION), debian)
estimate/Makefile +3 -1
@@ -12,7 +12,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
fsck/Makefile +3 -1
@@ -11,7 +11,9 @@ default: $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(INSTALL) -m 755 xfs_fsck.sh $(PKG_SBIN_DIR)/fsck.xfs install-dev:
fsr/Makefile +3 -1
@@ -15,7 +15,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
growfs/Makefile +3 -1
@@ -23,7 +23,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
include/Makefile +3 -1
@@ -57,7 +57,9 @@ install-headers: $(addsuffix -hdrs, $(DKHFILES) $(HFILES)) %-hdrs: $(Q)$(LN_S) -f $(CURDIR)/$* xfs/$* -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_INC_DIR) install-dev: install
io/Makefile +3 -1
@@ -85,7 +85,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 xfs_bmap.sh $(PKG_SBIN_DIR)/xfs_bmap
libfrog/Makefile +1 -1
@@ -70,6 +70,6 @@ crc32table.h: gen_crc32table.c crc32defs.h include $(BUILDRULES) -install install-dev: default +install install-pkg install-dev: default -include .ltdep
libhandle/Makefile +3 -1
@@ -19,7 +19,9 @@ default: ltdepend $(LTLIBRARY) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL_LTLIB) install-dev: default
libxcmd/Makefile +1 -1
@@ -23,6 +23,6 @@ default: ltdepend $(LTLIBRARY) include $(BUILDRULES) -install install-dev: default +install install-pkg install-dev: default -include .ltdep
libxfs/Makefile +3 -1
@@ -136,7 +136,9 @@ default: ltdepend $(LTLIBRARY) # set up include/xfs header directory include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_INC_DIR) install-headers: $(addsuffix -hdrs, $(PKGHFILES))
libxlog/Makefile +1 -1
@@ -21,6 +21,6 @@ default: ltdepend $(LTLIBRARY) include $(BUILDRULES) -install install-dev: default +install install-pkg install-dev: default -include .ltdep
logprint/Makefile +3 -1
@@ -21,7 +21,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
m4/Makefile +1 -1
@@ -33,7 +33,7 @@ default: include $(BUILDRULES) -install install-dev install-lib: default +install install-pkg install-dev install-lib: default realclean: distclean rm -f $(CONFIGURE)
man/Makefile +5 -3
@@ -9,12 +9,14 @@ SUBDIRS = man2 man3 man5 man8 default : $(SUBDIRS) -install : $(addsuffix -install,$(SUBDIRS)) +install : install-pkg + +install-pkg : $(addsuffix -install-pkg,$(SUBDIRS)) install-dev : $(addsuffix -install-dev,$(SUBDIRS)) -%-install: - $(Q)$(MAKE) $(MAKEOPTS) -C $* install +%-install-pkg: + $(Q)$(MAKE) $(MAKEOPTS) -C $* install-pkg %-install-dev: $(Q)$(MAKE) $(MAKEOPTS) -C $* install-dev
man/man2/Makefile +3 -1
@@ -15,7 +15,9 @@ default : $(MAN_PAGES) include $(BUILDRULES) -install : +install : install-pkg + +install-pkg : install-dev : default $(INSTALL) -m 755 -d $(MAN_DEST)
man/man3/Makefile +3 -1
@@ -15,7 +15,9 @@ default : $(MAN_PAGES) include $(BUILDRULES) -install : +install : install-pkg + +install-pkg : install-dev : default $(INSTALL) -m 755 -d $(MAN_DEST)
man/man5/Makefile +4 -1
@@ -15,7 +15,10 @@ default : $(MAN_PAGES) include $(BUILDRULES) -install : default +install : install-pkg + +install-pkg : default $(INSTALL) -m 755 -d $(MAN_DEST) $(INSTALL_MAN) + install-dev :
man/man8/Makefile +3 -1
@@ -22,7 +22,9 @@ default : $(MAN_PAGES) include $(BUILDRULES) -install : default +install : install-pkg + +install-pkg : default $(INSTALL) -m 755 -d $(MAN_DEST) $(INSTALL_MAN)
mdrestore/Makefile +3 -1
@@ -16,7 +16,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
mkfs/Makefile +3 -1
@@ -27,7 +27,9 @@ default: depend $(LTCOMMAND) $(CFGFILES) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) $(INSTALL) -m 755 -d $(MKFS_CFG_DIR)
po/Makefile +3 -1
@@ -19,7 +19,9 @@ default: $(POTHEAD) $(LINGUAS:%=%.mo) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL_LINGUAS) install-dev install-lib:
quota/Makefile +3 -1
@@ -23,7 +23,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
repair/Makefile +3 -1
@@ -102,7 +102,9 @@ include $(BUILDRULES) # #CFLAGS += ... -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
rtcp/Makefile +3 -1
@@ -16,7 +16,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev:
scrub/Makefile +3 -1
@@ -138,7 +138,9 @@ phase5.o unicrash.o xfs.o: $(builddefs) include $(BUILDRULES) -install: $(INSTALL_SCRUB) +install: install-pkg + +install-pkg: $(INSTALL_SCRUB) %.service: %.service.in $(builddefs) @echo " [SED] $@"
spaceman/Makefile +3 -1
@@ -26,7 +26,9 @@ default: depend $(LTCOMMAND) include $(BUILDRULES) -install: default +install: install-pkg + +install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) $(INSTALL) -m 755 xfs_info.sh $(PKG_SBIN_DIR)/xfs_info
RFC PATCH 2/2 debian: create a new package for automatic self-healing
From: Darrick J. Wong <[email protected]>
Create a new package for people who explicilty want self-healing turned on by default for XFS. This package is named xfsprogs-self-healing.
Note: This introduces a new "install-selfheal" target to install only the files needed for enabling online fsck by default. Other distributions should take note of the new target if they choose to create a package for enabling autonomous self healing.
--- Makefile | 8 +++++++- copy/Makefile | 2 ++ db/Makefile | 2 ++ debian/Makefile | 2 ++ debian/control | 8 ++++++++ debian/rules | 13 +++++++++---- doc/Makefile | 3 +++ estimate/Makefile | 2 ++ fsck/Makefile | 3 +++ fsr/Makefile | 2 ++ growfs/Makefile | 2 ++ include/Makefile | 3 +++ io/Makefile | 2 ++ libfrog/Makefile | 2 ++ libhandle/Makefile | 2 ++ libxcmd/Makefile | 2 ++ libxfs/Makefile | 3 +++ libxlog/Makefile | 2 ++ logprint/Makefile | 2 ++ m4/Makefile | 2 ++ man/Makefile | 2 ++ mdrestore/Makefile | 2 ++ mkfs/Makefile | 2 ++ po/Makefile | 3 +++ quota/Makefile | 2 ++ repair/Makefile | 2 ++ rtcp/Makefile | 2 ++ scrub/Makefile | 12 ++++++++++-- spaceman/Makefile | 2 ++ 29 files changed, 89 insertions(+), 7 deletions(-)
Makefile +7 -1
@@ -116,7 +116,7 @@ configure: configure.ac include/builddefs: configure ./configure $$LOCAL_CONFIGURE_OPTIONS -install: install-pkg +install: install-pkg install-selfheal install-pkg: $(addsuffix -install-pkg,$(SUBDIRS)) $(INSTALL) -m 755 -d $(PKG_DOC_DIR)
@@ -124,6 +124,8 @@ install-pkg: $(addsuffix -install-pkg,$(SUBDIRS)) install-dev: $(addsuffix -install-dev,$(SUBDIRS)) +install-selfheal: $(addsuffix -install-selfheal,$(SUBDIRS)) + %-install-pkg: @echo "Installing $@" $(Q)$(MAKE) $(MAKEOPTS) -C $* install-pkg
@@ -132,6 +134,10 @@ install-dev: $(addsuffix -install-dev,$(SUBDIRS)) @echo "Installing $@" $(Q)$(MAKE) $(MAKEOPTS) -C $* install-dev +%-install-selfheal: + @echo "Installing $@" + $(Q)$(MAKE) $(MAKEOPTS) -C $* install-selfheal + distclean: clean $(Q)rm -f $(LDIRT)
copy/Makefile +2 -0
@@ -25,4 +25,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
db/Makefile +2 -0
@@ -91,4 +91,6 @@ install-pkg: default $(INSTALL) -m 755 xfs_metadump.sh $(PKG_SBIN_DIR)/xfs_metadump install-dev: +install-selfheal: + -include .dep
debian/Makefile +2 -0
@@ -36,3 +36,5 @@ ifeq ($(PKG_DISTRIBUTION), debian) $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(INSTALL) -m 755 $(BOOT_MKFS_BIN) $(PKG_SBIN_DIR)/mkfs.xfs endif + +install-selfheal: default
debian/control +8 -0
@@ -27,6 +27,14 @@ Description: Utilities for managing the XFS filesystem Refer to the documentation at https://xfs.wiki.kernel.org/ for complete details. +Package: xfsprogs-self-healing +Depends: ${shlibs:Depends}, ${misc:Depends}, xfsprogs, systemd, udev +Architecture: linux-any +Description: Automatic self healing for the XFS filesystem + A set of background services for the XFS filesystem to make it + find and fix corruptions automatically. These services are activated + automatically upon installation of this package. + Package: xfslibs-dev Section: libdevel Depends: libc6-dev | libc-dev, uuid-dev, xfsprogs (>= 3.0.0), ${misc:Depends}
debian/rules +9 -4
@@ -14,6 +14,7 @@ endif package = xfsprogs develop = xfslibs-dev bootpkg = xfsprogs-udeb +healpkg = xfsprogs-self-healing DEB_BUILD_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE) DEB_HOST_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
@@ -26,9 +27,11 @@ udebpkg = $(bootpkg)_$(version)_$(target).udeb dirme = debian/$(package) dirdev = debian/$(develop) dirdi = debian/$(bootpkg) -pkgme = DIST_ROOT=`pwd`/$(dirme); export DIST_ROOT; -pkgdev = DIST_ROOT=`pwd`/$(dirdev); export DIST_ROOT; -pkgdi = DIST_ROOT=`pwd`/$(dirdi); export DIST_ROOT; +dirheal= debian/$(healpkg) +pkgme = DIST_ROOT=`pwd`/$(dirme); export DIST_ROOT; +pkgdev = DIST_ROOT=`pwd`/$(dirdev); export DIST_ROOT; +pkgdi = DIST_ROOT=`pwd`/$(dirdi); export DIST_ROOT; +pkgheal= DIST_ROOT=`pwd`/$(dirheal); export DIST_ROOT; stdenv = @GZIP=-q; export GZIP; configure_options = \
@@ -103,6 +106,7 @@ binary-arch: checkroot built $(pkgme) $(MAKE) -C . install-pkg $(pkgdev) $(MAKE) -C . install-dev $(pkgdi) $(MAKE) -C debian install-d-i + $(pkgheal) $(MAKE) -C . install-selfheal #$(pkgme) $(MAKE) dist install -D -m 0755 debian/local/initramfs.hook debian/xfsprogs/usr/share/initramfs-tools/hooks/xfs rmdir debian/xfslibs-dev/usr/share/doc/xfsprogs
@@ -114,7 +118,8 @@ binary-arch: checkroot built dh_compress dh_fixperms dh_makeshlibs - dh_installsystemd -p xfsprogs --no-enable --no-start --no-restart-after-upgrade --no-stop-on-upgrade + dh_installsystemd -p xfsprogs --no-restart-after-upgrade --no-stop-on-upgrade system-xfs_scrub.slice + dh_installsystemd -p xfsprogs-self-healing --no-restart-after-upgrade --no-stop-on-upgrade xfs_scrub_all.timer dh_installdeb dh_shlibdeps dh_gencontrol
doc/Makefile +3 -0
@@ -26,3 +26,6 @@ ifeq ($(PKG_DISTRIBUTION), debian) endif install-dev: + +install-selfheal: +
estimate/Makefile +2 -0
@@ -19,4 +19,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
fsck/Makefile +3 -0
@@ -17,3 +17,6 @@ install-pkg: default $(INSTALL) -m 755 -d $(PKG_SBIN_DIR) $(INSTALL) -m 755 xfs_fsck.sh $(PKG_SBIN_DIR)/fsck.xfs install-dev: + +install-selfheal: +
fsr/Makefile +2 -0
@@ -22,4 +22,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
growfs/Makefile +2 -0
@@ -30,4 +30,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
include/Makefile +3 -0
@@ -64,3 +64,6 @@ install-pkg: default install-dev: install $(INSTALL) -m 644 $(HFILES) $(PKG_INC_DIR) + +install-selfheal: +
io/Makefile +2 -0
@@ -95,4 +95,6 @@ install-pkg: default $(LTINSTALL) -m 755 xfs_mkfile.sh $(PKG_SBIN_DIR)/xfs_mkfile install-dev: +install-selfheal: + -include .dep
libfrog/Makefile +2 -0
@@ -72,4 +72,6 @@ include $(BUILDRULES) install install-pkg install-dev: default +install-selfheal: + -include .ltdep
libhandle/Makefile +2 -0
@@ -27,4 +27,6 @@ install-pkg: default install-dev: default $(INSTALL_LTLIB_DEV) +install-selfheal: + -include .ltdep
libxcmd/Makefile +2 -0
@@ -25,4 +25,6 @@ include $(BUILDRULES) install install-pkg install-dev: default +install-selfheal: + -include .ltdep
libxfs/Makefile +3 -0
@@ -158,3 +158,6 @@ install-dev: install ifndef NODEP -include .ltdep endif + +install-selfheal: +
libxlog/Makefile +2 -0
@@ -23,4 +23,6 @@ include $(BUILDRULES) install install-pkg install-dev: default +install-selfheal: + -include .ltdep
logprint/Makefile +2 -0
@@ -28,4 +28,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
m4/Makefile +2 -0
@@ -35,5 +35,7 @@ include $(BUILDRULES) install install-pkg install-dev install-lib: default +install-selfheal: + realclean: distclean rm -f $(CONFIGURE)
man/Makefile +2 -0
@@ -21,4 +21,6 @@ install-dev : $(addsuffix -install-dev,$(SUBDIRS)) %-install-dev: $(Q)$(MAKE) $(MAKEOPTS) -C $* install-dev +install-selfheal: + include $(BUILDRULES)
mdrestore/Makefile +2 -0
@@ -23,4 +23,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
mkfs/Makefile +2 -0
@@ -37,4 +37,6 @@ install-pkg: default install-dev: +install-selfheal: + -include .dep
po/Makefile +3 -0
@@ -25,3 +25,6 @@ install-pkg: default $(INSTALL_LINGUAS) install-dev install-lib: + +install-selfheal: +
quota/Makefile +2 -0
@@ -30,4 +30,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
repair/Makefile +2 -0
@@ -109,4 +109,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
rtcp/Makefile +2 -0
@@ -23,4 +23,6 @@ install-pkg: default $(LTINSTALL) -m 755 $(LTCOMMAND) $(PKG_SBIN_DIR) install-dev: +install-selfheal: + -include .dep
scrub/Makefile +10 -2
@@ -20,6 +20,7 @@ XFS_SCRUB_ARGS = -p XFS_SCRUB_SERVICE_ARGS = -b ifeq ($(HAVE_SYSTEMD),yes) INSTALL_SCRUB += install-systemd +INSTALL_SELFHEAL += install-systemd-selfheal SYSTEMD_SERVICES=\ $(scrub_svcname) \ [email protected] \
@@ -27,9 +28,10 @@ SYSTEMD_SERVICES=\ [email protected] \ xfs_scrub_all.service \ xfs_scrub_all_fail.service \ - xfs_scrub_all.timer \ system-xfs_scrub.slice -OPTIONAL_TARGETS += $(SYSTEMD_SERVICES) +SYSTEMD_SERVICES_SELFHEAL=\ + xfs_scrub_all.timer +OPTIONAL_TARGETS += $(SYSTEMD_SERVICES) $(SYSTEMD_SERVICES_SELFHEAL) endif ifeq ($(HAVE_CROND),yes) INSTALL_SCRUB += install-crond
@@ -164,6 +166,10 @@ install-systemd: default $(SYSTEMD_SERVICES) $(INSTALL) -m 755 -d $(PKG_LIBEXEC_DIR) $(INSTALL) -m 755 $(XFS_SCRUB_FAIL_PROG) $(PKG_LIBEXEC_DIR) +install-systemd-selfheal: default $(SYSTEMD_SERVICES_SELFHEAL) + $(INSTALL) -m 755 -d $(SYSTEMD_SYSTEM_UNIT_DIR) + $(INSTALL) -m 644 $(SYSTEMD_SERVICES_SELFHEAL) $(SYSTEMD_SYSTEM_UNIT_DIR) + install-crond: default $(CRONTABS) $(INSTALL) -m 755 -d $(CROND_DIR) $(INSTALL) -m 644 $(CRONTABS) $(CROND_DIR)
@@ -182,4 +188,6 @@ install-udev: $(UDEV_RULES) install-dev: +install-selfheal: $(INSTALL_SELFHEAL) + -include .dep
spaceman/Makefile +2 -0
@@ -34,4 +34,6 @@ install-pkg: default $(INSTALL) -m 755 xfs_info.sh $(PKG_SBIN_DIR)/xfs_info install-dev: +install-selfheal: + -include .dep
Re: [RFC PATCH 1/2] misc: shift install targets
In reply to Darrick J. WongQuoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Modify each
Makefileso that "install-pkg" installs the main package contents, and "install" just invokes "install-pkg". We'll need this indirection for the next patch where we add an install-selfheal target to build the xfsprogs-self-healing package but will still want 'make install' to install everything on a developer's workstation.
Maybe debian packaging foo is getting a little rusty, but wasn't the a concept of pattern matching to pick what files go into what subpackage without having to change install targets?
Re: [RFC PATCH 1/2] misc: shift install targets
Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Modify each
Makefileso that "install-pkg" installs the main package contents, and "install" just invokes "install-pkg". We'll need this indirection for the next patch where we add an install-selfheal target to build the xfsprogs-self-healing package but will still want 'make install' to install everything on a developer's workstation.
Quoted 3 lines
Maybe debian packaging foo is getting a little rusty, but wasn't the a concept of pattern matching to pick what files go into what subpackage without having to change install targets?
It is, and modern debhelper-based packaging workflows make this easy. Unfortunately, xfsprogs hasn't been updated to use it. :(
--D
Re: [RFC PATCH 1/2] misc: shift install targets
Quoted 6 lines · Darrick J. Wong
Quoted 6 lines
Quoted 5 lines
Modify each
Makefileso that "install-pkg" installs the main package contents, and "install" just invokes "install-pkg". We'll need this indirection for the next patch where we add an install-selfheal target to build the xfsprogs-self-healing package but will still want 'make install' to install everything on a developer's workstation.
Quoted 6 lines
Quoted 3 lines
Maybe debian packaging foo is getting a little rusty, but wasn't the a concept of pattern matching to pick what files go into what subpackage without having to change install targets?
It is, and modern debhelper-based packaging workflows make this easy. Unfortunately, xfsprogs hasn't been updated to use it. :(
Oh well. Maybe I'll need to dust off my packaging skills and look into that. Because splitting the install targets just makes it harder to move to a more modern build system eventually. Another one of those projects I've started and need to eventually finish..
PATCH 10/16 xfsprogs: improve extended attribute validation
In reply to Darrick J. WongHi all,
Prior to introducing parent pointer extended attributes, let's spend some time cleaning up the attr code and strengthening the validation that it performs on attrs coming in from the disk.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=improve-attr-validation
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=improve-attr-validation
---
Commits in this patchset:
* xfs_repair: check free space requirements before allowing upgrades
* xfs_repair: enforce one namespace bit per extended attribute
* xfs_repair: check for unknown flags in attr entries
--- include/libxfs.h | 1 libxfs/libxfs_api_defs.h | 1 repair/attr_repair.c | 30 ++++++++++ repair/phase2.c | 134 ++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 166 insertions(+)
PATCH 1/3 xfs_repair: check free space requirements before allowing upgrades
From: Darrick J. Wong <[email protected]>
Currently, the V5 feature upgrades permitted by xfs_repair do not affect filesystem space usage, so we haven't needed to verify the geometry.
However, this will change once we start to allow the sysadmin to add new metadata indexes to existing filesystems. Add all the infrastructure we need to ensure that there's enough space for metadata space reservations and per-AG reservations the next time the filesystem will be mounted.
--- include/libxfs.h | 1 repair/phase2.c | 134 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 135 insertions(+)
include/libxfs.h +1 -0
@@ -91,6 +91,7 @@ struct iomap;#include "libxfs/buf_mem.h" #include "xfs_btree_mem.h" #include "xfs_parent.h" +#include "xfs_ag_resv.h" #ifndef ARRAY_SIZE #define ARRAY_SIZE (x) (sizeof(x) / sizeof((x)[0]))
repair/phase2.c +134 -0
146 lines not on this page · raw message
Re: [PATCH 1/3] xfs_repair: check free space requirements before allowing upgrades
Looks good:
PATCH 2/3 xfs_repair: enforce one namespace bit per extended attribute
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enforce that all extended attributes have at most one namespace bit.
--- libxfs/libxfs_api_defs.h | 1 + repair/attr_repair.c | 15 +++++++++++++++ 2 files changed, 16 insertions(+)
libxfs/libxfs_api_defs.h +1 -0
@@ -36,6 +36,7 @@#define xfs_ascii_ci_hashname libxfs_ascii_ci_hashname +#define xfs_attr_check_namespace libxfs_attr_check_namespace#define xfs_attr_get libxfs_attr_get#define xfs_attr_leaf_newentsize libxfs_attr_leaf_newentsize#define xfs_attr_namecheck libxfs_attr_namecheck
repair/attr_repair.c +15 -0
@@ -291,6 +291,13 @@ process_shortform_attr( } } +if (!libxfs_attr_check_namespace (currententry->flags)) { +do_warn ( +_ ("multiple namespaces for shortform attribute %d in inode %" PRIu64"\n" ), + i, ino); + junkit =1 ; + } +/* namecheck checks for null chars in attr names. */ if (!libxfs_attr_namecheck(currententry->flags, currententry->nameval,
@@ -641,6 +648,14 @@ process_leaf_attr_block(break ; } +if (!libxfs_attr_check_namespace (entry->flags)) { +do_warn ( +_ ("multiple namespaces for attribute entry %d in attr block %u, inode %" PRIu64"\n" ), + i, da_bno, ino); + clearit =1 ; +break ; + } +if (entry->flags &XFS_ATTR_INCOMPLETE ) {/* we are inconsistent state. get rid of us */ do_warn(
Re: [PATCH 2/3] xfs_repair: enforce one namespace bit per extended attribute
Looks good:
PATCH 3/3 xfs_repair: check for unknown flags in attr entries
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Explicitly check for unknown bits being set in the shortform and leaf attr entries.
--- repair/attr_repair.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
repair/attr_repair.c +15 -0
@@ -291,6 +291,13 @@ process_shortform_attr( } } +if (currententry->flags & ~XFS_ATTR_ONDISK_MASK ) { +do_warn ( +_ ("unknown flags 0x%x in shortform attribute %d in inode %" PRIu64"\n" ), + currententry->flags, i, ino); + junkit =1 ; + } +if (!libxfs_attr_check_namespace (currententry->flags)) { do_warn( _("multiple namespaces for shortform attribute %d in inode %" PRIu64 "\n"),
@@ -648,6 +655,14 @@ process_leaf_attr_block(break ; } +if (entry->flags & ~XFS_ATTR_ONDISK_MASK ) { +do_warn ( +_ ("unknown flags 0x%x in attribute entry #%d in attr block %u, inode %" PRIu64"\n" ), + entry->flags, i, da_bno, ino); + clearit =1 ; +break ; + } +if (!libxfs_attr_check_namespace (entry->flags)) { do_warn( _("multiple namespaces for attribute entry %d in attr block %u, inode %" PRIu64 "\n"),
Re: [PATCH 3/3] xfs_repair: check for unknown flags in attr entries
Looks good:
PATCH 11/16 xfsprogs: Parent Pointers
In reply to Darrick J. WongHi all,
This is the latest parent pointer attributes for xfs. The goal of this patch set is to add a parent pointer attribute to each inode. The attribute name containing the parent inode, generation, and directory offset, while the attribute value contains the file name. This feature will enable future optimizations for online scrub, shrink, nfs handles, verity, or any other feature that could make use of quickly deriving an inodes path from the mount point.
Directory parent pointers are stored as namespaced extended attributes of a file. Because parent pointers are an indivisible tuple of (dirent_name, parent_ino, parent_gen) we cannot use the usual attr name lookup functions to find a parent pointer. This is solvable by introducing a new lookup mode that checks both the name and the value of the xattr.
Therefore, introduce this new name-value lookup mode that's gated on the XFS_ATTR_PARENT namespace. This requires the introduction of new opcodes for the extended attribute update log intent items, which actually means that parent pointers (itself an INCOMPAT feature) does not depend on the LOGGED_XATTRS log incompat feature bit.
To reduce collisions on the dirent names of parent pointers, introduce a new attr hash mode that is the dir2 namehash of the dirent name xor'd with the parent inode number.
At this point, Allison has moved on to other things, so I've merged her patchset into djwong-dev for merging.
Updates since v12 [djwong]:
Rebase on 6.9-rc and update the online fsck design document. Redesign the ondisk format to use the name-value lookups to get us back to the point where the attr is (dirent_name -> parent_ino/gen).
Updates since v11 [djwong]:
Rebase on 6.4-rc and make some tweaks and bugfixes to enable the repair prototypes. Merge with djwong-dev and make online repair actually work.
Updates since v10 [djwong]:
Merge in the ondisk format changes to get rid of the diroffset conflicts with the parent pointer repair code, rebase the entire series with the attr vlookup changes first, and merge all the other random fixes.
Updates since v9:
Reordered patches 2 and 3 to be 6 and 7
xfs: Add xfs_verify_pptr
moved parent pointer validators to xfs_parent
xfs: Add parent pointer ioctl
Extra validation checks for fs id
added missing release for the inode
use GFP_KERNEL flags for malloc/realloc reworked ioctl to use pptr listenty and flex array
NEW
xfs: don't remove the attr fork when parent pointers are enabled
NEW
directory lookups should return diroffsets too
NEW
xfs: move/add parent pointer validators to xfs_parent
Updates since v8:
xfs: parent pointer attribute creation
Fix xfs_parent_init to release log assist on alloc fail Add slab cache for xfs_parent_defer
Fix xfs_create to release after unlock
Add xfs_parent_start and xfs_parent_finish wrappers removed unused xfs_parent_name_irec and xfs_init_parent_name_irec
xfs: add parent attributes to link
Start/finish wrapper updates
Fix xfs_link to disallow reservationless quotas
xfs: add parent attributes to symlink
Fix xfs_symlink to release after unlock
Start/finish wrapper updates
xfs: remove parent pointers in unlink
Start/finish wrapper updates
Add missing parent free
xfs: Add parent pointers to rename
Start/finish wrapper updates
Fix rename to only grab logged xattr once Fix xfs_rename to disallow reservationless quotas Fix double unlock on dqattach fail
Move parent frees to out_release_wip
xfs: Add parent pointers to xfs_cross_rename
Hoist parent pointers into rename
Questions comments and feedback appreciated!
Thanks all!
Allison
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=pptrs
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=pptrs
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=pptrs
xfsdocs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-documentation.git/log/?h=pptrs
---
Commits in this patchset:
* libxfs: create attr log item opcodes and formats for parent pointers
* xfs_{db,repair}: implement new attr hash value function
* xfs_logprint: dump new attr log item fields
* man: document the XFS_IOC_GETPARENTS ioctl
* libfrog: report parent pointers to userspace
* libfrog: add parent pointer support code
* xfs_io: adapt parent command to new parent pointer ioctls
* xfs_io: Add i, n and f flags to parent command
* xfs_logprint: decode parent pointers in ATTRI items fully
* xfs_spaceman: report file paths
* xfs_scrub: use parent pointers when possible to report file operations
* xfs_scrub: use parent pointers to report lost file data
* xfs_db: report parent pointers in version command
* xfs_db: report parent bit on xattrs
* xfs_db: report parent pointers embedded in xattrs
* xfs_db: obfuscate dirent and parent pointer names consistently
* libxfs: export attr3_leaf_hdr_from_disk via libxfs_api_defs.h
* xfs_db: add a parents command to list the parents of a file
* xfs_db: make attr_set and attr_remove handle parent pointers
* xfs_db: add link and unlink expert commands
* xfs_db: compute hashes of parent pointers
* libxfs: create new files with attr forks if necessary
* mkfs: Add parent pointers during protofile creation
* mkfs: enable formatting with parent pointers
--- db/attr.c | 33 ++ db/attrset.c | 202 +++++++++-- db/attrshort.c | 27 ++ db/field.c | 10 + db/field.h | 3 db/hash.c | 44 ++ db/metadump.c | 322 +++++++++++++++++- db/namei.c | 701 +++++++++++++++++++++++++++++++++++++++ db/sb.c | 2 include/handle.h | 1 include/xfs_inode.h | 4 io/parent.c | 541 +++++++++++------------------- libfrog/Makefile | 2 libfrog/fsgeom.c | 6 libfrog/getparents.c | 355 ++++++++++++++++++++ libfrog/getparents.h | 42 ++ libfrog/paths.c | 168 +++++++++ libfrog/paths.h | 25 + libhandle/handle.c | 7 libxfs/defer_item.c | 52 +++ libxfs/init.c | 4 libxfs/libxfs_api_defs.h | 19 + libxfs/util.c | 19 + logprint/log_redo.c | 217 +++++++++++- logprint/logprint.h | 6 man/man2/ioctl_xfs_getparents.2 | 212 ++++++++++++ man/man8/xfs_db.8 | 59 +++ man/man8/xfs_io.8 | 32 +- man/man8/xfs_spaceman.8 | 7 mkfs/lts_4.19.conf | 3 mkfs/lts_5.10.conf | 3 mkfs/lts_5.15.conf | 3 mkfs/lts_5.4.conf | 3 mkfs/lts_6.1.conf | 3 mkfs/lts_6.6.conf | 3 mkfs/proto.c | 62 +++ mkfs/xfs_mkfs.c | 45 ++- repair/attr_repair.c | 24 + scrub/common.c | 41 ++ scrub/phase6.c | 75 ++++ spaceman/Makefile | 16 + spaceman/file.c | 7 spaceman/health.c | 53 ++- spaceman/space.h | 3 44 files changed, 2942 insertions(+), 524 deletions(-) create mode 100644 libfrog/getparents.c create mode 100644 libfrog/getparents.h create mode 100644 man/man2/ioctl_xfs_getparents.2
PATCH 1/24 libxfs: create attr log item opcodes and formats for parent pointers
From: Darrick J. Wong <[email protected]>
Update xfs_attr_defer_add to use the pptr-specific opcodes if it's reading or writing parent pointers.
--- libxfs/defer_item.c | 52 +++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 46 insertions(+), 6 deletions(-)
libxfs/defer_item.c +46 -6
@@ -676,21 +676,61 @@ xfs_attr_defer_add( enum xfs_attr_defer_op op) {struct xfs_attr_intent *new; +unsigned int log_op =0 ; +bool is_pptr = args->attr_filter &XFS_ATTR_PARENT ; - new =kmem_cache_zalloc (xfs_attr_intent_cache,GFP_NOFS | __GFP_NOFAIL); +if (is_pptr) { +ASSERT (xfs_has_parent (args->dp->i_mount)); +ASSERT ((args->attr_filter & ~XFS_ATTR_PARENT ) !=0 ); +ASSERT (args->op_flags &XFS_DA_OP_LOGGED ); +ASSERT (args->valuelen ==sizeof (struct xfs_parent_rec )); + } + + new =kmem_cache_zalloc (xfs_attr_intent_cache, +GFP_NOFS | __GFP_NOFAIL); new->xattri_da_args = args; +/* Compute log operation from the higher level op and namespace. */ switch (op) {case XFS_ATTR_DEFER_SET : - new->xattri_op_flags =XFS_ATTRI_OP_FLAGS_SET ; - new->xattri_dela_state =xfs_attr_init_add_state (args); +if (is_pptr) + log_op =XFS_ATTRI_OP_FLAGS_PPTR_SET ; +else + log_op =XFS_ATTRI_OP_FLAGS_SET ;break ;case XFS_ATTR_DEFER_REPLACE : - new->xattri_op_flags =XFS_ATTRI_OP_FLAGS_REPLACE ; - new->xattri_dela_state =xfs_attr_init_replace_state (args); +if (is_pptr) + log_op =XFS_ATTRI_OP_FLAGS_PPTR_REPLACE ; +else + log_op =XFS_ATTRI_OP_FLAGS_REPLACE ;break ;case XFS_ATTR_DEFER_REMOVE : - new->xattri_op_flags =XFS_ATTRI_OP_FLAGS_REMOVE ; +if (is_pptr) + log_op =XFS_ATTRI_OP_FLAGS_PPTR_REMOVE ; +else + log_op =XFS_ATTRI_OP_FLAGS_REMOVE ; +break ; +default : +ASSERT (0 ); +break ; + } + new->xattri_op_flags = log_op; + +/* Set up initial attr operation state. */ +switch (log_op) { +case XFS_ATTRI_OP_FLAGS_PPTR_SET : +case XFS_ATTRI_OP_FLAGS_SET : + new->xattri_dela_state =xfs_attr_init_add_state (args); +break ; +case XFS_ATTRI_OP_FLAGS_PPTR_REPLACE : +ASSERT (args->new_valuelen == args->valuelen); + new->xattri_dela_state =xfs_attr_init_replace_state (args); +break ; +case XFS_ATTRI_OP_FLAGS_REPLACE : + new->xattri_dela_state =xfs_attr_init_replace_state (args); +break ; +case XFS_ATTRI_OP_FLAGS_PPTR_REMOVE : +case XFS_ATTRI_OP_FLAGS_REMOVE : new->xattri_dela_state =xfs_attr_init_remove_state (args);break ; }
Re: [PATCH 01/24] libxfs: create attr log item opcodes and formats for parent pointers
Looks good:
PATCH 2/24 xfs_{db,repair}: implement new attr hash value function
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Port existing utilities to use libxfs_attr_hashname instead of calling libxfs_da_hashname directly.
--- db/hash.c | 8 ++++---- db/metadump.c | 10 +++++----- libxfs/libxfs_api_defs.h | 2 ++ repair/attr_repair.c | 18 ++++++++++++------ 4 files changed, 23 insertions(+), 15 deletions(-)
db/hash.c +4 -4
@@ -73,7 +73,7 @@ hash_f(if (use_dir2_hash) hashval =libxfs_dir2_hashname (mp, &xname);else - hashval =libxfs_da_hashname (xname.name, xname.len); + hashval =libxfs_attr_hashname (xname.name, xname.len);dbprintf ("0x%x\n" , hashval); }
@@ -306,7 +306,7 @@ collide_xattrs(unsigned long i;int error =0 ; - old_hash =libxfs_da_hashname ((uint8_t *)name, namelen); + old_hash =libxfs_attr_hashname ((uint8_t *)name, namelen);if (fd >=0 ) {/*
@@ -331,8 +331,8 @@ collide_xattrs(snprintf (xattrname,MAXNAMELEN +5 ,"user.%s" , name);obfuscate_name (old_hash, namelen, (uint8_t *)xattrname +5 , false); -ASSERT (old_hash ==libxfs_da_hashname ((uint8_t *)xattrname +5 , - namelen)); +ASSERT (old_hash ==libxfs_attr_hashname ( + (uint8_t *)xattrname +5 , namelen));if (fd >=0 ) { error =fsetxattr (fd, xattrname,"1" ,1 ,0 );
db/metadump.c +5 -5
@@ -835,7 +835,7 @@ dirattr_hashname(return libxfs_dir2_hashname (mp, &xname); } -return libxfs_da_hashname (name, namelen); +return libxfs_attr_hashname (name, namelen); } static void
@@ -982,9 +982,9 @@ obfuscate_path_components(if (!slash) {/* last (or single) component */ namelen =strnlen ((char *)comp, len); - hash =libxfs_da_hashname (comp, namelen); + hash =dirattr_hashname (true, comp, namelen);obfuscate_name (hash, namelen, comp, false); -ASSERT (hash ==libxfs_da_hashname (comp, namelen)); +ASSERT (hash ==dirattr_hashname (true, comp, namelen));break ; } namelen = slash - (char *)comp;
@@ -994,9 +994,9 @@ obfuscate_path_components( len--;continue ; } - hash =libxfs_da_hashname (comp, namelen); + hash =dirattr_hashname (true, comp, namelen);obfuscate_name (hash, namelen, comp, false); -ASSERT (hash ==libxfs_da_hashname (comp, namelen)); +ASSERT (hash ==dirattr_hashname (true, comp, namelen)); comp += namelen +1 ; len -= namelen +1 ; }
libxfs/libxfs_api_defs.h +2 -0
@@ -38,6 +38,8 @@#define xfs_attr_check_namespace libxfs_attr_check_namespace#define xfs_attr_get libxfs_attr_get +#define xfs_attr_hashname libxfs_attr_hashname +#define xfs_attr_hashval libxfs_attr_hashval#define xfs_attr_leaf_newentsize libxfs_attr_leaf_newentsize#define xfs_attr_namecheck libxfs_attr_namecheck#define xfs_attr_set libxfs_attr_set
repair/attr_repair.c +12 -6
@@ -485,6 +485,7 @@ process_leaf_attr_local( xfs_ino_t ino) {xfs_attr_leaf_name_local_t *local; +xfs_dahash_t computed; local =xfs_attr3_leaf_name_local (leaf, i); if (local->namelen == 0 ||
@@ -504,9 +505,12 @@ process_leaf_attr_local(* ordering anyway in case both the name value and the * hashvalue were wrong but matched. Unlikely, however. */ -if (be32_to_cpu (entry->hashval) !=libxfs_da_hashname ( - &local->nameval[0 ], local->namelen) || -be32_to_cpu (entry->hashval) < last_hashval) { + computed =libxfs_attr_hashval (mp, entry->flags, local->nameval, + local->namelen, + local->nameval + local->namelen, +be16_to_cpu (local->valuelen)); +if (be32_to_cpu (entry->hashval) != computed || +be32_to_cpu (entry->hashval) < last_hashval) {do_warn (_ ("bad hashvalue for attribute entry %d in attr block %u, inode %" PRIu64"\n" ), i, da_bno, ino);
@@ -540,15 +544,17 @@ process_leaf_attr_remote( {xfs_attr_leaf_name_remote_t *remotep;char * value; +xfs_dahash_t computed; remotep =xfs_attr3_leaf_name_remote (leaf, i); + computed =libxfs_attr_hashval (mp, entry->flags, remotep->name, + remotep->namelen,NULL , +be32_to_cpu (remotep->valuelen));if (remotep->namelen ==0 || !libxfs_attr_namecheck (entry->flags, remotep->name, remotep->namelen) || -be32_to_cpu (entry->hashval) != -libxfs_da_hashname ((unsigned char *)&remotep->name[0 ], - remotep->namelen) || +be32_to_cpu (entry->hashval) != computed ||be32_to_cpu (entry->hashval) < last_hashval ||be32_to_cpu (remotep->valueblk) ==0 ) { do_warn(
Re: [PATCH 02/24] xfs_{db,repair}: implement new attr hash value function
Looks good:
PATCH 3/24 xfs_logprint: dump new attr log item fields
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Dump the new extended attribute log item fields. This was split out from the previous patch to make libxfs resyncing easier. This code needs more cleaning, which we'll do in the next few patches before moving on to the parent pointer code.
--- logprint/log_redo.c | 140 ++++++++++++++++++++++++++++++++++++++++++--------- logprint/logprint.h | 6 +- 2 files changed, 119 insertions(+), 27 deletions(-)
logprint/log_redo.c +115 -25
@@ -674,6 +674,12 @@ xfs_attri_copy_log_format(return 1 ; } +static inline unsigned int +xfs_attr_log_item_op (const struct xfs_attri_log_format *attrp) +{ +return attrp->alfi_op_flags &XFS_ATTRI_OP_FLAGS_TYPE_MASK ; +} + int xlog_print_trans_attri( char **ptr,
@@ -683,6 +689,10 @@ xlog_print_trans_attri(struct xfs_attri_log_format *src_f =NULL ;xlog_op_header_t *head =NULL ;uint dst_len; +unsigned int name_len =0 ; +unsigned int new_name_len =0 ; +unsigned int value_len =0 ; +unsigned int new_value_len =0 ;int error =0 ; dst_len =sizeof (struct xfs_attri_log_format );
@@ -705,27 +715,71 @@ xlog_print_trans_attri(memmove ((char *)src_f, *ptr, src_len); *ptr += src_len; -printf (_ ("ATTRI: #regs: %d name_len: %d, value_len: %d id: 0x%llx\n" ), - src_f->alfi_size, src_f->alfi_name_len, src_f->alfi_value_len, - (unsigned long long )src_f->alfi_id); +if (xfs_attr_log_item_op (src_f) ==XFS_ATTRI_OP_FLAGS_PPTR_REPLACE ) { + name_len = src_f->alfi_old_name_len; + new_name_len = src_f->alfi_new_name_len; + value_len = src_f->alfi_value_len; + new_value_len = src_f->alfi_value_len; + }else { + name_len = src_f->alfi_name_len; + value_len = src_f->alfi_value_len; + } + +printf (_ ("ATTRI: #regs: %d f: 0x%x, ino: 0x%llx, igen: 0x%x, attr_filter: 0x%x, name_len: %u, new_name_len: %u, value_len: %u, new_value_len: %u id: 0x%llx\n" ), + src_f->alfi_size, + src_f->alfi_op_flags, + (unsigned long long )src_f->alfi_ino, + (unsigned int )src_f->alfi_igen, + src_f->alfi_attr_filter, + name_len, + new_name_len, + value_len, + new_value_len, + (unsigned long long )src_f->alfi_id); + +if (name_len >0 ) { +printf (_ ("\n" )); + (*i)++; + head = (xlog_op_header_t *)*ptr; +xlog_print_op_header (head, *i, ptr); + error =xlog_print_trans_attri_name (ptr, +be32_to_cpu (head->oh_len),"name" ); +if (error) + goto error; + } -if (src_f->alfi_name_len >0 ) { +if (new_name_len >0 ) {printf (_ ("\n" )); (*i)++; head = (xlog_op_header_t *)*ptr;xlog_print_op_header (head, *i, ptr); - error =xlog_print_trans_attri_name (ptr,be32_to_cpu (head->oh_len)); + error =xlog_print_trans_attri_name (ptr, +be32_to_cpu (head->oh_len),"newname" );if (error) goto error; } -if (src_f->alfi_value_len >0 ) { +if (value_len >0 ) {printf (_ ("\n" )); (*i)++; head = (xlog_op_header_t *)*ptr;xlog_print_op_header (head, *i, ptr); - error =xlog_print_trans_attri_value (ptr,be32_to_cpu (head->oh_len), - src_f->alfi_value_len); + error =xlog_print_trans_attri_value (ptr, +be32_to_cpu (head->oh_len), value_len,"value" ); +if (error) + goto error; + } + +if (new_value_len >0 ) { +printf (_ ("\n" )); + (*i)++; + head = (xlog_op_header_t *)*ptr; +xlog_print_op_header (head, *i, ptr); + error =xlog_print_trans_attri_value (ptr, +be32_to_cpu (head->oh_len), new_value_len, +"newvalue" ); +if (error) + goto error; } error:free (src_f);
@@ -736,31 +790,33 @@ xlog_print_trans_attri(int xlog_print_trans_attri_name (char **ptr, -uint src_len) +uint src_len, +const char *tag) { -printf (_ ("ATTRI: name len:%u\n" ), src_len); +printf (_ ("ATTRI: %s len:%u\n" ), tag, src_len);print_or_dump (*ptr, src_len); *ptr += src_len;return 0 ; -}/* xlog_print_trans_attri */ +}int xlog_print_trans_attri_value (char **ptr,uint src_len, -int value_len) +int value_len, +const char *tag) {int len =min (value_len, src_len); -printf (_ ("ATTRI: value len:%u\n" ), value_len); +printf (_ ("ATTRI: %s len:%u\n" ), tag, value_len);print_or_dump (*ptr, len); *ptr += src_len;return 0 ; -}/* xlog_print_trans_attri_value */ +}void xlog_recover_print_attri(
@@ -768,7 +824,10 @@ xlog_recover_print_attri( {struct xfs_attri_log_format *f, *src_f =NULL ;uint src_len, dst_len; - +unsigned int name_len =0 ; +unsigned int new_name_len =0 ; +unsigned int value_len =0 ; +unsigned int new_value_len =0 ;int region =0 ; src_f = (struct xfs_attri_log_format *)item->ri_buf[0 ].i_addr;
@@ -788,24 +847,55 @@ xlog_recover_print_attri(if (xfs_attri_copy_log_format ((char *)src_f, src_len, f)) goto out; -printf (_ ("ATTRI: #regs: %d name_len: %d, value_len: %d id: 0x%llx\n" ), - f->alfi_size, f->alfi_name_len, f->alfi_value_len, (unsigned long long )f->alfi_id); +if (xfs_attr_log_item_op (f) ==XFS_ATTRI_OP_FLAGS_PPTR_REPLACE ) { + name_len = f->alfi_old_name_len; + new_name_len = f->alfi_new_name_len; + value_len = f->alfi_value_len; + new_value_len = f->alfi_value_len; + }else { + name_len = f->alfi_name_len; + value_len = f->alfi_value_len; + } + +printf (_ ("ATTRI: #regs: %d f: 0x%x, ino: 0x%llx, igen: 0x%x, attr_filter: 0x%x, name_len: %u, new_name_len: %u, value_len: %d, new_value_len: %u id: 0x%llx\n" ), + f->alfi_size, + f->alfi_op_flags, + (unsigned long long )f->alfi_ino, + (unsigned int )f->alfi_igen, + f->alfi_attr_filter, + name_len, + new_name_len, + value_len, + new_value_len, + (unsigned long long )f->alfi_id); -if (f->alfi_name_len >0 ) { +if (name_len >0 ) { region++; -printf (_ ("ATTRI: name len:%u\n" ), f->alfi_name_len); +printf (_ ("ATTRI: name len:%u\n" ), name_len);print_or_dump ((char *)item->ri_buf[region].i_addr, - f->alfi_name_len); + name_len); } -if (f->alfi_value_len >0 ) { -int len = f->alfi_value_len; +if (new_name_len >0 ) { + region++; +printf (_ ("ATTRI: newname len:%u\n" ), new_name_len); +print_or_dump ((char *)item->ri_buf[region].i_addr, + new_name_len); + } + +if (value_len >0 ) { +int len =min (MAX_ATTR_VAL_PRINT , value_len); + + region++; +printf (_ ("ATTRI: value len:%u\n" ), value_len); +print_or_dump ((char *)item->ri_buf[region].i_addr, len); + } -if (len >MAX_ATTR_VAL_PRINT ) - len =MAX_ATTR_VAL_PRINT ; +if (new_value_len >0 ) { +int len =min (MAX_ATTR_VAL_PRINT , new_value_len); region++; -printf (_ ("ATTRI: value len:%u\n" ), f->alfi_value_len); +printf (_ ("ATTRI: newvalue len:%u\n" ), new_value_len);print_or_dump ((char *)item->ri_buf[region].i_addr, len); }
logprint/logprint.h +4 -2
@@ -59,8 +59,10 @@ extern void xlog_recover_print_bud(struct xlog_recover_item *item);#define MAX_ATTR_VAL_PRINT 128extern int xlog_print_trans_attri (char **ptr,uint src_len,int *i); -extern int xlog_print_trans_attri_name (char **ptr,uint src_len); -extern int xlog_print_trans_attri_value (char **ptr,uint src_len,int value_len); +extern int xlog_print_trans_attri_name (char **ptr,uint src_len, +const char *tag); +extern int xlog_print_trans_attri_value (char **ptr,uint src_len,int value_len, +const char *tag);extern void xlog_recover_print_attri (struct xlog_recover_item *item);extern int xlog_print_trans_attrd (char **ptr,uint len);extern void xlog_recover_print_attrd (struct xlog_recover_item *item);
Re: [PATCH 03/24] xfs_logprint: dump new attr log item fields
logprint/logprint.h extern void xlog_recover_print_bud(struct xlog_recover_item *item); · line 65
Quoted 4 lines
logprint/logprint.h +4
-0+extern int xlog_print_trans_attri_name (char **ptr,uint src_len, +const char *tag); +extern int xlog_print_trans_attri_value (char **ptr,uint src_len,int value_len, +const char *tag);
Maybe drop the pointless externs?
Otherwise looks good:
Re: [PATCH 03/24] xfs_logprint: dump new attr log item fields
Quoted 10 lines · Christoph Hellwig
logprint/logprint.h extern void xlog_recover_print_bud(struct xlog_recover_item *item); · line 65
Quoted 4 lines
logprint/logprint.h +4
-0+extern int xlog_print_trans_attri_name (char **ptr,uint src_len, +const char *tag); +extern int xlog_print_trans_attri_value (char **ptr,uint src_len,int value_len, +const char *tag);Maybe drop the pointless externs?
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Done, thanks.
--D
PATCH 4/24 man: document the XFS_IOC_GETPARENTS ioctl
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Document how this new ioctl works.
--- man/man2/ioctl_xfs_getparents.2 | 212 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 212 insertions(+) create mode 100644 man/man2/ioctl_xfs_getparents.2
man/man2/ioctl_xfs_getparents.2 new file +212 -0
@@ -0,0 +1,212 @@ +.\" Copyright (c) 2019-2024 Oracle. All rights reserved. +.\" +.\" %%%LICENSE_START(GPLv2+_DOC_FULL) +.\" SPDX-License-Identifier: GPL-2.0-or-later +.\" %%%LICENSE_END +.TH IOCTL-XFS-GETPARENTS 2 2024-04-09 "XFS" +.SH NAME +ioctl_xfs_getparents \- query XFS directory parent information +.SH SYNOPSIS +.br +.B #include <xfs/xfs_fs.h> +.PP +.BI "int ioctl(int " fd ", XFS_IOC_GETPARENTS, struct xfs_getparents *" arg ); +.PP +.BI "int ioctl(int " fd ", XFS_IOC_GETPARENTS_BY_HANDLE, struct xfs_getparents_by_handle *" arg ); +.SH DESCRIPTION +This command is used to retrieve the directory parent pointers of either the +currently opened file or a file handle. +Parent pointers point upwards in the directory tree from a child file towards a +parent directories. +Each entry in a parent directory must have a corresponding parent pointer in +the child. + +Calling programs should allocate a large memory buffer and initialize a header +of the following form: +.PP +.in +4n +.nf +struct xfs_getparents { + struct xfs_attrlist_cursor gp_cursor; + __u16 gp_iflags; + __u16 gp_oflags; + __u32 gp_bufsize; + __u64 __pad; + __u64 gp_buffer; +}; + +struct xfs_getparents { + struct xfs_handle gph_handle; + struct xfs_getparents gph_request; +}; +.fi +.in + +.PP +The field +.I gp_cursor +tracks the progress of iterating through the parent pointers. +Calling programs must initialize this to zero before the first system call +and must not touch it after that. + +.PP +The field +.I gp_iflags +control the behavior of the query operation and provide more information +about the outcome of the operation. +There are no input flags currently defined; this field must be zero. + +.PP +The field +.I gp_oflags +contains information about the query itself. +Possibly output flags are: +.RS 0.4i +.TP +.B XFS_GETPARENTS_OFLAG_ROOT +The file queried was the root directory. +.TP +.B XFS_GETPARENTS_OFLAG_DONE +There are no more parent pointers to query. +.RE + +.PP +The field +.I __pad +must be zero. + +.PP +The field +.I gp_bufsize +should be set to the size of the buffer, in bytes. + +.PP +The field +.I gp_buffer +should point to an output buffer for the parent pointer records. + +Parent pointer records are returned in the following form: +.PP +.in +4n +.nf + +struct xfs_getparents_rec { + struct xfs_handle gpr_parent; + __u16 gpr_reclen; + char gpr_name[]; +}; +.fi +.in + +.PP +The field +.I gpr_parent +is a file handle that can be used to open the parent directory. + +.PP +The field +.I gpr_reclen +will be set to the number of bytes used by this parent record. + +.PP +The array +.I gpr_name +will be set to a NULL-terminated byte sequence representing the filename +stored in the parent pointer. +If the name is a zero-length string, the file queried has no parents. + +.SH SAMPLE PROGRAM +Calling programs should allocate a large memory buffer, initialize the head +structure to zeroes, set gp_bufsize to the size of the buffer, and call the +ioctl. +The XFS_GETPARENTS_OFLAG_DONE flag will be set in gp_flags when there are no +more parent pointers to be read. +The below code is an example of XFS_IOC_GETPARENTS usage: + +.nf +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <xfs/linux.h> +#include <xfs/xfs.h> +#include <xfs/xfs_types.h> +#include <xfs/xfs_fs.h> + +int main() { + struct xfs_getparents gp = { }; + struct xfs_getparents_rec *gpr; + int error, fd; + + gp.gp_buffer = (uintptr_t)malloc(65536); + if (!gp.gp_buffer) { + perror("malloc"); + return 1; + } + gp->gp_bufsize = 65536; + + fd = open("/mnt/test/foo.txt", O_RDONLY | O_CREAT); + if (fd == -1) + return errno; + + do { + error = ioctl(fd, XFS_IOC_GETPARENTS, gp); + if (error) + return error; + + for (gpr = xfs_getparents_first_rec(&gp); + gpr != NULL; + gpr = xfs_getparents_next_rec(&gp, gpr)) { + if (gpr->gpr_name[0] == 0) + break; + + printf("inode = %llu\\n", + gpr->gpr_parent.ha_fid.fid_ino); + printf("generation = %u\\n", + gpr->gpr_parent.ha_fid.fid_gen); + printf("name = \\"%s\\"\\n\\n", + gpr->gpr_name); + } + } while (!(gp.gp_flags & XFS_GETPARENTS_OFLAG_DONE)); + + return 0; +} +.fi + +.SH RETURN VALUE +On error, \-1 is returned, and +.I errno +is set to indicate the error. +.PP +.SH ERRORS +Error codes can be one of, but are not limited to, the following: +.TP +.B EFSBADCRC +Metadata checksum validation failed while performing the query. +.TP +.B EFSCORRUPTED +Metadata corruption was encountered while performing the query. +.TP +.B EINVAL +One or more of the arguments specified is invalid. +.TP +.B EMSGSIZE +The record buffer was not large enough to store even a single record. +.TP +.B ENOMEM +Not enough memory to retrieve parent pointers. +.TP +.B EOPNOTSUPP +Repairs of the requested metadata object are not supported. +.TP +.B EROFS +Filesystem is read-only and a repair was requested. +.TP +.B ESHUTDOWN +Filesystem is shut down due to previous errors. +.TP +.B EIO +An I/O error was encountered while performing the query. +.SH CONFORMING TO +This API is specific to XFS filesystem on the Linux kernel. +.SH SEE ALSO +.BR ioctl (2)
Re: [PATCH 04/24] man: document the XFS_IOC_GETPARENTS ioctl
Looks good:
PATCH 5/24 libfrog: report parent pointers to userspace
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Report the presence of parent pointer to userspace.
--- libfrog/fsgeom.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
libfrog/fsgeom.c +4 -2
@@ -32,6 +32,7 @@ xfs_report_geom(int inobtcount;int nrext64;int exchangerange; +int parent; isint = geo->logstart >0 ; lazycount = geo->flags &XFS_FSOP_GEOM_FLAGS_LAZYSB ?1 :0 ;
@@ -51,6 +52,7 @@ xfs_report_geom( inobtcount = geo->flags &XFS_FSOP_GEOM_FLAGS_INOBTCNT ?1 :0 ; nrext64 = geo->flags &XFS_FSOP_GEOM_FLAGS_NREXT64 ?1 :0 ; exchangerange = geo->flags &XFS_FSOP_GEOM_FLAGS_EXCHANGE_RANGE ?1 :0 ; + parent = geo->flags &XFS_FSOP_GEOM_FLAGS_PARENT ?1 :0 ; printf(_( "meta-data=%-22s isize=%-6d agcount=%u, agsize=%u blks\n"
@@ -60,7 +62,7 @@ xfs_report_geom(" =%-22s exchange=%-3u\n" "data =%-22s bsize=%-6u blocks=%llu, imaxpct=%u\n" " =%-22s sunit=%-6u swidth=%u blks\n" -"naming =version %-14u bsize=%-6u ascii-ci=%d, ftype=%d\n" +"naming =version %-14u bsize=%-6u ascii-ci=%d, ftype=%d, parent=%d\n" "log =%-22s bsize=%-6d blocks=%u, version=%d\n" " =%-22s sectsz=%-5u sunit=%d blks, lazy-count=%d\n" "realtime =%-22s extsz=%-6d blocks=%lld, rtextents=%lld\n"),
@@ -72,7 +74,7 @@ xfs_report_geom("" , geo->blocksize, (unsigned long long )geo->datablocks, geo->imaxpct,"" , geo->sunit, geo->swidth, - dirversion, geo->dirblocksize, cimode, ftype_enabled, + dirversion, geo->dirblocksize, cimode, ftype_enabled, parent, isint ?_ ("internal log" ) : logname ? logname :_ ("external" ), geo->blocksize, geo->logblocks, logversion, "", geo->logsectsize, geo->logsunit / geo->blocksize, lazycount,
Re: [PATCH 05/24] libfrog: report parent pointers to userspace
Looks good;
PATCH 6/24 libfrog: add parent pointer support code
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add some support code to libfrog so that client programs can walk file descriptors and handles upwards through the directory tree; and obtain a reasonable file path from a file descriptor/handle. This code will be used in xfsprogs utilities.
--- include/handle.h | 1 libfrog/Makefile | 2 libfrog/getparents.c | 355 ++++++++++++++++++++++++++++++++++++++++++++++++++ libfrog/getparents.h | 42 ++++++ libfrog/paths.c | 168 ++++++++++++++++++++++++ libfrog/paths.h | 25 ++++ libhandle/handle.c | 7 + 7 files changed, 597 insertions(+), 3 deletions(-) create mode 100644 libfrog/getparents.c create mode 100644 libfrog/getparents.h
include/handle.h +1 -0
@@ -17,6 +17,7 @@ struct parent;extern int path_to_handle (char *__path,void **__hanp,size_t *__hlen);extern int path_to_fshandle (char *__path,void **__fshanp,size_t *__fshlen);extern int fd_to_handle (int fd,void **hanp,size_t *hlen); +extern int handle_to_fsfd (void *,char **);extern int handle_to_fshandle (void *__hanp,size_t __hlen,void **__fshanp,size_t *__fshlen);extern void free_handle (void *__hanp,size_t __hlen);
libfrog/Makefile +2 -0
@@ -20,6 +20,7 @@ convert.c \ crc32.c \ file_exchange.c \ fsgeom.c \ +getparents.c \ histogram.c \ list_sort.c \ linux.c \
@@ -46,6 +47,7 @@ dahashselftest.h \ div64.h \ file_exchange.h \ fsgeom.h \ +getparents.h \ histogram.h \ logging.h \ paths.h \
libfrog/getparents.c new file +355 -0
355 lines not on this page · raw message
libfrog/getparents.h new file +42 -0
42 lines not on this page · raw message
libfrog/paths.c +168 -0
177 lines not on this page · raw message
libfrog/paths.h +25 -0
@@ -58,4 +58,29 @@ typedef struct fs_cursor {extern void fs_cursor_initialise (char *__dir,uint __flags,fs_cursor_t *__cp);extern fs_path_t *fs_cursor_next_entry (fs_cursor_t *__cp); +/* Path information. */ + +struct path_list ; +struct path_component ; + +struct path_component *path_component_init (const char *name,uint64_t ino); +void path_component_free (struct path_component *pc); + +struct path_list *path_list_init (void ); +void path_list_free (struct path_list *path); +void path_list_add_parent_component (struct path_list *path, +struct path_component *pc); +void path_list_add_component (struct path_list *path,struct path_component *pc); +void path_list_del_component (struct path_list *path,struct path_component *pc); + +ssize_t path_list_to_string (const struct path_list *path,char *buf, +size_t buflen); + +typedef int (*path_walk_fn_t )(const char *name,uint64_t ino,void *arg); + +int path_walk_components (const struct path_list *path,path_walk_fn_t fn, +void *arg); + +bool path_will_loop (const struct path_list *path,uint64_t ino); +#endif /* __LIBFROG_PATH_H__ */
libhandle/handle.c +4 -3
@@ -29,7 +29,6 @@ typedef union { } comarg_t;static int obj_to_handle (char *,int ,unsigned int ,comarg_t ,void **,size_t *); -static int handle_to_fsfd (void *,char **);static char *path_to_fspath (char *path);
@@ -203,8 +202,10 @@ handle_to_fshandle(return 0 ; } -static int -handle_to_fsfd (void *hanp,char **path) +int +handle_to_fsfd ( +void *hanp, +char **path) {struct fdhash *fdhp;
Re: [PATCH 06/24] libfrog: add parent pointer support code
Looks good: