Free kernel solaris sparc data recovery 4.01 software for linux

Poisson Media Recovery project can be used to retrieve slightly damaged files from CD-ROM media.

It sequentially mounts and umounts the device, and on each mount it tries to read as many new 512 byte sectors as possible.

I was able to use this tool to save some files from old CDs.

Solaris::Kstat is a Perl module to access Solaris Kstats from Perl.

SYNOPSIS

use Solaris::Kstat;
my $kstat = Solaris::Kstat->new();
my ($usr1, $sys1, $wio1, $idle1) =
@{$kstat->{cpu_stat}{0}{cpu_stat0}}{qw(user kernel wait idle)};
print("usr sys wio idlen");
while (1)
{
sleep 5;
if ($kstat->update()) { print("Configuration changedn"); }
my ($usr2, $sys2, $wio2, $idle2) =
@{$kstat->{cpu_stat}{0}{cpu_stat0}}{qw(user kernel wait idle)};
printf(" %.2d %.2d %.2d %.2dn",
($usr2 - $usr1) / 5, ($sys2 - $sys1) / 5,
($wio2 - $wio1) / 5, ($idle2 - $idle1) / 5);
$usr1 = $usr2; $sys1 = $sys2; $wio1 = $wio2; $idle1 = $idle2;
}

This module provides a tied hash interface to the Solaris kstats library. The kstats library allows you to get access to all the stats used by sar, iostat, vmstat etc, plus a lot of others that arent accessible through the usual utilities.
Solaris categorises statistics using a 3-part key - module, instance and name. For example, the root disk stats can be found under sd.0.sd0, and the cpu statistics can be found under cpu_stat.0.cpu_stat0, as in the above example. The method Solaris::Kstats-new()> creates a new 3-layer tree of perl hashes with exactly the same structure - i.e. the stats for disk 0 can be accessed as $ks-{sd}{0}{sd0}>. The bottom (4th) layer is a tied hash used to hold the individual statistics values for a particular system resource.

Creating a Solaris::Kstat object doesnt actually read all the possible statistics in, as this would be horribly slow and inefficient. Instead it creates a 3-layer structure as described above, and only reads in the individual statistics as you reference them. For example, accessing $ks-{sd}{0}{sd0}{reads} will read in all the statistics for sd0, including writes, bytes read/written, service times etc. Once you have accessed a bottom level statitics value, calling $ks->update() will automatically update all the individual values of any statistics that you have accessed.

Note that there are two values per bottom-level hash that can be read without causing the full set of statistics to be read from the kernel. These are "class" which is the kstat class of the statistics and "crtime" which is the time that the kstat was created. See kstat(3K) for full details of these fields.

gnome-kernel-manager is a tool for managing kernel modules and more.
gnome-kernel-manager is a gui for managing the kernel modules, .... Only Linux kernel is supported.
Main features:
- Shows the list of loaded modules.
- Shows the list of all installed modules.
- Shows information about modules.
- Supports (un)loading modules.

The Linux SMP kernel uses spinlocks to protect data structures from concurrent, potentially conflicting accesses. Linux Kernel Spinlock Metering is a kernel patch that allows you to build an i386, ia64, Alpha, Sparc64, or mips64 kernel that can perform simple "metering" (record-keeping) of spinlock usage. Also available is source for an associated new command, lockstat, that is used to instruct the kernel to turn this lock metering on or off, and to retrieve the metering data from the kernel and display it in a human-readable format.

Data displayed includes the number of lock attempts, per-spinlock per-caller, the number of those attempts that were immediately successful vs. those that required the attempting locker to wait for the current lock-holder to release; the mean and max hold-time, and the mean, max, and cumulative wait-time. Whenever possible, the locking caller and the spinlocks are identified by their symbolic names, not by their virtual addresses.

Various patch sets are available. Version 1.1.4 patches the 2.2.14 kernel and reflects a relatively old flavor of Lockmeter. Version 1.4.11 patches the 2.4.16, 2.4.17, 2.5.3, and 2.5.5 kernels, and the previous release v1.4.9 patches various other releases of the 2.4.x kernel. This version 1.4 supports i386, alpha, ia64, mips64, and sparc64. The most recent version 1.5 is available as a patch against the 2.4.18 and various 2.5.x kernels, and it additionally supports mips (32-bit mips). Each is approximately 22 KB in gziped size. (Patches against a few older kernel versions are also available in the old subdirectory.) After applying the appropriate patch, make oldconfig presents a new Kernel lock metering option in the Kernel hacking subsection -- although only if CONFIG_SMP (Symmetric multi-processing support) has been enabled. The spinlock metering code is compiled into the kernel only when this new option is turned on.

