Free aix filesystems software for linux

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.

Filesys::Df is a Perl extension for filesystem disk space information.

SYNOPSIS

use Filesys::Df;

#### Get information by passing a scalar directory/filename value
my $ref = df("/tmp"); # Default output is 1K blocks
if(defined($ref)) {
print "Total 1k blocks: $ref->{blocks}n";
print "Total 1k blocks free: $ref->{bfree}n";
print "Total 1k blocks avail to me: $ref->{bavail}n";
print "Total 1k blocks used: $ref->{used}n";
print "Percent full: $ref->{per}n";

if(exists($ref->{files})) {
print "Total inodes: $ref->{files}n";
print "Total inodes free: $ref->{ffree}n";
print "Inode percent full: $ref->{fper}n";
}
}

#### Get information by passing a filehandle
open(FILE, "some_file"); # Get information for filesystem at "some_file"
my $ref = df(*FILE);
#### or
my $ref = df(*FILE);
#### or
my $fhref = *FILE;
my $ref = df($fhref);

#### Get information in other than 1k blocks
my $ref = df("/tmp", 8192); # output is 8K blocks
my $ref = df("/tmp", 1); # output is bytes

This module provides a way to obtain filesystem disk space information. This is a Unix only distribution. If you want to gather this information for Unix and Windows, use Filesys::DfPortable. The only major benefit of using Filesys::Df over Filesys::DfPortable, is that Filesys::Df supports the use of open filehandles as arguments.

The module should work with all flavors of Unix that implement the statvfs() and fstatvfs() calls, or the statfs() and fstatfs() calls. This would include Linux, *BSD, HP-UX, AIX, Solaris, Mac OS X, Irix, Cygwin, etc ...

df() requires a argument that represents the filesystem you want to query. The argument can be either a scalar directory/file name or a open filehandle. There is also an optional block size argument so you can tailor the size of the values returned. The default block size is 1024. This will cause the function to return the values in 1k blocks. If you want bytes, set the block size to 1.

df() returns a reference to a hash. The keys available in the hash are as follows:
{blocks} = Total blocks on the filesystem.
{bfree} = Total blocks free on the filesystem.
{bavail} = Total blocks available to the user executing the Perl application. This can be different than {bfree} if you have per-user quotas on the filesystem, or if the super user has a reserved amount. {bavail} can also be a negative value because of this. For instance if there is more space being used then you have available to you.
{used} = Total blocks used on the filesystem.
{per} = Percent of disk space used. This is based on the disk space available to the user executing the application. In other words, if the filesystem has 10% of its space reserved for the superuser, then the percent used can go up to 110%.
You can obtain inode information through the module as well, but you must call exists() on the {files} key first, to make sure the information is available. Some filesystems may not return inode information, for example some NFS filesystems.
Here are the available inode keys:
{files} = Total inodes on the filesystem.
{ffree} = Total inodes free on the filesystem.
{favail} = Total inodes available to the user executing the application. See the rules for the {bavail} key.
{fused} = Total inodes used on the filesystem.
{fper} = Percent of inodes used on the filesystem. See rules for the {per} key.

There are some undocumented keys that are defined to maintain backwards compatibilty: {su_blocks}, {user_blocks}, etc ...

If the df() call fails for any reason, it will return undef. This will probably happen if you do anything crazy like try to get information for /proc, or if you pass an invalid filesystem name, or if there is an internal error. df() will croak() if you pass it a undefined value.

AIX::Perfstat is a Perl wrapper for perfstat() functions.

SYNOPSIS

use AIX::Perfstat;
$cput = AIX::Perfstat::cpu_total();
$diskt = AIX::Perfstat::disk_total();
$netift = AIX::Perfstat::netinterface_total();
$memoryt = AIX::Perfstat::memory_total();
$num_cpus = AIX::Perfstat::cpu_count();
$num_disks = AIX::Perfstat::disk_count();
$num_netifs = AIX::Perfstat::netinterface_count();
$cpu_data = AIX::Perfstat::cpu(desired_number = 1, name = "");
$disk_data = AIX::Perfstat::disk(desired_number = 1, name = "");
$netif_data = AIX::Perfstat::netinterface(desired_number = 1, name = "");

This Perl module lets you call all of the perfstat functions defined on AIX 5.1 and returns system data in Perl data structures.

The AIX::Perfstat::cpu_total, AIX::Perfstat::disk_total, AIX::Perfstat::netinterface_total, and AIX::Perfstat::memory_total functions each return a hashref containing all of the respective C structures.

The AIX::Perfstat::cpu_count, AIX::Perfstat::disk_count, and AIX::Perfstat::netinterface_count functions each return a count of how many structures are available from the AIX::Perfstat::cpu, AIX::Perfstat::disk, and AIX::Perfstat::netinterface functions respectively.

The AIX::Perfstat::cpu, AIX::Perfstat::disk, and AIX::Perfstat::netinterface functions each take up to two arguments and return a reference to an array of hashes. The arguments specify the number of records to return, and the name of the record to start with. These arguments are equivalent to the desired_number and name parameters to the perfstat functions. Only valid data is returned (Example: If you call AIX::Perfstat::netinterface(5) on a machine with only 2 network interfaces, the returned array will only contain two entries.) When these functions are called with a variable for the name parameter the variable will be modified in place to contain the name of the next available record, or "" if no more records are available.

