LCA04 Tux logo
LCA04 Main Logo
Call for Papers
Media Centre
Partner Programme
Works in Progress
Event Record
Dymocks Books
Inetd LiveCD
Speaker Coaching
About SA
Linux Australia







Sun Microsystems


The University of Adelaide


NetCraft Australia










Australian Developer Magazine

Other LCAs

2005 Canberra
2003 Perth
2002 Brisbane
2001 Sydney
1999 Melbourne


LCA 2004 started at Wed Jan 14 08:00:00 2004.



Where Would You Like One Hundred Thousand Users to Go Today? (Advocacy/Community)

Presented by Bdale Garbee in Elder Hall on Friday, January 16th at 9:00am

When any new technology gets deployed to average users on a scale of tens or hundreds of thousands at a time it impacts a whole generation of people. The technology becomes ubiquitous and takes on a momentum of its own, because it is part of people's lives and the processes of society. Free software is now at that point, and Bdale gets paid to be involved in this process all over the world.

Large deployments of Linux to the desktop in government and educational settings are underway in many nations. Particularly in the developing world, there can be immediately obvious economic benefits. But closer inspection reveals that saving money is only a small part of the equation.

What's really going on? Why are governments lining up to invest in Free Software? Why is Debian the distribution of choice in virtually all of these deployments? What are some of the challenges being faced? What roles can companies play in these deployments? Does Bdale really know the answers to any of these questions?

Programmers Are From Mars, Users/Managers/Companies are from Venus (Advocacy/Community)

Presented by Jon "maddog" Hall in Elder Hall on Thursday, January 15th at 9:00am

This talk will outline some of the issues of programmers (and particularly Free Software programmers) have versus what Users/Managers and Companies expect. It will try to explain to each audience why the other seems so odd. The speaker has been in each of these positions, both in large and small companies, and it will be given in his most inimitable way.

The state of the Open-Source Desktop (Advocacy/Community)

Presented by Havoc Pennington in Elder Hall on Saturday, January 17th at 10:00am

...including the wonderful world of


Developing and Deploying media (Applications)

Presented by Core Team in Napier G04 on Wednesday, January 14th at 2:30pm

Annodex media is a fun, open source way of creating surfable media content.

As well as being extremely easy to use and to create content for, the Annodex format provides massive benefits in terms of network deployment, including efficiency of indexing and proxying, and automated reassembly of cached fragments.

This in-depth tutorial presents the nitty-gritty of creating Annodex media and serving it on your network, including:
  • Annodex media basics: CMML and the core tools
  • General tips for structuring interesting media
  • Server and network configuration for efficient streaming
  • Development with the core libraries (libcmml and libannodex)
  • Dynamic generation of media content, including the construction of a video blogging system
  • Deployment on set-top boxes, handhelds and other devices
This is a world-first introduction to doing real work with this rock-solid new format. The intended audience includes systems administrators, network engineers, web developers, and anyone involved in managing or creating media content.

Administration of NSA Security Enhanced Linux (Applications)

Presented by Russell Coker in Napier LG29 on Wednesday, January 14th at 10:00am

A tutorial for Linux administrators on the basics of installing and administering a SE Linux system. It will be based on User Mode Linux, and the full files and documentation will be available for all delegates to use at a later date. Every delegate who wants to take full advantage of this will require their own laptop to log in.

Due to hardware limitations not everyone will be able to have their own UML session, so some sharing will be required. Therefore delegates without laptops will be able to share with others and can still attend.

Exim Tutorial (Applications)

Presented by Phil Hazel in Napier G03 on Wednesday, January 14th at 2:30pm

This tutorial will cover in some detail the facilities that Exim 4 has for controlling incoming email. These are:
  • Authentication - how Exim handles the SMTP AUTH command, and what you need to do to support it;
  • Encryption - how to configure Exim for TLS (aka SSL) support;
  • Access control lists - how the sysadmin specifies which tests to apply to incoming messages, including verifying addresses;
  • Testing - how to test all of the above.
Access control lists are one of the major features that were new in Exim 4. If you are still using Exim 3, this tutorial will show you how much easier input policy control is in Exim 4. If you have never used Exim, this tutorial will give you an insight into one of its main features.

The tutorial rather jumps into the middle of Exim, but on the way some of the fundamental configuration building blocks such as lookups and address lists will be briefly covered in the context of their use for controlling input. These items are also used in the configuration for message delivery, but this tutorial will not cover that aspect of Exim.

PHP Tips and Tricks (Programming/High Level)

Presented by Rasmus Lerdorf in Elder Hall on Wednesday, January 14th at 2:30pm

A fast-paced tutorial aimed at beginner, intermediate and advanced PHP developers all in one. We will fly through everything that is cool about PHP past, present and future. This tutorial will show you why you would use PHP to solve the Web problem no matter how small or how large your specific web problem might be. From simple flat-file based SQLite guestbook-style sites to the busiest web applications in the world.

An overview of Cairo Graphics (Programming/High Level)

Presented by Keith Packard in Napier G04 on Wednesday, January 14th at 10:00am

Cairo is a new 2D graphics library. Built on the PostScript/PDF rendering model, it produces consistent results across different output devices and operating systems.

This tutorial will present the motivation for cairo, compare it to existing systems and then provide a detailed look at the cairo API. Complete examples will demonstrate the simplicity and power of this new library. Finally, a look inside the cairo implementation will show several interesting new algorithms for drawing 2D graphics along with providing information about developing new output drivers and language bindings.

