Free kernel software for linux

Submount is a system for automatically mounting and unmounting removable media drives like cdroms and floppy disk drives. It works with the Linux 2.6 kernel series.

A backport to the 2.4 kernel series is available now as well. Once installed, it allows removable media drives to be accessed as if they were permanently mounted.

Installing

Submount is composed of two part: a kernel module called "subfs" and a user program titled "submountd". Both must be properly installed for submount to work. The software is contained in the two directories underneath the submount directory. To build and install the software, read the files titled "INSTALL" in both directories. A few binary packages are now available.

For many distributions, there are packages for 2 different kernels available. This usually means one is for the original distribution kernel, and the second for a kernel released with recent security updates included. Check the package name and the version of the kernel installed on your system carefully to make sure that they match.

For Redhat, Fedora, and Mandrake, Choose the RPM that matches your kernel package. For Debian, download the subfs-modules package that matches your kernel-image deb, download the submountd package, and install both. The .tgz packages for Slackware 9.1 were built for the basic ide kernels, but also work for the scsi.s kernels, and hopefully for others. If you want a package for a different stock kernel from these distributions (such as smp) email me directly.

SuSE 9 contains version 0.2 of submount, with the kernel modules included in the kernel packages, and the userspace portion in a separate "submount" package. The package is included with the professional version, but not with the personal edition, so if you have the latter, get the package from SuSEs ftp site. Theres no integration with yast, however, so youll still have to edit your /etc/fstab file by hand.

SuSE 9.1 will use submount to handle removable media by default.

Linice is a source-level kernel debugger for x86 systems with the look and feel of SoftIce for MS Windows.
It is designed for people who are already familiar with SoftIce, but anyone can quickly get used to it. It can break into a running kernel at any time using a hotkey and supports breakpoints and single step on modules, the kernel, or user programs.
Linice supports the VGA frame buffer, the X Window System, serial connections, and monochrome adapters.
Enhancements:
- A bug in linsym where getlogin() would return NULL for some kernels has been fixed.
- This fixes a linsym segfault reported by a number of users.

Kernel Configuration Comparison (kccmp) provides a GUI for comparing two Linux kernel ".config" files.
It shows configuration variables with different values in a tabular format. It also shows configuration variables found in only one of the input configuration files.
Building:
kccmp by default requires Qt 3.x. However, by changing one line in kccmp.pro you can build against Qt 4.x. Note that the Qt 4.x build requilres libboost_regex as well.
The standard build is as easy as:
example:
% qmake
% make
Usage
% kccmp /path/to/first/.config path/to/second/.config
example:
% kccmp /usr/src/linux/.config /usr/src/linux/.config.old
Enhancements:
- This release was ported to Qt 3.x.
- The requirement for libboost_regex was removed.
- Building with either Qt 4.x or Qt 3.x is now supported.

kfsmd (kernel filesystem monitor daemon) is a daemon to log and view kernel filesystem changes using inotify.
Its main purpose is to allow libferris to reindex all updated files while you are sleeping.
Enhancements:
- This version was ported to the inotify syscall interface of mainline kernel 2.6.13+.

fuseftp is a userspace FTP filesystem for FUSE.
Installation:
perl Makefile.PL
make
sudo make install
If any of the preregs fail, you can install the missing modules using the cpan shell which is started with "cpan" or "cpan -MCPAN -e shell".
Usage:
marcus@hal2000:~: mkdir kernel
marcus@hal2000:~: fuseftp kernel/ ftp.kernel.org &
Successfully logged into ftp.kernel.org
[1] 7150
marcus@hal2000:~: cd kernel/
marcus@hal2000:~/kernel: ls
for_mirrors_only lost+found pub usr welcome.msg
marcus@hal2000:~/kernel: cd ..
marcus@hal2000:~: fusermount -u kernel/
[1]+ Done fuseftp kernel/ ftp.kernel.org
Enhancements:
- A --port option was added to specify a non-standard FTP port.
- The handling of file names containing special characters was fixed.
- The cache timeout option was also fixed.

libnfnetlink is the low-level library for netfilter related kernel and userspace communication.
It provides a generic messaging infrastructure for in-kernel netfilter subsystems (such as nfnetlink_log, nfnetlink_queue, nfnetlink_conntrack) and their respective users and/or management tools in userspace.
This library is not meant as a public API for application developers. It is only used by other netfilter.org projects, such as libnetfilter_log, libnetfilter_queue or libnetfilter_conntrack.
Enhancements:
- This release fixes numerous bugs and adds support for top-level APIs that are required by other pieces of the netfilter userspace world, such as libnetfilter_conntrack.

libnetfilter_queue is a userspace library providing an API to packets that have been queued by the kernel packet filter. libnetfilter_queue library is is part of a system that deprecates the old ip_queue / libipq mechanism.
libnetfilter_queue has been previously known as libnfnetlink_queue.
Main features:
- receiving queued packets from the kernel nfnetlink_queue subsystem
- issuing verdicts and/or reinjecting altered packets to the kernel nfnetlink_queue subsystem

smalloc short from Static memory buffer malloc, is an ideal memory manager for Realtime Linux Kernel modules that cant use dynamic memory offered by kmalloc because of the non-realtime nature of kmalloc.

Like malloc(), smalloc() doles out memory to client code. Unlike malloc, however, smalloc takes a static memory buffer (as an initialization parameter). It is this buffer that smalloc manages when doling out memory to client code.

This design makes smalloc ideal for use inside a Realtime Linux kernel module. It also makes it much easire to port userspace code that relies on malloc() in C or operator new() in C++ for memory management to a realtime kernel module.

For example:

(the below is linux kernel code)

< code >

#include "smalloc.h"
#include < linux/slab.h >

#define MEMPOOLSZ (1024*1024*1024)
char *buf;

...

buf = kmalloc(MEMPOOLSZ, GFP_KERNEL); /* 1 megabyte buffer in kernel
module.. */
smalloc_set_memory_pool(buf, sizeof(buf));

...

MyStruct *s;

s = smalloc(sizeof(MyStruct)); /* example of code that uses this
static memory buffer */

< /code >

The above example is a typical usage pattern of smalloc.