Free hard limit exceeded on all filesystems software for linux

vlsf is a plugin for the LUFS package which allows to write large files (4GB and more) on primitive filesystems like FAT32.
The workaround is simple: the file is stored in small files (chunks) on the real filesystem using the same method and naming scheme as the split utility.
Installing
To install lvfs, you need the prepatched LUFS package or the original version from the LUFS homepage and the patch (see above).
To patch LUFS, do
cd lufs-0.9.7
patch -p0 < ...patchfile
./bootstrap
The rest as usual:
./configure
make
(as root) make install
cd kernel/Linux
make
(as root) insmod 2.6/lufs.ko
(or the equivalent for 2.4/lufs.o)
Version restrictions:
- chunk files must be named after foo.XY (where XY follows the split(1) scheme)
- chunk size is limited to 2GB
- Link/Symlink operations not possible with virtual files
- no cache update functions - you will see wrong data if you work on directly on underlying filesystem
Enhancements:
- In LUFS, version 0.9.7, the kernel module misses an internal cast so virtual files contain the wrong data over 4GB. The vlfs patch contains fixes, but make sure that you compile and install the fixed module.

Filesystems HOWTO is about filesystems and accessing filesystems from several OSes.

This HOWTO is a document that describes a wide variety of filesystems and instructs you on how to access them from a wide variety of operating systems.

Sys::Filesystem project is intended to be a portable interface to list and query filesystem names and their properties.

It hopes to provide a consistent API to list all, mounted, unmounted, and special filesystems on a system, and query as many properties as possible with common aliases wherever possible.

mod_limitipconn is an Apache module which allows web server administrators to limit the number of simultaneous downloads permitted from a single IP address.

I have ported the original mod_limitipconn module to Apache 2.0. The Apache 2.0 port includes all the features of the Apache 1.3 version, including proxy tracking and MIME type inclusion/exclusion.

J Operating System is primarily intended for programmers.
Target Users:
- Hobbiests--You used to buy computers to do programming. They didnt do much else. Windows doesnt even come with a compiler, which is ironic since Bill Gates wrote BASIC. The "J" operating system is primarily intended for programmers. Ive attempted to lower the bar, so amateurs can contribute. I hope to recreate the dynamic environment that used to exist when the Commodore 64 was around and everyone was creating odd-ball software.
- Researchers--Im sure many lab researchers still use DOS because they have to interact with hardware, which is difficult with Windows.
Main features:
- No security! You can access all ports, memory and disk blocks to your hearts content. When youre working with your own computer, security just gets in the way and makes things slow--I hate anti-virus and anti-spyware because they just slow things down. When you know you dont have a risk, have no secrets and do regular back-ups, who needs security?
- Uniformity
- There is no virtual memory and everyone is on the same address-map. You can easily communicate between tasks, passing addresses. Addresses start at a base of zero and, essentually, segment registers are not used.
- There is basically one language to learn called "C+" which is a little more than "C", but less than "C++". You dont need to learn a scripting langauge because everything uses this syntax.
- There is an extension of ASCII called "J" rich text which allows colors, links, graphics and various widgets in your documents. This format is used in source code, documents, help, menus, etc.
- Support for compressed, encrypted and contiguous files.
- FAT32, FAT12 and ISO9660 filesystems.
- Blazing-fast compiler which can recompile everything in 5 seconds. It doesnt optimize.
- All source code is included and its still around a Meg.
Hardware:
- PS/2 mouse and keyboard
- VGA graphics
- Some hard drives. Must be on the primary or secondary IDE controller and support LBA28. Drives of 120Gig are the limit.
- Some CD-ROM/DVD drives, including burning.
- Some floppies. Just 1.44Meg and not all types.
- No USB support yet
- No network support yet
- ASCII printers on the parallel port are supported.

Extended attributes for Python is a Python module that can manipulate extended attributes in filesystems that support them.

SQL::Abstract::Limit is a portable LIMIT emulation.

SYNOPSIS

use SQL::Abstract::Limit;

my $sql = SQL::Abstract::Limit->new( limit_dialect => LimitOffset );;

# or autodetect from a DBI $dbh:
my $sql = SQL::Abstract::Limit->new( limit_dialect => $dbh );

# or from a Class::DBI class:
my $sql = SQL::Abstract::Limit->new( limit_dialect => My::CDBI::App );

# or object:
my $obj = My::CDBI::App->retrieve( $id );
my $sql = SQL::Abstract::Limit->new( limit_dialect => $obj );

# generate SQL:
my ( $stmt, @bind ) = $sql->select( $table, @fields, %where, @order, $limit, $offset );

# Then, use these in your DBI statements
my $sth = $dbh->prepare( $stmt );
$sth->execute( @bind );

# Just generate the WHERE clause (only available for some syntaxes)
my ( $stmt, @bind ) = $sql->where( %where, @order, $limit, $offset );

ngacl project is an effort to give Linux and its filesystems a full blown ACL system, similar to that used by NFSv4 and Windows.
With this software, you have 13 different access rights, dynamic inheritance, and audit ACLs. The implementation is filesystem-independent because the kernel parts are an LSM module.
In addition, there is a Samba-VFS module that enables you to alter ACLs with the Windows ACL editor.
Enhancements:
- This release adds working audit ACLs, stability, and semantic enhancements.