Hacking Your Own Virtual and Augmented Reality Apps For Fun And Profit! (Programming/High Level)

Presented by Wayne Piekarski in Elder Hall on Wednesday, January 14th at 10:00am

Developing virtual reality and augmented reality applications has traditionally been very expensive due to the high cost of the equipment involved. In the last few years however, desktop computers have evolved to meet the demands of the gaming community and we now have cheap 3D graphics hardware and powerful processing power that rivals million dollar machines available only a few years ago.

This tutorial gives an introduction to some of the less mainstream possibilities that are available from the PC and web cam hardware currently sitting on your desk and currently existing free software toolkits. I will present some examples that perform real time 3D tracking of a user's location within a room as well as the positions of their hands. These applications are able to operate on mobile computers carried by a user with a head mounted display, but are equally useful on fixed desktops with monitors.

The purpose of this talk is to encourage developers to think "outside the box" by showing how it is possible to experiment and hack at home with exotic new input devices and user interfaces. I will cover some of the less used and understood subsystems available under Linux, including the DRI and OpenGL 3D interfaces in XFree86, accessing video cameras using Video4Linux and the 1394 Firewire drivers, using free libraries such as ARToolkit for 3D object tracking, and scene graph libraries for rendering 3D graphics.

One other important point to remember is that hacking doesn't always involve writing software, but includes opening up and modifying your hardware with power tools. You can make your own specialised input devices but chopping up existing cheap components such as USB mice. I will cover some of the possibilities for modifying existing laptops that you can wear on a backpack or within your clothing. Attendees will be able to inspect and try out the Tinmith backpack computer, a custom developed software and hardware system I have developed that provides mobile 3D modelling capabilities in outdoor environments.

Advanced PostgreSQL (Applications)

Presented by Gavin Sherry in Napier G03 on Wednesday, January 14th at 10:00am

PostgreSQL is the most advanced open source relational database server. This tutorial will cover:

  1. A detailed look, with extensive examples, at recent features added to PostgreSQL, including:
    1. Schemas
    2. Information Schema
    3. Error reporting and handling
    4. SQL99 compliant array support
    5. Logging/debugging
    6. Increasing performance significantly with prepared statements and new client library functions
    7. The auto-vacuum daemon
    8. Other significant features added before the conference
  2. A survey of advanced SQL features in PostgreSQL
  3. A detailed look at the architecture of the backend, including:
    1. How buffering/caching works
    2. How write ahead logging works
    3. How transactions work
    4. Multi Version Concurrency Control
    5. Costing and planning
    And how the design and implementation of these in PostgreSQL impacts upon configuration and its appropriateness for use in different types of applications
  4. A look at features in development (some of which might have been released before the conference), including:
    1. Point in time recovery
    2. Table spaces
    3. Replication
    4. A native Windows version of PostgreSQL

The GNOME Platform Libraries (Programming/High Level)

Presented by Malcolm Tredinnick in Napier LG29 on Wednesday, January 14th at 2:30pm

Application developers who wish to leverage the large body of code provided by the GNOME project can easily become overwhelmed by the available possibilities. Even an experienced coder can find it difficult to know which libraries are most suited to provide which pieces of functionality and when a particular component is not available in the standard libraries. Looking at existing applications is not always successful, either because some authors are suffering from exactly the problem this tutorial aims to fix (confusion about what roles are played by which pieces) or because any application of a small enough size to be a useful example will not always use a significant portion of the platform.

The goal in this tutorial is to provide guidance when building new applications that leverage the GNOME platform. We will focus on the roles played by the various libraries in the hierarchy and provide a logical approach to designing a new application and mapping it onto the existing infrastructure. The tutorial will be mostly language independent; a developer working with any of the languages that have wrapped the GNOME libraries will be able to take away information of use to them. There will be brief notes given of any significant differences between the C, C++, Python, Perl and C# interfaces to the platform libraries.

The tutorial will be of most interest to developers aiming to develop applications on top of GNOME, rather than working with the development of GNOME itself. Great experience is not necessarily required, since we hope to encourage new developers to join the community. However, hopefully experienced developers will also benefit from a logical outline of the whole platform.


To be advised (Programming/High Level)

Presented by Jeremy Allison in Napier G04 on Saturday, January 17th at 12:00pm

To be advised.

umlsim --- A UML-based simulator (Kernel/Low Level)

Presented by Werner Almesberger in Elder Hall on Thursday, January 15th at 2:45pm

umlsim provides an environment that allows the use of regular Linux kernel or application code in event-driven simulations. It consists of an extension of user-mode Linux (UML) to deterministically control the flow of time as seen by the UML kernel and applications running under it, and a simulation control system that acts like a debugger, and that can be programmed in a Perl-like scripting language.

Since umlsim only requires minor changes to the UML kernel, simulations use the original kernel code and do not require code to be translated back and forth between the kernel and the simulation environment, as is frequently the case with other simulators. Furthermore, applications run under this UML kernel without any changes at all.

The scripting language of umlsim provides --- besides most of the functionality found in languages like C or Perl --- only the basic primitives for controlling processes (such as the UML kernel) and accessing their data. Higher-level elements, such as taps into kernel subsystems and components for model creation, is provided by libraries written in this scripting language.

One of the first uses of umlsim is to examine the behaviour of Linux TCP, but it will also be useful for many other applications in research and kernel development, including regression tests, examination of race conditions, validation of configuration scripts, and performance analysis.