Compiling the spinlock metering code into the kernel does not materially affect the kernel size because the additional code is roughly compensated for by the shrinking effect of the normally in-line locking routines now becoming procedure calls. A metering-capable kernel (i.e., with the patch applied, but data collection turned off) is negligibly slower than a non-metering-capable kernel, though a metering-capable kernel does slow when the metering data collection is turned on using the lockstat command (typically 8% for a systime==25% workload). Care has been taken to minimize performance degradation, and further improvements are in progress.

The lockstat command must also be downloaded, compiled, and installed. lockstat is a privileged command that requires root access. It reads and writes to the node /proc/lockmeter to control the kernels metering as follows:

lockstat on enables the kernels metering data collection,
lockstat options displays the collected data, and
lockstat off disables the metering data collection.

Run lockstat with no arguments to see a verbose description of the command arguments and options.

When metering is enabled, count and time data is collected in malloced arrays that are private to each CPU, thereby avoiding costly cacheblock coherency operations that would otherwise be required if all CPUs updated the same count and time fields. The lockstat command accumulates and sorts the per-cpu data at display time.

Lockmetering attempts to provide both "cause" and "effect" information about spinlock usage. The "hold time" metering exposes which spinlocks are being held and for how long, identified by where they are held inside the kernel. The "wait-time" metering exposes the effects of these hold-times when multiple CPUs concurrently contend for the same lock.

The gzip Recovery Toolkit attempts to automate the recovery of data from corrupted gzip files (including tarballs) through a program called gzrecover. gzip Recovery Toolkit package is still very experimental at this point.
99% of "corrupted" gzip archives are caused by transferring the file via FTP in ASCII mode instead of binary mode. Please re-transfer the file in the correct mode first before attempting to recover from a file you believe is corrupted.
This program is provided AS IS with absolutely NO WARRANTY. It is not guaranteed to recover anything from your file, nor is what it does recover guaranteed to be good data. The bigger your file, the more likely that something will be extracted from it. Also keep in mind that this program gets faked out and is likely to "recover" some bad data. Everything should be manually verified.
Usage:
Run gzrecover on a corrupted .gz file. Anything that can be read from the file will be written to a file with the same name, but with a .recovered appended (any .gz is stripped). You can override this with the -o option.
To get a verbose readout of exactly where gzrecover is finding bad bytes, use the -v option to enable verbose mode. This will probably overflow your screen with text so best to redirect output to a file.
Once gzrecover has finished, you will need to manually verify any data recovered as it is quite likely that our output file is corrupt and has some garbage data in it. If your archive is a tarball, read on.
For tarballs, the tar program will choke because GNU tar cannot handle errors in the file format. Fortunately, GNU cpio (tested at version 2.5 or higher) handles corrupted files out of the box.
Heres an example:
$ ls *.gz
my-corrupted-backup.tar.gz
$ gzrecover my-corrupted-backup.tar.gz
$ ls *.recovered
my-corrupted-backup.tar.recovered
$ cpio -F my-corrupted-backup.tar.recovered -i -v
If you have a previous release, please note that the patches to GNU tar have been discontinued. They were only marginally successful at best and GNU cpio does what is needed out of the box and does it far better.
Enhancements:
- Documentation updates, including a man page, plus code cleanup to better enable inclusion in GNU/Linux packages and eliminate compilation warnings.

Solaris::Disk::SVM::Graph is a Perl module for graph your Solaris Volume Manager configurations.

SYNOPSIS

my $graph = Solaris::Disk::SVM::Graph->new(
sourcedir => path/to/dir, # path to SVM config files,
# see Solaris::Disk::SVM for details
fontname => fontname,
fontsize => fontsize,
);

$graph->output(); # output the whole SVM config to svm.png

# output whole configuration
$graph->output(
output => /path/to/image.svg,
# format deduced from file name, if format
# is not present
format => png, # or anything accepted by GraphViz,
# extension will be appended to output filename
);

# output one device
$graph->output( objects => d10 ); # d10 object with sub-devices to d10.png

# output many devices on same graph
$graph->output( objects => [ d10, d11 ] );

# output one device specifying output file name & format
$graph->output(
objects => d10
output => /path/to/image.svg,
format => png,
);