diary

We've had a new version of patchwork - the web-based patch-tracking system - online for a few weeks now at patchwork.ozlabs.org.

After Paul's presentation on patchwork at the 2008 Kernel Summit, there has been wider interest in patchwork setups for other projects. Patchwork originally hosted the Linux on Power and Linux on Cell lists, we've since added netdev, linux-mtd and linux-ext4. I've also added the main Linux Kernel mailing list (lkml), just to see how the new patchwork handles the load; all has been okay so far.

If you're interested in installing the new patchwork at your own site, you can grab the source from the patchwork project page. Installation can be a little tricky, so feel free to mail me if you need a hand.

If you're using vim as your text editor, try adding the following to your .vimrc:

highlight RedundantWhitespace ctermbg=red guibg=red
match RedundantWhitespace /\s\+$\| \+\ze\t/

Handy for telling you when there's invalid whitespace in your code. Telling you with large, red blocks:

See also: this vim tip.

Patchwork, the web-based patch-tracking system has just reached version 0.5. This release adds a few new features, mostly requested from non-maskable sources. Some noteable items from the changelog:

• Remember filter, search & order settings when navigating
• Add 'bundle' support for easy maintaining
• Bugfix: don't use listfooter regex if it isn't defined
• Allow multiple projects for one installation
• Add previous/next links for patch navigation

Visit the patchwork page for more patch-management fun.

Along the lines of bitfield, I've written a small tool to show the layout (ie, starting byte and size of each member) of C structures, called destructor:

[jk@pokey ~]$ cat in.h
#include <sys/stat.h>

struct test {
        int i;
        struct stat stat;
        char c;
        long l;
};
[jk@pokey ~]$ destructor --padding in.h
struct test {
[    0:    4] int             i
[          4]
[    8:   88] struct stat     stat
[   96:    1] char            c
[          3]
[  100:    4] long            l
}

More info on the destructor page.

After unprecedented (unprecedented I tell you!) interest from the initial post about the register-decoding utility bitfield, there is now another release available.

From the changelog:

• Add support for aliased definitions.
• Add support for non-contiguous bitfields
• Allow progressive parsing of stdin
• Add -n option to print only non-zero fields
• Add support for multiple config files & directories
• Debianize
• Add bash completion definitions
• Add vim syntax highlighting definition
• Add configuration files for powerpc and cell
• More error checking

Also, Mikey has been a total champion and put together some .deb packages. If completely untested software is more your cup of tea, then you can access the mercurial repository directly.

More information and downloads on the bitfield project page.

The plan for the next version of bitfield is to add lots more register definitions, so feel free to send your configuration files to me (and thanks to those who already have!).

Over the past few months, I've been using bitfield - a script to decode the fields within a register. It does neat stuff like this:

[jk@pokey ~]$ bitfield IOC_PTE 0xb80000000140031c
decoding as Cell IOMMU Page table entry
0xb80000000140031c [13258597302999712540]
   Page protection: 0x2 [write]
Coherence required: 0x1
  Storage ordering: 0x3 [reads & writes]
               RPN: 0x1400
              IOID: 0x31c

It's handy for those "did I really tell the hardware to do that?" problems.

Download and documentation over here.

I've recently been working on a few changes to the Kopete Meanwhile Protocol Plugin, which allows you to use Kopete, the KDE instant messenger client, to connect to Lotus Sametime servers. The update has now been committed to the development branch of Kopete, and should be find its way into to the main KDE 3.5 tree soon.

The changes implement some neat new features, such as server-side buddy-list suppport and allowing contact name lookups.

Changes are in KDE svn, revision 491724.

One of the most useful pieces of software functionality I've discovered in the last few years is the programmable completion system provided in the GNU Bourne-Again shell (bash).

Somewhat surprisingly, I've found that not a whole lot of people know about this yet, so I've put up a small document about using and extending the bash completion system.

A chat with Mikey about image processing over the weekend inspired me to play with some of the edge-detection code I wrote some time ago. It does (Sobel) edge detection on the separate RGB components of a video signal (from a little logitech webcam, using the qce-ga kernel module), colours the edges and merges each channel back to the original image to be displayed in an X window.

The edge detection algorithm is fast enough to process the 8-frame-per-second video in real time - it's quite cool to see the "line drawing" respond to actions in the scene.

The speckling on the right of the image is caused by camera noise - it'd be good to perform a dilation/erosion operation on the image before the edge detection (to remove small regions like this), but I haven't managed to do that fast enough to process the image on the fly... yet.

Mikal's Perl doesn't look much like line noise, so I thought I'd set it straight. I've also renamed rmkdir to pmkdir, so it looks less like rmdir

sub pmkdir($)
{
        my $x;
        $x .= "$_/", -d $x or mkdir $x for grep {$_ ne ''} split '/', shift;
}

Update: do -d checking in the correct place.