This paper describes the design of umlsim, gives a brief overview of the scripting language, and concludes with real-life usage examples.

The GStreamer Multimedia Architecture (Programming/High Level)

Presented by Steve Baker in Napier LG29 on Thursday, January 15th at 1:45pm

GStreamer allows the construction of graphs of media-handling components, ranging from simple mp3 playback to complex audio (mixing) and video (non-linear editing) processing. Applications can take advantage of advances in codec and filter technology transparently. Developers can add new codecs and filters by writing a simple plugin with a clean, generic interface.

GStreamer is released under the LGPL, with many of the included plugins retaining the license of the code they were derived from, usually GPL or BSD.

More information can be found at the GStreamer project site.

This presentation will include:
  • A walk-through of the various sub-systems that make up GStreamer
  • An overview of the plugins, applications and language bindings that are available
  • A discussion of current Intellectual Property issues
  • Demos of working pipelines and code samples
  • A look to the future at what new features are being developed
This presentation should be of interest to those who write multimedia applications or libraries. Some of the presentation will be high-level enough to be of general interest.

Grouse and Grep (Kernel/Low Level)

Presented by behoffski in Napier G03 on Friday, January 16th at 2:45pm

I've always been a bit of a speed freak when it comes to writing software, striving to write programs that run as quickly as possible within the available appropriate resources.

Over the last nine years, I've been playing with high-speed architectures and algorithms for byte-oriented data handling, mostly based on table-driven threaded-assembly finite-state machines. The main application I've worked on in this area has been a grep program, Grouse Grep. I first published these works in a feature article in the November 1997 issue of Dr. Dobb's Journal entitled "High-Speed Finite State Machines".

A port of Grouse Grep to Linux was released in February 2000. This version featured some new algorithms and support modules, and in particular introduced the Self-Tuning Boyer-Moore string search algorithm and the Tracery trace/debug module.

Grouse Grep has demonstrated substantially better performance than GNU Grep in some cases, although certainly not all cases. In December 2003 I released for discussion and evaluation a set of four patches for GNU Grep that address some of the areas where its performance fell behind Grouse Grep.

This talk will be an introduction to the major technologies used in Grouse Grep, including some more in-depth discussion of the technologies where possible. The talk will also briefly discuss the strengths and weaknesses of the GNU Grep patches.

Using Linux to control your home lighting with C-Bus (Programming/High Level)

Presented by Geoffrey D. Bennett in Napier G03 on Friday, January 16th at 12:00pm

Clipsal C-Bus is a microprocessor-controlled wiring system which (among other things) replaces the traditional light-switch with a reprogrammable system where you can change which light switches control which lights. Of course, Clipsal supply Windows software for doing this reprogramming. The author (and friends) took this as a challenge, and this presentation will demonstrate how he achieved control over his home using Linux.

The presentation will cover:
  • What is C-Bus: its end-user interface, the available C-Bus devices, electrical characteristics, and interesting technical details
  • Techniques used when reverse engineering the proprietary C-Bus protocol
  • Why Perl is good for bit manipulation
  • The Linux C-Bus software that has been implemented
  • Demonstration

Reverse Engineering Linux x86 Binaries (Programming/High Level)

Presented by Sean Burford in Napier LG29 on Thursday, January 15th at 2:45pm

This fairly technical talk details the construction and use of ELF binaries under Linux, the process of reverse engineering (specifically; obtaining the design of a program from the compiled binary) and how to reverse engineer Linux binaries. An audience with a programming or systems administration background will come away from the talk with a greater understanding of the tools and techniques available under Linux for debugging and understanding the operation of programs, even without access to source code. Many of the techniques can be applied to common problems to obtain a quick understanding of what is going wrong.

PIC microcontrollers and Open Source tools (Kernel/Low Level)

Presented by James Cameron in Napier G03 on Saturday, January 17th at 12:00pm

This paper will demonstrate some uses of the PIC microcontroller architecture and the open source tools that were used during project development. Tools to provide source code control, syntax highlighting editing, configuration control, code assembly, simulation, and device programming are described. The author has contributed to the GNU PIC assembler, was instrumental in the GPL relicensing of picprg, and has used PIC microcontrollers extensively as a hobby.

Infrastructure for User-Level Device Drivers in Linux 2.5 (Kernel/Low Level)

Presented by Peter Chubb in Napier G03 on Thursday, January 15th at 1:45pm

Linux 2.5.x has good support now for user-mode device drivers --- XFree being the biggest and most obvious --- but also there is support for user-mode input devices and for devices that hang off the parallel port.

The motivations for user-mode device drivers are many:
  • Ease of development (all the normal user-space tools can be used to write and debug, not restricted to use of C only (could use Java, C++, Perl, etc), fewer reboot cycles needed, fewer restrictions on what one can do wrt reentrancy and interrupts, etc., etc.)
  • Ease of deployment (kernel/user interfaces change much more slowly than in-kernel interfaces; no licensing issues; no need for end-users to recompile to get module versions right, etc., etc.)
  • Increased robustness (less likely that a buggy driver can cause a panic)
  • Increased functionality. Some things are just plain easier to do in user space than in the kernel --- e.g., networking.
  • Increased simplicity (rather than have, say, a generic IDE controller that has to understand the quirks of many different kinds of controllers and drivers, you can afford to pick at run time the controller you really need)
There are however some drawbacks, the main ones being performance and security.

