System structure

In this part I shall look at the overall system structure of the CMS and what each part is supposed to do. I won't go into too much detail at this point, I just want to get an overview.

Again, the client sends a request to the CMS, this is handled by the SCGI Handler which will be a queue of tasks that does the work. We uses tasking here so we can ultimately have a number of simultaneous requests being handled at any one time which is more efficient.

On each request the CMS needs to know if the user has permission to do whatever they are requesting. e.g. a normal user cannot access the admin pages of any of the Documents, Fields or API's but a normal user can view content created by a document and it's fields.

The CMS also needs to know what to do exactly, i.e. has the user filled in a form and sent it back to the server or has the user just selected a link to view some content?

The Response Builder utilises the various elements of the CMS (i.e. Documents, Fields, API's, etc.) to build up the page from it's various parts, send it through the template parser and then pass it back to the SCGI Handler and thus back to the client.

The various elements in the CMS such as Documents, Users, Fields, etc. all access the database and thus is implied, there the database is not shown on the diagram.

If you have any comments or any ideas that I've missed out, please use the form below.

Introduction

This site is currently implemented using MODX, and not very well on my end as I wanted something fast. It is also residing on a basic Linode running Debian Linux. I was always intending on creating a new site, but was most likely going to use an existing CMS, like Drupal.

I'm not a fan of PHP and have starting wanting to redevelop this site using Ada, Linode lets me rexecute binaries directly as it is a virtual system. I could use the Common Gateway Interface, but this is old technology and every invocation of an URL would mean that an application will have to be spawned from the web server, this is rather slow. Enhancements to CGI are Simple Common Gateway Interface (SCGI) and FastCGI; the former is simple to implement (hence the name), the other is actually quite difficult. I had previously implemented code to handle the SCGI protocol for Jesse Lang's Solid framework, so I'll use this.

I'll also require a Unicode library, so I'll utilise the League library in Vadim Godunko's Matreshka framework. This does have a FastCGI implementation, but I won't be using that.

Also required is template parsing, so that the document style can be replaced easily. There is a template parser library in the AWS project I can use for this.

Key concepts

The design of this CMS is fulfill the following requirements.

• Web standards compliance
• Document revisions
• Extensibility
• User roles/permissions
• Users
• Internationalisation

High level design

First we need to think about how this CMS is going to be structured at a high-level, the following diagram shows this using the client-server model.

The CMS runs as a daemon process in the background on the operating system, the HTTPD (the web server) will be configured to send certain requests over sockets to the CMS server, the CMS will then send a response which in turn gets passed back to the client that requested it.

You'll notice in the diagram that there is an External box. This basically means that there could be other servers that the CMS daemon needs to access.

System structure

The next diagram shows how the CMS fits in with the operating system. The CMS communicates with the web server via SCGI, it also interfaces to a database server and the filesystem. Very few OS specifics will be required:

1. running the CMS as a daemon, and
2. modules architecture.

I have chosen PostgreSQL as the Database for storage of the various content within the CMS. I have heard very good things about the quality of this software from other Ada developers. There exists a number of bindings to libpq, I shall try the one in Matreshka as it also provides a common abstraction over other databases.

Abstractions

The following diagram shows the general abstractions that will be included in the CMS.

• Documents, Fields and API's are the basic content creation constructs.
• Users, Roles and Permissions are used to give the various human users of a site abilities and determine what they are allowed to do within the CMS.
• Modules, Cache and Database expose the CMS to the OS.

Documents

Documents are what the CMS is managing. Documents can be extended to create new types of documents, for example a site could have a blog document, an article document, a product document.

Each document has a number of fields that the user can complete when entering the content:

• Title
• Summary
• Body text

But the administrator can add new fields to the document type to give it more structure. For example, a site for a newspaper could add a photo field to a story document which could be shown at the top of the page and have it float to the right so the text flows around it.

As stated in the key concepts from the beginning of this article, each document has revision information. The database will essentially store a new version as new revision of the document, unless explicitly set by the user. It should be possible to roll back to a previous revision, thus deleting any subsequent revisions.

Fields

As mentioned in the previous section, Fields provide a mechanism for adding fields to the input forms on the documents. These fields can be anything and will provide extra features that an administrator wants to add to a site.

API's

API's are added to the system and can be used by other modules to build extra features or content. These API's can provide admin interfaces if one is required.

Users

These are the human's who use the site built with the CMS. Usernames and passwords, profile information can be built up separately.

Roles

Roles are given to specific users, such as Administrator, Editor, Writer, etc.

Permissions

Permissions define what a user's role can do within the CMS, e.g. deleting content.

Modules

Modules provide a mechanism to extend the CMS with new Documents, Fields or API's to enhance the CMS. An example could be an online shopping system.

Cache

The cache is where pages are stored after they've been taken from the database, parsed, tuck together with the other template fragments and sent back to the client.

N.B: I have just had a thought about this, say you have advertising on a page, this could end up getting stuck with the same ad on every page request.

Database

The database is where the content is stored.

Skip to Part 2 of this project.

If you have any comments or any ideas that I've missed out, please use the form below.

After managing to update the build scripts for TAMP's compilers, I have managed to build and run a very simple application on an STM32F4DISCOVERY board in Ada. I hacked together a basic version of the initialisation code in Ada (ported directly from C) and also used the existing startup code and linker script. This allows me to set a breakpoint in GDB and catch it when it runs. All very cool!

The app is called bink, even though it doesn't do anything. The code can be found on the TAMP GitHub site.

After a multitude of different builds and a few modifications to the GNAT runtime, I have finally managed to build GCC-4.6.1 C and GNAT compilers for bare metal.

The build utilises Newlib as the libc interface that GNAT's RTS builds upon, I've disabled sockets, files and a few other things we don't need. I've added:

1. system-bare-armel.ads as the bare metal system package (this can be used for any platform with a few modifications),
2. mlib-specific-bare.adb, to enable the building of static libs within the arm-none-eabi-* tools from project files. This has also been tested with my minimal runtime using gnat.gpr, which I was told by Arno Charlet that it wouldn't work.

This is really good progress and also gives me some insider knowledge of GNAT, which isn't pretty!

I think I will use this new information to also build a GNAT to target the chipKIT Uno32 which is based on a PIC32 (MIPS core).

After spending about 2 weeks basically compiling compilers pretty much constantly, I've managed to build gnat for arm-none-eabi with tools and without the runtime system, which is the most important part.

This isn't supported by AdaCore in the FSF release so I've had to hack into the makefiles and configure scripts to enable it. Shame really, would be nice to have this built into the build system already. I suppose I'll just have to wait for John Marino to get it working in his fork.

But for now, here are the files I've copied from GNAT sources to make the zero-footprint (ZFP) runtime building:

Bash code
$ ./build-rts.sh beagle
Creating RTS with GCC-svn-trunk for 'beagle' board
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/boards/beagle/system.ads
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/a-unccon.ads
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/s-maccod.ads
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/interfac.ads
arm-none-eabi-gcc -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/gnat.ads
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/a-uncdea.ads
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/s-stoele.adb
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/s-atacco.adb
arm-none-eabi-gcc -gnatpg -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/ada.ads
arm-none-eabi-gcc -c -gnat2005 -gnatg -O2
  -ffunction-sections -fdata-sections
  --RTS=/home/laguest/src/mine/tamp/thirdparty/../rts/boards/beagle
  -I- -gnatA
  /home/laguest/src/mine/tamp/rts/src/common/g-souinf.ads
Exception name: SYSTEM.ASSERTIONS.ASSERT_FAILURE
Message: namet.adb:655

arm-none-eabi-gnatmake: INTERNAL ERROR. Please report.

This is so frustrating!

And yes, my script is executing a gnatmake project file to build!

I have been working on getting the basic toolchain created ready for the development of TAMP. At present there are scripts for building the toolchain, but nothing else.

Due to GNAT being broken and not being able to create a set of cross tools without a runtime, I'm having to hack this using a set of scripts which will look like they were installed by GNAT.

The next stage is the development of the Zero Profile Runtime (ZFP) based on the information found on AdaCore's GNAT Pro manual in tandem with the development of a hello world style kernel.

You can find the repository at GitHub.

I was pointed at a link which goes through a number of reasons to choose Ada over C. Although this email is now just over 11 years old, it's strange just how valid it still is.

It's quite a tricky read due to the format of the email.

After a long break from wxAda, I'm getting back into looking at it. I've decided to start again and generate the bindings automatically using the 2.9.x interface files. Binding is a difficult proces and this could take some time to acheive. I have already started to read in the XML Doxygen output from the wxWidgets interfaces and get get the class name and the member names at the moment, it's a start anyway.

On the 2nd April, I finally got around to completing a SCGI implementation in Ada, which turned out easier than expected. This was sent to Jesse Lang for inclusion in his Solid framework.

Ok, it's been a while, mainly because I didn't like what I ended up with with MODx and also the shared hosting was dog slow. I've now relocated this site onto a Linode using Lighttpd as the web hosting server and MySQL as the database; I've only use MySQL as my existing site already used it.

Both the move from Apache2 and from Vexxhost has increased the speed of this site enormously, but this will only get faster later.

Plans for the future

Now I have this newer, faster server running, this is what I intend to do with it:

• Get the mail server working using Postfix and PostgreSQL as the backend.
• Work on a new site using Simple CGI in Ada, this will be a lot faster than PHP.

I have no idea what happened yesterday when I charged it, it charged for only a few minutes then the led turned to green (meaning it's finished) yet there was virtually no charge on the battery indicator.

I charged it last night and it's now at full charge, so I'm happy at the moment.

Ubuntu Gutsy (7.10) provides the right packages to get MTP devices working, just not the right versions for the P2. To get it working somebody has put up a repository of packages with the right versions up, install these as per the instructions. These packages also add the /etc/udev/rules.d/libmtp7.rules file which has the correct line for the P2.

To mount the player in Gutsy, do the following:

1. Install mtpfs (as in the above link).
2. Uncomment the user_allow_other line in the /etc/fuse.conf so that any user can mount the player.

Bash code
$ mkdir ~/YP-P2
$ mtpfs -o allow_other ~/YP-P2/

To unmount the player type:

Bash code
$ fusermount -u ~/YP-P2

I've noticed that if RhythmBox has been started you can't use mtpfs at the same time.

Upgrading the firmware

Samsung have made this is a complete doddle to do, mount the P2, and copy over the 2 firmware files to the root of the device, unmount, remove the USB cable (I don't know if this is really necessary) and then reboot. On the first boot, it'll upgrade one of the files and shut down. Power it back up and it'll upgrade the next one and shut down again. Power on for the third time and all should be upgrded to the new firmware. Mine is now running the new Bluewave 2 firmware. Or you can see screenshots of the upgrade.

Getting the cover art to work

This took me about 2 hours to work out during which I tried all sorts of packages. Easytag doesn't work, it embeds it, but the P2 cannot read it. I couldn't work out Amarok, so that was out. Finally, I tried kid3 and it worked first time! Basically, you select all the files that you want to have the same image, add a new tag (APIC), set the encoding (UTF8), the mimetype (image/jpeg), picture type (front cover) and description (the filename in this case) and import the file into kid3. Select OK and then save all the files to disk. Easy as that!

Playlists

My success with these has been patchy really, most of the time I copy a playlist (in m3u format) to the P2 (using mtpfs, as this is supposed to convert to the native playlist format when the file is copied), I can't unmount the player (it says the device is busy). Killing mtpfs works, I can then unmount, but the playlist isn't copied across, the P2 states that it is empty. I've managed to copy a playlist over twice so far, but patchy it is.

I've had an Xclef MT-500 for about 5 years now, but it has a number of problems:

• The battery life is crap and I have to carry around a number of spares.
• internal memory can corrupt easily.
• There are no more firmware updates, and these can easily go wrong causing a broken player.

The things it got right though were:

• The provision of an SD card slot, although no-one seems to know what size limit it has.
• Has an FM radio.

So, I started to look for a new MP3 player this week. Although the Apple iPod nano 4GB MP3 Player's are very sexy, they're still too much style over substance in my opinion. So, these have been ruled out.

I would prefer a player I can upgrade the memory of, but given that these things are such a commodity these days, it's very unlikely that I'd find one that was SD card (or similar) only. I did find the iAudio D2 2GB MP3 Player and although it does have the SD card, for the price, I think it's a bit expensive.

I then found the Samsung YP-P2 8GB Bluetooth Portable Media Player which is slightly bigger than an iPOD Nano, but has a radio, plays films too (whether I'll use these features is unknown at this time though). But then, after a bit of searching on the net, I find that there is a 16GB version coming out, when? I've no idea. Also, a possibility of a dock with a mini-SD card slot in it (although a lot of people think it's a fake). So, if these 2 things pan out, I'm probably going to buy one of these.

I've found that this device can be used on Linux.

Following on from my hello world style kernel, I've decided to post a plan for what I intend to accomplish in regards to an OS design.

I've been thinking about OS designs for over 10 years on and off and have wanted to develop one. Originally, I was going to do it in C but as I now use Ada more and more I want to use this language for the implementation (and assembly where necessary). The main thing that has been stopping me from developing an OS is the thought that I didn't really know how to. I pretty much know the basics of the underlying core of an OS, e.g. setting up interrupts, memory management, etc. so that is, at least, a starting point.

So, here's the plan; develop a microkernel based OS using Ada. This OS should provide a microkernel, some basic services and be able to run some applications. I'm not aiming to provide a full OS, just something to learn from. I'm also not going to be trying to implement POSIX, it'll be something else entirely.

Targets

I intend for the OS to be portable to other architectures and it should be capable of being compiled for big-endian and little-endian machines. I'll also be aiming to provide versions for both 32-bit and 64-bit architectures.

This might seem a bit excessive, but I believe that the OS designer should start thinking about making their OS cross platform from the outset. Here is a list of the tools I will use:

• binutils-2.18
• GCC/GNAT-4.2.2
• NewLib (latest version from CVS)
• GNU Make (standard Ubuntu version is fine)
• QEMU (latest version from CVS)
• GRUB 2 (there's a problem with GRUB 1 segfaulting on my Ubuntu and the GRUB developers are only interesting in talking/helping with GRUB 2)

These tools will be available on all Linux and Win32 platforms. I'm not too sure about MacOS X, I'm fairly sure that they have the GNU tools available, they definitely have GNAT. I'll be using Ubuntu Linux and compiling my own toolchain. I'll also be attempting to port a minimal Ada runtime so I can have full GNAT tool support (including ASIS) and I will be showing the build process of each relevant component.

The QEMU emulator provides a number of system targets:

• ia32 (PC)
  • Little-endian
  • 32-bit
  • Hardware TLB
• amd64 (PC)
  • Little-endian
  • 64-bit
  • Hardware TLB
• MIPS (Malta board)
  • Endian switchable by running different emulators. On real hardware this is done when executing the kernel.
  • 32/64-bit
  • Software TLB

QEMU provides these targets and this should keep me going for a while anyway. Also, by showing how to do memory managment using a software MMU I'll get more experience as will the reader.

I also forgot to mention, that apart from being different hardware, they'll also provide interesting challenges regarding the booting environment.

After playing with Google AdSense and Amazon Affiliate code, I found that the size of the template was just wrong, so I've gone through and made it slightly wider. This allows for full size banners and more text in the width of the page, which I think is a bit nicer.

I also found that there were a few problems with IE6 (as per usual) so these have been fixed as far as I can possibly fix them.

Also, you'll note the styling on the tag cloud to the left, this is much nicer design-wise and also the line-height has been increased as IE6 (again) decided to render the text too close together.

Finally, I've added the Amazon e-store. This is a real pain as Amazon in their infinite wisdom only provide:

1. a direct link to the store on their site, or
2. a frameset to embed the store into your own site, or
3. an iframe (which is what I've used) to embed the store into you own site.

Now because of this, you have to either set the iframe to scroll if it gets too big or make the frame tall enough to handle lots of data. Why can't they provide an API so we can do what we want with it and not use a frame?

Finally, I fixed that damned date problem I was having way back when.

As you can probably tell, I've been playing with the Amazon Affiliation links and have found that:

• Most of them just don't fit on this site because their size.
• They're not customisable in regards to their size like I thought they might be.
• The optimised links don't seem to provide a close enough match to the content of the pages, oh well.
• Ths shop is too bloody wide for this site!
• It'd also be nice to customise the e-store links to a particular category or product as well.

So, all in all, I'm not that pleased with it so far, I expected so much more. Looks like I'm going to have to go back into the templates and modify them, which I hate doing.

I'll continue to look into it and see what I can find, maybe I can find some scripting API for it, that might be better.

I've just been reading an Ada blog and found a link to a number of programming tips which really should be adhered to by all programmers and managers should read it so they don't get on programmer's backs causing more stress.

Just posted on SlashDot.com is an article outlining the problems with teaching Java as a first language for CS students. I can relate to this as my uni decided to change from Ada95 to Java during the second year, this was interesting at the time, but Java had only just come out and I didn't know anything about the language at the time. I can now see it's problems. In retrospect I think my uni was just jumping on the Java bandwagon. In a way there was some foresight in this as there are now a lot of jobs in industry for Java programmers, mostly banking but even some real-time (I have no idea how well this works).

Let's face it:

1. You really should have programmed before doing a CS degree anyway, but these courses do actually go through the A-level CS stuff in the first year anyway.
2. Teaching Java is a bad idea as a first language as it doesn't touch on pointers and this is necessary for understanding the hardware (later courses will go into this).
3. Teaching C or C++ isn't a good idea either considering it teaches really bad programming habits that are hard to get out of later on. Yes, I was a C/C++ programmer before Ada.
4. If anyone is thinking about it, don't teach VB as a first language either, cos it's crap, half the time it works, type in the same program and it might just work the second time. This has been my experience!

In my CS course they tried to teach Haskell (a functional language) and PROLOG (logic) and they failed miserably. The guy teaching functional programming wasn't a lecturer, didn't like lecturing and lets face it was crap at it. He took a tape recorder into the lecture as back up just in case anyone complained about the course; which they did. The guy taking the PROLOG course was actually the head of department and was Italian, not the best English speaker in the world and didn't like teaching undergraduates. PROLOG isn't the easiest language to get to grips with, but if the lecturer can't speak English that well, he's got no chance.

Also that article mentions formal methods, they taught us discrete maths and Z, I got to the point where I could read Z (ish), but couldn't write a spec in it to save my life. Also, the formal methods used later were an extension of this but without the Z notation (just set theory really) and relating this to actual programming practice is difficult. Let's just say, I didn't really find it easy and subsequently never used it. In industry, it's unlikely students will ever use it either.

Now, unfortunately, having been out of programming for a few years after total burn out I can't say my maths is the best and I've no idea if I'll ever get back to where I was when I was at uni, so I can't say if I'll ever touch a functional language again or even formal methods. Oh well.

Conversations on #Ada keep coming back to operating systems and their kernels so I decided to dig out some code I wrote in 2000 and get it working again. I intended this code to be the basis of a microkernel written in Ada. The code presented here is a second attempt at using the latest version of GNAT (4.2.2) and binutils (2.18) as the first time I just couldn't get it working properly.

Unlike other OSes that have been written in Ada like MarteOS, RTEMS, AdaExpOS (a more full featured test kernel), I wanted to get it working using no Ada runtime, which is quite tricky. These other compilers seem to have a full runtime as they use the host's native port of the compiler and just add the -nostdlib flag when compiling. This isn't exactly the best way forward as you won't actually have this when targeting bare hardware.

Also, I didn't want to go the route of porting the Ada runtime to bare hardware - this is what other Ada OS developers do, which makes sense for specific targets, i.e. a robot in a manufacturing plant or a guided missile, but not for a general purpose OS.

It is possible to build GNAT so that there is no runtime installed. This is called the "Zero Foot Print" runtime which has to be configured from the system.ads package which needs to be modified. The configuration options that are in the private part of the system.ads package are documented in the targparm.ads package in the GNAT distribution.

Further to modifying the system package, we need to provide restrictions in the gnat.adc file. These restrictions are supplied using the Ada 2005 pragma Restrictions directive. There used to be pragma No_Run_Time but this is deprecated now, although I've heard it still works. So, even though the source provided is Ada95 it should be possible to compile it using an Ada95 compiler and using a different gnat.adc file.

The following commands will configure a basic compiler and other tools required.

Bash code
$ cd <to somewhere on disk>
$ mkdir -p build-binutils-2.18 build-gcc-4.2.2
$ tar -xjvpf binutils-2.18.bz2
$ tar -xjvpf gcc-core-4.2.2.bz2
$ tar -xjvpf gcc-ada-4.2.2.bz2
$ cd build-binutils-2.18
$ ../binutils-2.18/configure --prefix=$HOME/opt/cross-gcc \
    --target=i386-elf --host=x86_64-pc-linux \
    --build=x86_64-pc-linux --disable-nls \
    2>&1|tee config.log
$ make
$ make install
$ export PATH=$HOME/opt/cross-gcc/bin:$PATH
$ cd ../build-gcc-4.2.2
$ ../gcc-4.2.2/configure --prefix=$HOME/opt/cross-gcc \
    --target=i386-elf --host=x86_64-pc-linux \
    --build=x86_64-pc-linux --disable-nls \
    --enable-languages=c,ada --without-headers \
    2>&1|tee config.log
$ make all-gcc
$ make install-gcc

You may need to change your --host and --build options to reflect what your host machine is, you may not even need them. I've added them as Ubuntu doesn't define the platform properly.

Now you have the compiler and tools installed you can build my test kernel by downloading it from below and extracting it somewhere, just type the following:

Bash code
$ tar -xzvpf multiboot.tgz
$ cd multiboot
$ make qemu

As long as you have qemu installed somewhere, this will build a boot floppy and boot into GRUB. For some reason, it doesn't pick up the menu, so when booted type the following to get the menu:

GRUB commands
$ configfile /boot/grub/menu.lst

As it stands, I'm not sure that restricting the runtime to zero footprint is the right approach. I think that providing a very limited runtime is the best way forward. This way, the kernel developer has access to aggregates, 'Image attribute (useful for debugging) and other features. Obviously it makes no sense to allow tasking or even exceptions (as far as I can see).

Download multiboot.tgz

During my research of operating systems kernels, I got side tracked towards security mechanisms in operating systems and their kernels. Obviously, I'd heard of the usual 2:

1. Access Control Lists (ACL's), and
2. Capabilities.

ACL's are used in most OSes due to being easy to implement, and I had no idea how to implement capabilities, so I thought I'd try and research them. Seems they're incredibly hard to understand unless you're one of these research type people who spend their days writing in bizarre mathematical notation and dream in Z!

Whilst on IRC, I did go into the #erights channel on Freenode and talk to the guys there who did essentially say that an object-oriented OS is basically a capability OS. They were saying that by holding onto a capability, a process has the right to access whatever that capability points to.

Now, from what I understand, the kernels like EROS and Coyotos define a set of objects (like a class in OOP) that are defined in the kernel. Each of these objects have a bunch of capabilities associated with them, these capabilities are like the method calls of an OOP language so that other programs can call them. So, these capabilities are essentially syscalls into the kernel via Inter-Process Communication (IPC) mechanisms.

Another part of my research into other security mechanisms lead me to HiStar, which is a kernel based on Π-Calculus, no me neither! This stuff is even harder to understand than the capability papers, maybe I should try reading them for longer rather than skimming?

Persistence

Another area of capability based OSes is that they tend to use persistence. This it seems, is due to:

1. The capabilities being managed by the kernel, and
2. Not knowing what configuration capabilities should be in when the machine is rebooted.

So, how was the HURD going to do it using user-space capabilities?

Now, the idea of orthogonal persistence is a fine one:

• You don't have to worry about saving any documents, images, etc. whilst using the OS as the checkpointing mechanism will save your data at regular intervals, i.e. at, say every 5 mins, the system will take a snapshot of the current state of the OS and save this to disk.
• If somebody pulls out the mains cable by accident (or to turn on a hoover), you won't have lost everything you've been working on (you might have lost something between checkpoints though), so when you restart the machine, everything (mostly) will still be present in your session.

Persistence basically maps RAM onto disk. RAM is managed in page sized chunks (usually 4KB), so each page in RAM has a page on disk. When a program opens a file from disk, the OS will just memory map (mmap) the page from disk into RAM, now if the file is small (say, less than a page in size) and you also have quite a few small files open at any one time, you are essentially not utilising RAM efficiently.

Conclusion

1. Nobody knows how an OS based on capabilities is to present itself to the user as it's never really been done. Most capability based OSes are research projects and tend to get shelved when the research has completed and it hardly ever gets released to the public.
2. Most of it is research and can be found in (sometimes) hard to read papers.
3. Placing capabilities in the kernel seems to tie the filesystem to the kernel as well, this goes against the concept of a μ-kernel.
4. With persistence, small files (less than the page size) can cause memory to just be eaten up really quickly.

I've already set myself quite a task in using Ada as the implementation language for an OS kernel, so I think that rather than try to cram in all these extra features, I should concentrate on just getting a portable μ-kernel developed

Conversations in #Ada on IRC yesterday turned back to developing an OS in Ada, this has actually been a goal of mine for some time. I had written a demo hello world style kernel in Ada a few years ago, so I thought I'd try to recompile it using the newest version of FSF GNAT; this failed to build.

After looking through the manuals and finding pragma Restrictions, I stripped out all the other pragmas I had in there to reduce the runtime and tried it out using these pragma restrictions; all compiled ok and it even booted on QEMU!

So, I decided to try and put together a high level design document based on thoughts that I've had over the last 10 years or so, which outlines what I want in an OS. I may even get started on this thing!