ifstat is a tool to report network interface bandwith just like vmstat/iostat do for other system counters. It can monitor local interfaces by polling the kernel counters, or remote hosts interfaces using SNMP.
fstat gathers these statistics from the kernel internal counters, which is highly operating system dependent.
Right now, the following systems are supported:
Linux >= 2.2.0 (through /proc/net/dev file).
FreeBSD >= 2.2 (using the ifmib(4) interface).
Solaris >= 5.6 (using the kstat(3K) interface).
IRIX and OpenBSD (using the SIOCGIFDATA ioctl).
NetBSD and Darwin (using the route(4) sysctl interface).
Other BSDs (using the kvm(3) interface).
Digital Unix (OSF/1), Tru64, and Aix (using the legacy kmem interface).
HP-UX (using the DPLI streams interface).
Win32 native or through Cygwin (using the GetIfTable call).
If the net-snmp (or ucd-snmp) library is available, ifstat can use it to gather statistics from remote equipments (hosts, routers, switches...) or even the local host if a SNMP daemon is running.
ifstats functionnalities can as a static application. To use it, you just have to pass --enable-library while configuring ifstat.
Enhancements:
- Digital Unix (OSF/1) and Tru64 support.
- AIX support (tested on AIX v4.3).
- HP-UX support with DLPI streams interface. (sample code contributed by Jean-Marc Saffroy )
- Win32 support (native or with cygwin) with GetIfTable interface. (sample code contributed by Alexandre Raclot )
- Use net-snmp-config if present to find out SNMP flags.

zisofs filesystem is an extension to the ISO9660 filesystem that allows files, on a file-by-file basis, to be stored compressed and decompressed in real time.
The zisofs filesystem is supported by recent versions of Linux (2.4.14 or later).
Legacy systems can still read uncompressed files. zisofs-tools contains the tools necessary to create such a compressed ISO9660 filesystem and to read compressed files on a legacy system.
Enhancements:
- This release fixes the --sloppy option, which was documented but did not work.

anyfs-tools is a unix-way toolset for recovering and converting filesystems.
SYNOPSIS
build_it [-qvV] directory inode_table
anysurrect [-b blocksize] [-i input_inode_table] [-p path_prefix] [-u file_umask] [-U dir_umask] [-qvV] device inode_table
reblock [-nqvV] inode_table device blocksize
build_e2fs [ -c|-l filename ] [-b blocksize] [-f fragment-size] [-g blocks-per-group] [-i bytes-per-inode] [-j] [-J journal-options] [-N number-of-inodes] [-n] [-m reserved-blocks-percentage] [-o creator-os] [-O feature[,...]] [-q] [-r fs-revision-level] [-R raid-options] [-v] [-F] [-L volume-label] [-M last-mounted-directory] [-S] [-T filesystem-type] [-V] inode_table device [blocks-count]
mount -t any -o inodetable=file.it[,other_mount_options] device dir
build_it reads from directory recursively information about all filesystem inodes using filesystem driver (read-only maybe) for Linux OS and saves it to external inode table.
anysurrect search on device files proceeds from knowing different file types structure. Information about founded files also saves to external inode table.
reblock change filesystem block size. reblock using information from inode table change each files fragments placing so, that it was align by blocks bounds with new size.
build_e2fs proceeds from external inode table information for building ext2fs filesystems on device.
anyfs filesystem driver for Linux allows to mount device using inode table information. At mounted filesystem will be allow so file operations as deleting, moving files; making symbolic and hard links, special files; changing file access permissions. All this changes saves on unmounting to the same external inode table file and doesnt affect the device.
Usage:
Convert filesystems
anyfs-tools allows to convert filesystems. The only one requirement for source filesystem exist: there is must be FIBMAP system call ioctl(2) support in the filesystem driver (maybe read-only) for Linux OS.
Destination filesystem at that moment maybe only ext2fs. But its quite possible, that in future there are will other filesystem building support. At the first it must be interest for filesystem maintainers so as existing of convenient tool for converting of other filesystems to their one, not requesting much free space for saving of all user data, certainty will increase of the filesystem users.
In general, an applying anyfs-tools order for filesystem converting must be next:
1) build_it for reading all informaton about files placing and access permissions and saving it to external inode table file.;
2) anyfs driver for checking existence of all needed files and maybe searching of files requiring of separately saving (e.g, files eith size less than 4 Kb for ReiserFS);
3) maybe reblock for changing filesystem blocksize in occurence when destination filesystem dont support the same blocksize for this device, that source one;
4) at last ext2fs filesystem builds by build_e2fs.
Recovering damaged filesystem
For recovering files from filesystem at first intended anysurrect. After it using possible applying of anyfs filesystem drive for founded files viewing and maybe reading and saving it to another filesystem. Driver also may allow to sort files into directories so as user need in it, rename files as it necessary. At last also possible to build new filesystem with help of build_e2fs.
Recovering files from not damaged filesystem
For file recovering an aplying anyfs-tools tools order is the same that for recovering damaged filesystem excepting that at the begining you must execute build_it for reading about present filesystem file placing.
Enhancements:
- Fix anyfs building with kernel version >=2.6.19
- Some other building fix
- Fix new (from v0.84.10) i/o buffer bug in anysurrect.
- Extremally optimize anysurrect.
- Add -s option to build_it.
- Add support of converting from ntfs-3g by anyconvertfs.

PTXdist is a build system ("executable documentation") for compiling root filesystems for embedded systems.
PTXdist is based on a KConfig configuration system in combination with a set of rules which describe how all the source packages out there have to be tweaked to be compiled into a proper root filesystem.
Once a configuration has been developed, reproducing it is as easy as "make world".
PTXdist is free software released under the GPL licnese.
Enhancements:
- This revision is the beginning of a new stable series; all subsequent releases in the 1.0.x series will be bugfix-only.
- New features will be added to the next release in the 1.1.x series.
- Since 0.10.6, a new busybox version, true quilt patch handling, and several bugfixes have been added.