Three recent developments have made it possible to implement an infrastructure for user-level device drivers that perform almost as well (in some cases better than) in-kernel device drivers. These are the new pthreads library (and corresponding kernel changes: futexes, faster clone and exit, etc); fast system call support; and IOMMUs.

Now that many high-end machines have an IOMMU, it becomes possible, at least in theory, to provide secure access to DMA to user processes.

Fast system calls allow the kernel/user crossing to be extremely cheap, making user-process interrupt handling feasible.

And fast context-switching and IPC for posix threads, means that multithreaded device drivers can have the kind of performance that until recently was only available in-kernel.

In my paper and talk I shall describe the infrastructure necessary to provide low-latency access to interrupts and DMA from a user process. I shall also present some benchmarks for an IDE controller that show essentially the same I/O performance as the in-kernel driver, at the expense of slightly increased processor utilisation.

Perl 6 in a nutshell (Programming/High Level)

Presented by Damian Conway in Elder Hall on Friday, January 16th at 1:45pm

The Perl 6 design process is about keeping what works in Perl 5, fixing what doesn't, and adding what's missing. That means there will be a few fundamental changes to the language, a larger number of extensions to existing functionality, and a handful of completely new features. In this talk co-designer of Perl 6, Damian Conway, will showcase some of the ways in which these modifications, enhancements, and innovations will work together to make the next major version of Perl even more insanely great.

An inside view of changes in the 2.6 kernel (Kernel/Low Level)

Presented by Jonathan Corbet in Elder Hall on Friday, January 16th at 2:45pm

The newly-released 2.6 kernel contains a vast number of changes which were made over the 2.5 development series. This talk will look at some of those changes from the point of view of a kernel programmer; rather than talk about new features, we'll look at API changes and new ways of doing things. The emphasis will be on why those changes were made and what kernel hackers (especially driver programmers) need to do to write safe and correct code for 2.6.

A Complete College Curriculum using Open Source (Advocacy/Community)

Presented by Jon "maddog" Hall in Elder Hall on Friday, January 16th at 11:00am

Taking the college curricula of several universities, the author will make available a set of abstracts, books and minutia outlining the materials for the complete undergraduate degree program in computer science, along with rationale as to why each piece is appropriate.

Exim 4 Process Structure: Why anarchy is better than central control (Applications)

Presented by Phil Hazel in Elder Hall on Thursday, January 15th at 12:00pm

This describes the way Exim processes interact, and argues that the lack of a central controlling process improves overall performance.

Remote Control and Scripting of Gnome Applications with Python (Programming/High Level)

Presented by James Henstridge in Napier LG29 on Friday, January 16th at 11:00am

Gnome 2.x contains a number of hooks that allow scripting of applications using CORBA. These hooks include:
  • custom CORBA interfaces exposing the functionality of an application.
  • Accessibility framework exposes information about the user interface of applications.
The Python bindings for Gnome 2.x include a new CORBA binding called PyORBit that makes interaction with Gnome's CORBA services a lot easier. The new CORBA bindings can load interface information from IDL files, type libraries or from CORBA servers directly through introspection (without the need of an interface repository).

This talk will give a brief description of what PyORBit is, and then go on to show how it can be used with the Gnome Python bindings to control other applications.

Examples will include use of Nautilus and Evolution interfaces, and the use of the AT-SPI accessibility interfaces.

LVS: Active-Active Servers and Connection Synchronisation (Applications)

Presented by Simon Horman (Horms) in Napier G03 on Thursday, January 15th at 2:45pm

The Linux Virtual Server Project (LVS) allows the Linux Kernel to load balance TCP and UDP services. The host running LVS is referred to the Linux Director. All connections for load balanced services are forwarded by the Linux Director.

This system can be made highly available by having a standby linux director that can take over when a failure occurs or system maintenance is necessary. However, when failover occurs existing connections are broken as the standby does not know about them. Session Failover attempts to resolve this problem by sharing session information between active and stand-by directors.

If linux directors are stable and are taken down for system maintenance infrequently, then the standby is idle for much of the time. This is arguably a waste of resources. Also, the throughput of the cluster is limited by that of the linux director. By having multiple linux directors in an active-active configuration these problems can be alleviated.

This paper presents an implementation of active-active linux directors as well as significant enhancements to the session failover capabilities of LVS. These implementations should be considered as work in progress. It is intended for a technical audience that is interested in building large internet sites.

Hunting regressions in GCC (Programming/High Level)

Presented by Janis Johnson and Paul Larson, James Kenefick in Napier LG29 on Saturday, January 17th at 12:00pm

A software regression is a bug that exists in some version of software and did not exist in a previous version of that software. Regression testing helps to identify bugs which creep into software with new changes. In most projects, however, test suites don't catch all regressions, and some are discovered by users upon upgrading to a new release. A new bug must have been introduced or exposed by a specific set of changes, and knowing which change introduced a regression can be valuable information for the developer who is fixing that bug.

This paper describes general strategies for identifying the cause of a regression and when it might be practical to automate the search for a particular bug in a particular project. We then describe the use of automated regression hunts for the GNU Compiler Collection and for the Linux kernel. We look at differences in the two projects that require different tools and strategies for identifying regressions, and compare the value of the resulting information for developers within the two projects. We then speculate on the applicability of these techniques for other software projects.

Vinum (Kernel/Low Level)

Presented by Greg "groggy" Lehey in Napier G03 on Friday, January 16th at 11:00am

