sys-fs/adhocify::nest
- Ebuilds: 2, Testing: 1.3, Snapshot: 9999 Description:
adhocify uses inotify to watch for file system events.
Once an event occurs it can execute a script.
The path of the file and the event will be passed to that script.
Homepage:https://github.com/quitesimpleorg/adhocify License: ISC
sys-fs/android-simg2img::unc3nsored
- Ebuilds: 1, Testing: 1.1.4 Description:
Tool to convert Android sparse images to raw images.
Since image tools are not part of Android SDK, this standalone port of AOSP
libsparse aims to avoid complex building chains.
Provides:
- simg2img
- simg2simg
- img2simg
- append2simg
Homepage:https://github.com/anestisb/android-simg2img License: Apache-2.0
sys-fs/btrfs-heatmap::guru
- Ebuilds: 1, Testing: 9 Description: The btrfs heatmap script creates a visualization of how a btrfs filesystem is using the underlying disk space of the block devices that are added to it.
Homepage:https://github.com/knorrie/btrfs-heatmap License: MIT
sys-fs/clamfs::gentoo
- Ebuilds: 1, Testing: 1.3.0 Description:
ClamFS is a FUSE-based user-space file system for Linux with on-access
anti-virus file scanning through clamd daemon (a file scanning service
developed by ClamAV Project).
Homepage:https://github.com/burghardt/clamfs License: GPL-2
sys-fs/cryptmount::gentoo
- Ebuilds: 2, Stable: 6.3.0, Testing: 6.4.0 Description:
Cryptmount was written to make it as easy for ordinary users
to access encrypted filesystems on-demand using the newer devmapper
mechansism as it was to use the older, now deprecated, cryptoloop methods.
This offers the following advantages:
Access to improved functionality in the kernel
Transparent support for filesystems stored on either raw disk partitions or loopback files
Separate encryption of filesystem access keys, allowing access passwords to be changed without re-encrypting the entire filesystem
Storing multiple encrypted filesystems within a single disk partition, using a designated subset of blocks for each
Rarely used filesystems do not need to be mounted at system startup
Un-mounting of each filesystem is locked so that this can only be performed by the user that mounted it, or the superuser
Encrypted filesystems compatible with cryptsetup
Encrypted access-keys can be chosen to be compatible with openssl, or managed via libgcrypt, or (for 2.0 release-series) built-in SHA1/Blowfish ciphers
Support for encrypted swap partitions (superuser only)
Support for setting up encrypted filesystems or crypto-swap at system boot-up
Homepage:http://cryptmount.sourceforge.net/ License: GPL-2+
sys-fs/diskonaut::guru
- Ebuilds: 3, Testing: 0.11.0, Snapshot: 9999 Description:
Given a path on your hard-drive (which could also be the root path,
eg. /). diskonaut scans it and indexes its metadata to memory so that
you could explore its contents (even while still scanning!).
Once completed, you can navigate through subfolders, getting a visual
treemap representation of what's taking up your disk space. You can
even delete files or folders and diskonaut will track how much space
you've freed up in this session.
Homepage:https://github.com/imsnif/diskonaut License: MIT
sys-fs/dwarfs::guru
- Ebuilds: 1, Testing: 0.15.3 Description:
DwarFS is a read-only file system with a focus on achieving very high compression ratios in particular for very redundant data.
This probably doesn't sound very exciting, because if it's redundant, it should compress well. However, I found that other read-only, compressed file systems don't do a very good job at making use of this redundancy. See here for a comparison with other compressed file systems.
DwarFS also doesn't compromise on speed and for my use cases I've found it to be on par with or perform better than SquashFS. For my primary use case, DwarFS compression is an order of magnitude better than SquashFS compression, it's 4 times faster to build the file system, it's typically faster to access files on DwarFS and it uses less CPU resources.
Distinct features of DwarFS are:
* Clustering of files by similarity using a similarity hash function. This makes it easier to exploit the redundancy across file boundaries.
* Segmentation analysis across file system blocks in order to reduce the size of the uncompressed file system. This saves memory when using the compressed file system and thus potentially allows for higher cache hit rates as more data can be kept in the cache.
* Highly multi-threaded implementation. Both the file system creation tool as well as the FUSE driver are able to make good use of the many cores of your system.
* Optional experimental Lua support to provide custom filtering and ordering functionality.
Homepage:https://github.com/mhx/dwarfs License: GPL-3 MIT
sys-fs/dwarfs-bin::guru
- Ebuilds: 1, Testing: 0.15.3 Description:
DwarFS is a read-only file system with a focus on achieving very high compression ratios in particular for very redundant data.
This probably doesn't sound very exciting, because if it's redundant, it should compress well. However, I found that other read-only, compressed file systems don't do a very good job at making use of this redundancy. See here for a comparison with other compressed file systems.
DwarFS also doesn't compromise on speed and for my use cases I've found it to be on par with or perform better than SquashFS. For my primary use case, DwarFS compression is an order of magnitude better than SquashFS compression, it's 4 times faster to build the file system, it's typically faster to access files on DwarFS and it uses less CPU resources.
Distinct features of DwarFS are:
* Clustering of files by similarity using a similarity hash function. This makes it easier to exploit the redundancy across file boundaries.
* Segmentation analysis across file system blocks in order to reduce the size of the uncompressed file system. This saves memory when using the compressed file system and thus potentially allows for higher cache hit rates as more data can be kept in the cache.
* Highly multi-threaded implementation. Both the file system creation tool as well as the FUSE driver are able to make good use of the many cores of your system.
* Optional experimental Python support to provide custom filtering and ordering functionality.
Homepage:https://github.com/mhx/dwarfs License: GPL-3
sys-fs/fatsort::gentoo
- Ebuilds: 1, Stable: 1.7.1 Description:sys-fs/fatsort is a utility that sorts FAT16 and FAT32 partitions. It even can
handle long file name entries. It reads the boot sector and sorts the
directory structure recursively. The main use case is to sort files on an
Audio player that does not implement the sorting function itself but plays
the files in the same order as they were copied to the disk.
Homepage:https://fatsort.sourceforge.io/ License: GPL-2
sys-fs/ffmpegfs::guru
- Ebuilds: 2, Testing: 2.50 Description:
FFmpegfs is a read-only FUSE filesystem which transcodes various audio and video formats to MP4, WebM, and many more on the fly when opened and read using the FFmpeg library, thus supporting a multitude of input formats and a variety of common output formats.
This allows access to a multi-media file collection with software and/or hardware which only understands one of the supported output formats, or transcodes files through simple drag-and-drop in a file browser.
Homepage:https://nschlia.github.io/ffmpegfs/ License: GPL-3+
sys-fs/inotify-tools::gentoo
- Ebuilds: 1, Stable: 4.25.9.0, Testing: 4.25.9.0 Description:
inotify-tools is a set of command-line programs for Linux providing a simple
interface to inotify. These programs can be used to monitor and act upon
filesystem events. Requires a Linux kernel supporting inotify.
Homepage:https://github.com/inotify-tools/inotify-tools/ License: GPL-2
sys-fs/jfsutils::gentoo
- Ebuilds: 1, Stable: 1.1.15, Testing: 1.1.15 Description:
The jfsutils package contains administration and debugging
tools for IBM's journaled file system.
IBM's journaled file system technology, currently used in IBM enterprise servers,
is designed for high-throughput server environments, key to running intranet and
other high-performance e-business file servers.
Homepage:http://jfs.sourceforge.net/ License: GPL-2
sys-fs/lessfs::gentoo
- Ebuilds: 1, Stable: 1.7.0 Description:
Data deduplication (often called “intelligent compression” or “single-instance storage”) is a method of reducing storage needs by eliminating redundant data. Data deduplication is often used for backup purposes and for virtual machine image storage. lessfs can determine if data is redundant by calculating a unique (192 bit) tiger hash of each block of data that is written. When lessfs has determined that a block of data needs to be stored it first compresses the block with LZO or QUICKLZ compression. The combination of these two techniques results in a very high overall compression rate for many types of data. Multimedia files like mp3, avi or jpg files can not be compressed by lessfs when they are only stored once on the filesystem.
Homepage:https://sourceforge.net/projects/lessfs/ License: GPL-3
sys-fs/linux-ntfs-kmod::joecool-overlay
- Ebuilds: 1, Snapshot: 9999 Description:
Out-of-tree build of the NTFS(NTFS PLUS) filesystem driver maintained
by Namjae Jeon. Provides a backport so modern NTFS support can be used
on older kernels (6.1 and newer). The built module is named 'ntfs' and
conflicts with the legacy in-kernel NTFS driver (CONFIG_NTFS_FS).
Homepage:https://github.com/namjaejeon/linux-ntfs License: GPL-2
mdevd (available in: sys-fs/mdevd::dm9pZCAq, sys-fs/mdevd::guru, sys-fs/mdevd::nymphos)
- Ebuilds: 4, Testing: 0.1.8.2, 0.1.6.5, Snapshot: 9999Virtual Description:
mdevd is a daemon managing kernel hotplug events, similarly to udevd.
It uses the same configuration file as mdev, which is a hotplug
manager integrated in the Busybox suite of tools. However, mdev
needs to be registered as a hotplug manager and the kernel forks
an instance of mdev for every event; by contrast, mdevd is a daemon
listening to the netlink, and does not fork.
Homepage:
https://skarnet.org/software/mdevd/
https://github.com/skarnet/mdevd
License: ISC
sys-fs/mountpoint-s3-bin::guru
- Ebuilds: 1, Testing: 1.1.1 Description:
Mountpoint for Amazon S3 is a simple, high-throughput file client for mounting an Amazon S3 bucket as a local file system. With Mountpoint for Amazon S3, your applications can access objects stored in Amazon S3 through file operations like open and read. Mountpoint for Amazon S3 automatically translates these operations into S3 object API calls, giving your applications access to the elastic storage and throughput of Amazon S3 through a file interface.
Mountpoint for Amazon S3 is optimized for applications that need high read throughput to large objects, potentially from many clients at once, and to write new objects sequentially from a single client at a time. This means it's a great fit for applications that use a file interface to:
* read large objects from S3, potentially from many instances concurrently, without downloading them to local storage first
* access only some S3 objects out of a larger data set, but can't predict which objects in advance
* upload their output to S3 directly, or upload files from local storage with tools like cp
but probably not the right fit for applications that:
* use file operations that S3 doesn't natively support, like directory renaming or symlinks
* make edits to existing files (don't work on your Git repository or run vim in Mountpoint 😄)
Mountpoint for Amazon S3 does not implement all the features of a POSIX file system, and there are some differences that may affect compatibility with your application. See Mountpoint file system behavior for a detailed description of Mountpoint for Amazon S3's behavior and POSIX support and how they could affect your application.
Homepage:https://github.com/awslabs/mountpoint-s3 License: Apache-2.0 Apache-2.0 BSD BSD-2 ISC MIT openssl Unicode-DFS-2016 ZLIB
sys-fs/mtpfs::gentoo
- Ebuilds: 1, Stable: 1.1 Description:
MTPfs is a FUSE filesystem that supports reading and writing from any
MTP device, as supported by libmtp. MTPfs includes extra features such
as playlist and meta information support for MP3 players.
Homepage:https://www.adebenham.com/mtpfs/ License: GPL-3
ncdu (available in: sys-fs/ncdu::gentoo, sys-fs/ncdu::yellow)
- Ebuilds: 4, Stable: 2.9.2, 1.22, Testing: 2.9.2, 2.6, 1.22 Description:
Ncdu is a disk usage analyzer with an ncurses interface. It is designed to find
space hogs on a remote server where you don’t have an entire graphical setup
available, but it is a useful tool even on regular desktop systems. Ncdu aims
to be fast, simple and easy to use, and should be able to run in any minimal
POSIX-like environment with ncurses installed.
Homepage:https://dev.yorhel.nl/ncdu https://code.blicky.net/yorhel/ncdu License: MIT
sys-fs/ncdu-bin::gentoo
- Ebuilds: 1, Testing: 2.9.1 Description:
Ncdu is a disk usage analyzer with an ncurses interface. It is designed to find
space hogs on a remote server where you don’t have an entire graphical setup
available, but it is a useful tool even on regular desktop systems. Ncdu aims
to be fast, simple and easy to use, and should be able to run in any minimal
POSIX-like environment with ncurses installed.
Homepage:https://dev.yorhel.nl/ncdu License: MIT
sys-fs/nilfs-utils::gentoo
- Ebuilds: 1, Stable: 2.2.9, Testing: 2.2.9 Description:
NILFS is a new implementation of a log-structured file system for the
Linux 2.6 operating system. Conventional features of a log-structured
file systems (LFS) are high write performance and fast recovery time.
In addition, LFS prevents data write operations from overwriting the
disk blocks, thereby minimizing the damage to file data and system
consistency on hardware failure. Furthermore, LFS writes data and
meta-data in the correct order which helps ensuring consistency in the
entire file system. LFS can instantaneously create file system
snapshots and check the file system speedy. We implemented ``NILFS''
using modern technology: For example, the file and inode blocks are
managed by a B-tree structure, internal data are processed in 64 bit
wide word size. The B-tree structure enables ``NILFS'' to create and
store huge files.
Homepage:https://nilfs.sourceforge.net/ License: GPL-2 LGPL-2.1
sys-fs/qdirstat::didos
- Ebuilds: 1, Testing: 1.4 Description: GUI app to show where your disk space has gone and to help you to clean it up
License: GPL-2
sys-fs/safecopy::gentoo
- Ebuilds: 1, Stable: 1.7 Description: safecopy is a data recovery tool which tries to extract as much data as possible from a problematic (i.e. damaged sectors) source - like floppy drives, hard disk partitions, CDs, tape devices, ..., where other tools like dd would fail due to I/O errors.
Homepage:https://safecopy.sourceforge.net License: GPL-2+
sys-fs/shake::gentoo
- Ebuilds: 1, Stable: 1.0, Testing: 1.0 Description: Shake is a defragmenter that runs in userspace, without
then need of patching the kernel and while the system is used
Homepage:https://vleu.net/shake/ License: GPL-3
sys-fs/simple-mtpfs::gentoo
- Ebuilds: 1, Stable: 0.4.0 Description:
SIMPLE-MTPFS (Simple Media Transfer Protocol FileSystem) is a file system for
Linux (and other operating systems with a FUSE implementation, such as Mac OS X
or FreeBSD) capable of operating on files on MTP devices attached via
USB to local machine. On the local computer where the SIMPLE-MTPFS is
mounted, the implementation makes use of the FUSE (Filesystem in Userspace)
kernel module. The practical effect of this is that the end user can seamlessly
interact with MTP device files.
Homepage:https://github.com/phatina/simple-mtpfs License: GPL-2+
sys-fs/x11fs::mva
- Ebuilds: 1, Snapshot: 9999 Description: The RedirFS or redirecting file system is a layer between virtual file system switch (VFS) and file system drivers. It is implemented as an out-of-kernel module for Linux and it provides framework allowing modification of file system calls in the VFS layer. The RedirFS by itself does not provide any additional functionality and if it is loaded into the Linux kernel, it just occupies some memory space and it does practically nothing. The RedirFS is intended to be used by so-called filters. Filter is a linux kernel module (LKM) that uses the RedirFS framework. Each filter can add some useful functionality to the existing file systems like transparent compression, transparent encryption, merging contents of several directories into one, allowing writing to a read-only media and others.
Homepage:https://github.com/sdhand/x11fs License: BSD
sys-fs/xcp::gentoo
- Ebuilds: 1, Stable: 0.24.8 Description: A 'cp' alternative with user-friendly feedback and performance optimisations
Homepage:https://github.com/tarka/xcp License: GPL-3 Apache-2.0 MIT Unicode-3.0 ZLIB
xfs_undelete (available in: sys-fs/xfs_undelete::guru, sys-fs/xfs_undelete::nest)
- Ebuilds: 3, Testing: 15.0, Snapshot: 9999 Description:
It tries to recover all inodes on an XFS filesystem marked as deleted.
It's rather dumb, it just looks for the magic string IN\0\0\3\2\0\0 and
considers those as deleted inodes. Then, it tries to make sense of
the extents stored in the inode (which XFS does not delete) and collect
the data blocks of the file. That file is then stored on another
filesystem in a subdirectory, by default xfs_undeleted relative to
the current directory.
Homepage:https://github.com/ianka/xfs_undelete License: GPL-3
sys-fs/xwmfs::gentoo
- Ebuilds: 1, Testing: 0.92 Description:
This is xwmfs (X window manager file system), a userspace file system based on
fuse that allows interaction with an EWMH compliant X11 window manager
via files.
Some of its features are:
- newly appearing and disappearing windows in the X server are recognized and
the file system is updated in an event based manner
- new values for properties of window manager and windows will be reflected in
the file system in an event based manner
- properties of windows and window manager can be changed via writing to files
in the file system
- some X operations are accessible via control files in the file system
The file system can be used for easily implementing scripts that operate on
the window manager and windows (for example identifying specific windows,
rename a window, move it around and so on).
Homepage:https://github.com/gerstner-hub/xwmfs License: GPL-2
sys-fs/zerofree::gentoo
- Ebuilds: 1, Stable: 1.1.1, Testing: 1.1.1 Description:
zerofree is a small utility designed to zero-out the free space on a filesystem. It is especially useful for guests on a virtual machine before compacting their disk images.
Homepage:http://frippery.org/uml/index.html License: GPL-2
sys-fs/zfs::gentoo
- Ebuilds: 4, Stable: 2.4.4, Testing: 2.4.4, Snapshot: 9999 Description:
OpenZFS is an advanced file system and volume manager which was originally developed
for Solaris and is now maintained by the OpenZFS community
It includes the functionality of both traditional file systems and volume manager.
It has many advanced features including:
* Protection against data corruption. Integrity checking for both data and metadata.
* Continuous integrity verification and automatic “self-healing” repair
* Data redundancy with mirroring, RAID-Z1/2/3 [and DRAID]
* Support for high storage capacities — up to 256 trillion yobibytes (2^128 bytes)
* Space-saving with transparent compression using LZ4, GZIP or ZSTD
* Hardware-accelerated native encryption
* Efficient storage with snapshots and copy-on-write clones
* Efficient local or remote replication — send only changed blocks with ZFS send and receive
The OpenZFS project brings together developers from the Linux, FreeBSD, illumos, MacOS, and Windows platforms.
OpenZFS is supported by a wide range of companies.
Homepage:https://github.com/openzfs/zfs License: BSD-2 CDDL MIT modules? ( debug? ( GPL-2+ ) )
sys-fs/zfs-auto-snapshot::gentoo
- Ebuilds: 1, Stable: 1.2.4, Testing: 1.2.4 Description:
An alternative implementation of the zfs-auto-snapshot service for Linux
that is compatible with zfs-linux and zfs-fuse.
Automatically create, rotate, and destroy periodic ZFS snapshots. This is
the utility that creates the @zfs-auto-snap_frequent, @zfs-auto-snap_hourly,
@zfs-auto-snap_daily, @zfs-auto-snap_weekly, and @zfs-auto-snap_monthly
snapshots if it is installed.
Homepage:https://github.com/zfsonlinux/zfs-auto-snapshot License: GPL-2+
zfs-auto-utils (available in: sys-fs/zfs-auto-utils::guru, sys-fs/zfs-auto-utils::vowstar)
- Ebuilds: 2, Testing: 1.0.0 Description:
ZFS Automatic Scrub/Trim for Linux.
This package is ported from debian to facilitate use on other
distributions. This package renames some properties to make them more
consistent when used with zfs-auto-snapshot.
Auto TRIM is implemented using a custom per-pool property:
com.sun:auto-trim
By default, these TRIM jobs are scheduled on the first Sunday of every
month. The completion speed depends on the disks size, disk speed and
workload pattern. Cheap QLC disks could take considerable more time than
very expensive enterprise graded NVMe disks.
When com.sun:auto-trim is not present in pool, or the property is
present but value is empty/invalid, they are treated as auto.
Auto Scrub is implemented using a custom per-pool property:
com.sun:auto-scrub
By default this have a cron job entry to scrub all pools on the second
Sunday of every month at 24 minutes past midnight.
See /etc/cron.d/zfsutils-linux and /usr/libexec/zfs/scrub for details
It is possible to disable this by setting a zfs user defined property on
the root dataset for a pool.
Homepage:https://github.com/zfsonlinux License: GPL-2+