Free filesystems in windows software for linux

FUSE can implement a fully functional filesystem in a userspace program.
Main features:
- Simple library API
- Simple installation (no need to patch or recompile the kernel)
- Secure implementation
- Userspace - kernel interface is very efficient
- Usable by non privileged users
- Runs on Linux kernels 2.4.X and 2.6.X
- Has proven very stable over time
Installation
Some projects include the whole FUSE package (for simpler installation). In other cases or just to try out the examples FUSE must be installed first. The installation is simple, after unpacking enter:
./configure
make
make install
If this produces an error, please read on.
The configure script will try to guess the location of the kernel source. In case this fails, it may be specified using the --with-kernel parameter. Building the kernel module needs a configured kernel source tree matching the running kernel. If you build your own kernel this is no problem. On the other hand if a precompiled kernel is used, the kernel headers used by the FUSE build process must first be prepared. There are two possibilities:
1. A package containing the kernel headers for the kernel binary is available in the distribution (e.g. on Debian its the kernel-headers-X.Y.Z package for kernel-image-X.Y.Z)
2. The kernel source must be prepared:
- Extract the kernel source to some directory
- Copy the running kernels config (usually found in /boot/config-X.Y.Z) to .config at the top of the source tree
- Run make menuconfig, then make dep at the top of the source tree (only needed on 2.4 kernels)
If using the 2.6 kernel, then write access is needed to some files in the kernel source tree. Usually it is enough if you make .tmp_versions and .__modpost.cmd writable.
Enhancements:
- Stacking support for the high level API
- Add filename charset conversion module
- Improved mounting

FileSystem Investigator is a platform independent file system viewer and data extraction tool. It allows the user to:

* View the contents of the target file system in a forensicly safe manner, bypassing the normal operating system mechanisms.
* Extract files and whole directory trees of files from the source filesystem.

Since it is written in platform-neutral Java, it can be used to examine filesystems outside their native environment. For example, it can be used to view a Linux filesystem while running under Windows.

FileSystem Investigator directly accesses the source disk and processes the data using it own built in filesystem drivers. This ensures that it is safe to use FileSystem Investigator for forensic investigations.

FileSystem Investigator will never write to the source media thus important timestamps are preserved. FileSystem Investigator can also read disk-image files such as those created by dd.

Files and whole directory structures can be extracted easily from the source drive and stored for further use or analysis. Due to limitations imposed by Java, special files such as device nodes, pipes, sockets and links, cannot be extracted.

live-initramfs is a fork from Casper by Canonical. The project is used to build an initramfs suited to boot live systems.

live-initramfs is a hook for the initramfs-tools, used to generate a initramfs capable to boot live systems, such as those created by live-helper(7). This includes the Debian Live isos, netboot tarballs, and usb stick images.

At boot time it will look for a (read-only) media containing a "/live" directory where a root filesystems (often a compressed filesystem image like squashfs) is stored. If found, it will create a writable environ‐ ment, using unionfs, for Debian like systems to boot from.

To modify the code you can follow the below process:

Checkout or install live-initramfs

svn co svn://svn.debian.org/debian-live/dists/trunk/live-initramfs/

Then build to match your target platform (i.e. if target is lenny then build with lenny) with debuilder inside the live-initramfs (debuilder is part of devscripts package):

debuild -us -uc -b

Then copy the .deb generated to config/chroot_local-packages.

FindFile will be a collection of tools for recovering files from filesystems with corrupted directories/allocationtables/etc.

This can be usefull when the partitiontable (or more) of a harddisk is corrupted. Or when you have a memory-card of a digital camera which is corrupted.

For now only a tool for recovering .JPEG files is included. It is pretty fast!

flmkisofs project is a very simple program for creating ISO images with mkisofs.

flmkisofs is a very simple program for creating ISO images with the mkisofs program. It can create DVD video ISO images, Apple ISO filesystems, HFS/ISO filesystems, and El Torito or Generic bootable ISO filesystems.

It fully supports versions 1 through 3 of the ISO filesystem standard, with RockRidge and Joliet extensions, and has partial UDF support.

FSHeal aims to be a general filesystem tool that can scan and report vital "defective" information about the filesystem like broken symlinks, forgotten backup files, and left-over object files, but also source files, documentation files, user documents, and so on.

It will scan the filesystem without modifying anything and reporting all the data to a logfile specified by the user which can then be reviewed and actions taken accordingly.

FSVS stands for "Fast System VerSioning", "File System VerSioning" or "Full System VerSioning".
You may think of it as some kind of tar or rsync with versioned storage.
A future capability will be to cope with local adjustments for different machines (using branching techniques), so that most of the space needed for the backup of system-files (/bin, /usr, ...) can be shared between machines.
Main features:
- initialize itself for operation (define target URL)
- commit to this URL (backup), with meta-data support (owner, group, mode, devices, symlinks)
- show the status, ie. which entries have changed, and what was changed (data or meta-data)
- update from this URL (restore), with meta-data support
- use advanced ignore patterns, eg. to ignore all virtual filesystems like /proc, /sys, /dev (if devfs), and so on. PCRE-expressions and recursive ignore patterns are possible, too.
- Re-Synchronize with the repository, ie. get list of files in repository, to commit all different files.