The Vinum Volume Manager is a block device driver which implements virtual disk drives. It isolates disk hardware from the block device interface and maps data in ways which result in an increase in flexibility, performance and reliability compared to the traditional slice view of disk storage. Vinum implements the RAID-0, RAID-1, RAID-4 and RAID-5 models, both individually and in combination.

Vinum has been available as free software for over five years. It is currently a component of the FreeBSD and NetBSD operating systems, and a version is available for OpenBSD.

This paper discusses its background, its implementation, performance considerations and the challenges of porting to different platforms, notably Linux.

MySQL RoadMap - what we have now and where we are heading (Applications)

Presented by Arjen Lentz in Napier G04 on Friday, January 16th at 11:00am

In this presentation I will first outline the current key features of the MySQL RDBMS, supported by a little history and an overview of the MySQL development and release philosophy. We then go on to look at what new funky stuff the MySQL development team is working on.

Come and hear it all from the source - your "when will MySQL support <this>?" will be answered! Interestingly, the answer these days is often in the form of "yes we have supported <that> for a few years now, since version x.xx" ;-)

Verified Executables for NetBSD (Kernel/Low Level)

Presented by Brett Lymn in Napier G03 on Thursday, January 15th at 12:00pm

In 2000 the author performed a proof of concept modification to the NetBSD kernel source. This modification made the kernel evaluate the md5 fingerprint of a file on disk and verify the evaluated fingerprint against a pre-loaded list of known fingerprints when an attempt to execute a file is made. By performing this check the kernel can verify that the on-disk copy of the file has not been modified. This meant that a trojan horse program would be detected and prevented from running. An important component of the scheme was the caching of the fingerprint comparison result which reduced the computational impact. Initially this method only applied to statically linked binaries but further development provided the ability to detect tampering of dynamically linked binaries by verifying the fingerprints on shared libraries. This version of the code was committed to the NetBSD kernel tree and is available in the NetBSD-current branch. After the code was committed, further work was performed on the fingerprint verification to extend the verification to encompass fingerprints at the pager level. This means that pages of an executable are verified when they are brought in from storage which has the effect of preventing a binary being overwritten on storage, the pager bringing those pages in from storage and running the modified page. In effect, by using this scheme the storage the executables are stored on no longer need to have any implicit trust, the kernel can detect modifications and stop the execution of a modified binary, even if the process is already running. It extends the zone of trust from simply being the disk in the machine out onto the network.

Could SCO v IBM Happen to You? (Advocacy/Community)

Presented by Jeremy Malcolm in Napier LG29 on Thursday, January 15th at 11:00am

SCO's litigation against IBM is widely and properly regarded as an opportunistic and disingenuous gambit that has seriously backfired on the company. However, SCO's point is that the open source development model does not adequately vet contributors' code for violations of intellectual property rights. There is some truth in this, particularly since it is possible to breach intellectual property rights (such as patent rights) completely innocently. Regardless of the merits of SCO's claim, open source developers do need to sit up and take notice of the issues the litigation has raised. This presentation will enumerate those issues, and suggest some of the steps that open source developers should be taking to address them, and thereby protect themselves against litigious intellectual property owners.

Libsysfs --- an API to gather device information in Linux (Kernel/Low Level)

Presented by Ananth N Mavinakayanahalli in Napier LG29 on Friday, January 16th at 1:45pm

The latest Linux 2.6 kernel version includes a new driver model, a set of common data structures and operations abstracted from various subsystems. Sysfs, a new RAM-based file system included in the 2.6 kernels, takes advantage of the new driver model by exposing system device information to User Space. Sysfs is intended to be the device tree for Linux.

We present, Libsysfs which is a User Space library that provides applications with a programming interface to the sysfs file system and system device data. The library reduces the need for each applications to know how the file system is arranged and managed, providing common calls to query device attributes and relationships. The API is also meant to be stable, providing an interface that will not change while sysfs may change underneath it.

Libsysfs currently obtains system device information based on "bus", "class", and "devices." The three categories reflect sysfs' device representation. The "bus" subsystem under sysfs represents a bus view of system buses and their devices. "Class" refers to system device classes like "net", "scsi_host", and "usb." "Devices" represents the hierarchical view of all system devices. The library provides functions for listing devices by these categories as well as reading and writing to device attributes, represented as sysfs files.

There are three applications currently being developed that use libsysfs to query system device information. Greg Kroah-Hartman's udev --- a User Space replacement for devfs, Linux Event Logging project's "Error Log Analysis", and Linux Diagnostic Tools project's sysdiag diagnostic command-line interface.

This paper discusses:
  1. Need for Libsysfs
  2. The APIs associated with Libsysfs
  3. Design of Libsysfs
  4. Current state of Libsysfs.
  5. Future enhancements planned for Libsysfs, including specific subsystem support like SCSI, PCI, and USB.
The authors look forward to community involvement to help guide and improve the library.

RCU vs. Locking Performance on Different CPUs (Applications)

Presented by Paul E. McKenney in Napier LG29 on Friday, January 16th at 12:00pm

RCU has provided performance benefits in a number of areas in the Linux 2.5 kernel, as well as in several other operating system kernels. This experience has generated a number of useful rules of thumb, analytic comparisons of RCU to other locking techniques, and system-wide comparisons of specific RCU patches to the Linux kernel. However, there have not been any measured comparisons of RCU to other locking techniques under a variety of conditions running on different types of CPUs.

This paper fills that gap, comparing RCU to other locking techniques on a number of CPUs using a hash-lookup micro-benchmark. The read intensity, number of CPUs, and hash-chain length are varied to gain better insight into when RCU is the right tool for the job.

Maintaining lots of apt-get capable linux machines with apt and getupdates. (Applications)

Presented by Marc Merlin in Elder Hall on Saturday, January 17th at 12:00pm

Maintaining lots of linux machines with apt, and getupdates
  • Introduction to apt-get/apt-rpm
  • Pushing versus pulling updates
  • Design and benefits of getupdates
    • Clients are all kept up to date and receive and apply updates, even if they've been down for an unknown amount of time
    • Clients can be installed from a boot floppy, or any boot media, or from an old disk image which will update itself when the machine is booted
    • Updates are checkpointed and designed to stop on any failure and restart and re-run until they succeed, guaranteeing a consistent, known state for all clients
    • Any install where the RH portion completed, and getupdates was installed can continue and recover even if the machine is unplugged or crashes during the postinstall
    • No need to write separate scripts for the install and machine updates: an update automatically gets run by the install
    • Support for several TARGETS (tracks) that a server can be in, which allows client to either be tracking a server install or a workstation install, and run either unstable/testing updates (LEAD), or stable/tested updates (GOLD)

"Free Software. Why we did it. The AOL|7 Story" (Advocacy/Community)

Presented by Graeme Merrall in Napier G04 on Thursday, January 15th at 12:00pm

Enterprise level web development in Australia is on the whole quite Microsoft-centric. In the banking and finance sector, for example, all of the top 10 sites except for Citibank used Microsoft IIS as their web serving platform[1].

AOL|7 has taken the less common path of pursuing the Free Software alternative for its enterprise hosting and ISP services. In March 2003, AOL|7 launched a DSL-based broadband service utilising Free Software in its infrastructure. In addition, AOL|7 builds and hosts websites for Channel 7's online properties. The Seven Network is using Free Software in nearly all aspects of site development and hosting including development tools, databases, operating systems.

This paper discusses the Free Software AOL|7 has used in its products and infrastructure. Also discussed will be the history and motivation behind AOL|7's use of Free Software in the enterprise. The presentation will also touch on some of the hurdles AOL|7 has encountered along the way and the lessons that have been learnt. Finally there will be an overview of various Free Software initiatives at AOL Time Warner.

[1] Source: Red Sheriff June 2003 report

php-apd (Programming/High Level)

Presented by Jonathan Oxer in Napier LG29 on Friday, January 16th at 2:45pm

PHP has undergone incredible growth in the last couple of years and is now being used for a huge range of tasks ranging from tiny scripts to large-scale web applications. Some web applications have hundreds of thousands of lines of PHP code, and the fact that PHP can scale to these sorts of levels is a great testament to its design and the efficient Zend Engine that actually manages PHP code execution.

Of course, bigger and more complex projects result in more load on your servers, and when you throw a database into the mix you have even more potential performance bottlenecks to keep track of. A typical scenario is that you've added a few new features to a web application, and now you're seeing more server load and memory usage, and pages seem to load slower. What can you do? Maybe you can afford to throw bigger hardware at the problem, but even if that's a viable option you should also find the parts of your code that are causing slowdowns and optimize them.

In this paper I outline the use of performance profiling to run PHP code in a controlled environment, and show how to generate a report giving statistics such as time spent within each function, how long each database query takes, and how much memory has been used.

Examples and demonstrations are based on APD, the Advanced PHP Debugger, for which I am the Debian package maintainer. I demonstrate installation of APD, show how to integrate a profiling trace into a live site without compromising performance for normal users or being overwhelmed by debugging output, process the trace output using the pprofp tool, and explain how to interpret the pprofp output.

If time permits, hints are then given on approaches to streamlining code.

The D-BUS Messaging System (Programming/High Level)

Presented by Havoc Pennington in Napier G04 on Thursday, January 15th at 11:00am

D-BUS is a message system, a simple way for applications to talk to one another. D-BUS supplies both a secure system daemon (for events such as "new hardware device added" or "printer queue changed") and a per-login-session daemon (for IPC among user applications). The message bus daemon is built on top of a general one-to-one message passing framework, which can be used by any two apps to communicate directly without involving the daemon. D-BUS can even be used for secure IPC across an intranet or the Internet. An objective of the D-BUS project is to address the IPC needs of GNOME, KDE, and other desktop applications, but it's by no means limited to this role.

This talk will present the technical details of D-BUS as it currently stands.

distcc: Learning to Fly (Advocacy/Community)

Presented by Martin Pool in Napier G04 on Thursday, January 15th at 2:45pm

distcc is a fast, free distributed compiler for C, C++ and Objective C. It cuts software build times up to tenfold, and is remarkably straightforward to use. distcc is for many Linux users the single most useful cluster computing application: it applies existing hardware to an important problem more efficiently than can be done even with far more complex solutions.

I presented a paper on distcc at the (excellent) Perth LCA in 2003. The paper was well received and generated many interesting questions, and was in fact chosen as one of the Best of Show talks. At the start of 2003, distcc was in a fairly early release. It has since developed and matured significantly, but the basic design is still the same.

distcc has been a successful small project, both achieving its performance goals and generating wide adoption and praise. Since many current or potential free software developers will be at the conference, I would like to offer some observations on how to make their own projects equally or more successful.

Topics will include
  • A brief overview of the purpose and design of distcc.
  • Choosing the right niche, and the right time.
  • Feasibility assessments for free software.
  • Choosing the right implementation language.
  • How to handle bug reports and support users.
  • Automated testing.
  • The right release rhythm, and the right level of stability.
  • Prioritising features.
My research before the conference will include interviews with successful developers to gather their ideas on these topics.

These topics are not directly technical, but they can make the difference between a project which languishes in pre-alpha obscurity, and global success.

I promise not a single reference to firearms, Libertarianism, or epic poetry. :-)

Design of a High Performance Clustered Storage Architecture for Linux (Kernel/Low Level)

Presented by Richard Sharpe in Napier G04 on Friday, January 16th at 12:00pm

While Linux clusters have been very successful in providing large amounts of compute power for relatively small amounts of money, less attention has been paid to how to provide shared data and the large amounts of aggregate IO bandwidth that some of these Linux clusters require.

Panasas has been engaged in the development of an Object-based Clustered Storage Architecture that is poised to deliver multiple Gigabytes per second of data throughput and is in use or being evaluated by a number of customers with large Linux Clusters. This architecture that decouples metadata access from data access using an out-of-band control mechanism and allows compute nodes to schedule file IOs simultaneously across the multiple Object-based Storage Devices that an individual file might reside on.

This presentation will discuss the architecture of the Panasas Storage Cluster and identify some of the differences between it and more traditional approaches. We will also look at the Linux client and what Panasas is planning to do with it. We will also present some of the approaches that Panasas is utilizing to provide more
traditional file systems like NFS and CIFS.

Linux and Simulated Systems (Applications)

Presented by Dan Shearer in Napier G03 on Friday, January 16th at 1:45pm

Complete operating systems running in fully simulated environments are important to developers, administrators and these days often users. Linux is involved in all aspects of the simulation scene. Knowing which technology to pick can be difficult, and this tutorial visits some of the main ones. Since the LCA LiveCD is implemented using these technologies it won't be hard to crash-test this talk :-)
  • User Mode Linux - run Linux inside Linux (inside Linux, if you wish) in order to safely test new kernels, run with more CPUs than you really have, use a copy-on-write filesystem to capture exactly what changes a program is making, and plenty more.
  • Can't afford 64-bit hardware yet? The Hercules 31/64-bit freeware simulator for 31 and 64-bit IBM mainframes, and Bochs with AMD x86-64 instruction set.
  • Want to see ucLinux boot inside a virtual PalmPilot? The POSE emulator is a good way to get familiar with embedded platforms commonly used for tiny firewall, VPN and similar applications.
  • Building fake environments. Loopback mount sparse files for those multi-terrabyte RAID arrays. Use tmpfs for dozens of Gb of RAM. Create entire fake WANs using the tuntap virtual ethernet driver and iptables magic. These are the tools of the trade.
  • QEMU: a modular future for simulators. QEMU can boot a Linux system, but can also be decomposed for use in projects like Wine and DOSemu, making such projects completely portable. Valgrind, which accomplishes its memory debugging magic by means of an embedded x86 processor emulator. The ability to detech CPUs and drivers from a simulated system and use them elsewhere will become increasingly important.
  • The Xen, MacOnLinux and Basilisk approach.

Fixing what's wrong with BIND (Applications)

Presented by Michael Still (Mikal) in Napier G03 on Thursday, January 15th at 11:00am

BIND is the one of the standard DNS implementations used on the Internet today, in fact, it powers most of the DNS root servers. This paper is a light hearted look at shdns, a DNS server written by myself using bash and inetd. The paper will provide an introduction to the DNS protocol, discuss the implementation of a DNS server in bash (including its many and varied drawbacks), and the modifications I had to make to the inetd source code to make it all work.

It will also explain in great depth why you wouldn't run shdns in a production environment, let alone any other environment.

On a more serious note, shdns provides an excellent example of how to provide UDP services with inetd, which is something which I found was quite poorly documented when I started writing shdns.

It should be noted that shdns implementation is now complete, and a demonstration of the glories of shell based DNS services will be provided during the talk.

A tour of my junkcode directory (Programming/High Level)

Presented by Andrew "tridge" Tridgell in Elder Hall on Saturday, January 17th at 2:25pm

Even since I started to use Linux I have kept a "junkcode" directory, where I put all the little snippets of code that I use to try out ideas. Sometimes these bits of code grow into quite useful applications and sometimes they just sit there waiting for me to find a use for them. A few years ago I started to make my junkcode directory public and I found that quite a few other people found some of my little snippets of code useful.

In this talk I will give a small tour of the accumulated code in my junkcode directory. I think there will be something of interest for everyone. Highlights include:
  • a system for installing a system wide fault handler
  • an rsync based mailer
  • a neat little embedded web server
  • a tripwire replacement
  • a 3D Tic-Tac-Toe program
  • a solution to the "goats" conundrum
I hope to convince other programmers to keep a junkcode directory of their own, both to help with their own programming and because I hope they will share it with others. It's fun, and you don't need to write any documentation!

uClinux --- Micro-controller Linux (Kernel/Low Level)

Presented by Greg Ungerer in Elder Hall on Thursday, January 15th at 11:00am

Micro-Controller Linux (uClinux) is an open source project that adds support to Linux that enable it to run on microprocessors without Memory Management Units (MMU). These types of processors have traditionaly made up the bulk of processors used in embedded systems. Some examples include the Motorola M68K and ColdFire embedded devices, ARM7 and some ARM9 cores, NEC v850, Hitachi H8/300, and FPGA soft cores like NIOS, Microblaze and Sparc LEON.

This session will cover the basic architecture of uClinux, and in particular the design and code changes required to deal with not having any memory management. The kernel, device driver, library and application level changes will be detailed and explained. Many people will be surprised at how similar Linux is without an MMU!

The presentation will also cover tools required, porting Linux to different hardware platforms, porting and developing device drivers, porting and developing applications within the uClinux environment. It will give a run down on what hardware platforms uClinux currently runs on and also what library and application packages have been ported.

The process of developing and building embedded systems around uClinux will also be covered. Particular emphasis will be given to the implications of running and developing without memory protection. This will also cover packaging of kernels and filesystems for embedded use.

This session is aimed at giving not only an introduction to uClinux, but also a "state of the nation" on where uClinux is at, and where it is going in the future. In particular the integration into the 2.5 series kernels will be covered.

To The Teeth: Arming GNOME for Desktop Success (Advocacy/Community)

Presented by Jeff Waugh (jdub) in Napier G04 on Friday, January 16th at 1:45pm

After a dark time in the wilderness, The GNOME Project has roared back into action with a blistering development schedule, rapid high-quality releases, and a fundamentally different vision for Free Software desktop usability and success. Find out how they did it, what's changed, where GNOME is going, and why! This presentation will focus on the organisational challenges posed by large Free Software projects, the Free Software desktop space, and The GNOME Project in particular.

PCI: past, present and future (Kernel/Low Level)

Presented by Matthew Wilcox (willy) in Elder Hall on Friday, January 16th at 12:00pm

To be advised.

Building LSB Compliant Applications (Programming/High Level)

Presented by Christopher Yeoh in Napier LG29 on Thursday, January 15th at 12:00pm

The goal of the Linux Standard Base (LSB) is to develop and promote a set of standards that will increase compatibility among Linux distributions and enable software applications to run on any compliant Linux system. There are now specifications available for IA32, 32 and 64 bit PowerPC, Itanium, and 31 and 64 bit zSeries architectures.

The presentation will cover what is involved in building and certifying an LSB compliant application. It will address the most important areas of the specifications that developers should be aware of, the tools available to help build compliant binaries, the test suites that can be used to check for incompatibilities, and the informal and formal certification programs.

The Lost Art of Techno-masochism, or Hacking in TeX (Applications)

Presented by Patryk Zadarnowski in Napier G04 on Thursday, January 15th at 1:45pm

It is well-known that the document typesetting system TeX is a Turing-complete language, and, as such, may be used to solve arbitrary programming problems. Many TeX users who have been exposed to the design of LaTeX packages even realise that hacking in TeX may be USEFUL. It is a well-kept secret of the TeX elite (TeXperts) that it is also a lot of FUN.

It is the purpose of this paper to explain the mechanics of using conventional programming structures in TeX, while exposing the utility of writing TeX programs, in a hope of initiating a few of its readers into the inner circle of TeX addicts.

The author of this paper has written a number of TeX programs himself, including kfish and lambdaTeX, a popular pretty-printing package for the functional language Haskell, written entirely in over 3000 lines TeX code. By working directly in TeX, lambdaTeX allows authors to incorporate neatly-typeset fragments of programs in LaTeX documents simply by pasting the code into an appropriate \begin{}..\end{} environment, without resorting to any external preprocessing tools or heavy manual annotations, or putting up with the ugliness of code typeset with the "verbatim" environment.

The indented audience of this paper are UNIX programmers who:
  1. enjoy hacking, and
  2. use TeX or LaTeX to typeset technical papers containing programming code, and
  3. really, truly love hacking.
As such, it should fit neatly into

Few people realise that, from the language-theoretic point of view, TeX belongs to the lazy continuation-passing family of programming languages, which includes a few other popular languages such as Standard ML, Lisp and Scheme. Continuation passing style (CPS) has been successfully employed in the theoretical computer science community to model and implement sophisticated language features such as exceptions and concurrency. In C, a primitive form of CPS is available in the form of "setjmp/longjmp". The paper explains this style of programming in terms that should be comprehendible to any competent hacker, even without a prior background in functional or declarative languages.

Once the continuation-passing style is understood, it is a small step to move from coding in ML to writing programs in TeX, and this paper will demonstrate how to make this step without requiring any prior knowledge of lambda calculus or functional programming.

Last but not least, it is a purpose of this paper to cultivate the old tradition of minimalistic hacking --- doing the impossible with seemingly-inadequate tools, and, most importantly, having lots of fun in the process. In today's climate of a commercialization of the open source, it is worthwhile to look back to the days gone by, when public software was created only by hackers having fun over a cup of coffee.

Corporate Linux Evangelism: Getting Free Software in through the Front Door (Advocacy/Community)

Presented by Con Zymaris in Elder Hall on Thursday, January 15th at 1:45pm

This presentation is intended for those who either work in a corprate or government environment, or have corporate/government clients, and would like to increase the uptake of Linux and Free Software within that environment.

All the business arguments, whitepapers, sample presentation material for management perusal, ROI and TCO reports, case studies and policy information pointers necessary to achieve this aim will be covered. Also provided will be information on extant technical pilot-project and full-scale rollout procedures/documents for both Linux servers and desktops.
Linux® is a registered trademark of Linus Torvalds.
The original Tux penguin is Copyright © by Larry Ewing.
All material on this page is Copyright © "Linux Australia" unless otherwise noted.