I guess that almost all desktop systems in the office or home are derived from one prototype, the IBM PC (personal computer), which was built around the concept of an open architecture that IBM introduced 30 years ago. It’s true that the company itself didn’t quite understand how revolutionary open hardware architecture would be a few years later, in the mid-80s. Whatever the case, the fact remains that the PC became popular because many independent manufacturers could produce a wide range of compatible peripherals. This, in turn, allowed a competitive market to develop, eventually making desktop PCs available to everyone.

The open development model of Linux first embraced the desktop market of x86 computers, and then proceeded to “capture” other architectures as well (now more than 20), ranging from x86, ARM and MIPS, to Alpha, SPARC, PowerPC, IA64 and S390.

While “desktop” platforms (x86 and ARM) have many different Linux distributions and other operating systems that can run on them, the “pure” server architectures like IA64, S390 and Power cannot boast of this — the number of distributions is much, much smaller. This fact is understandable. Quality and the cost of server hardware for industrial applications is immeasurably higher than for the usual PC. Moreover, not every Linux distribution vendor can find the resources to build and provide long-term support for major server hardware architecture — even if they are willing to.

Some time ago, I got my hands on an IBM IntelliStation POWER 285 workstation, considered the closest model to large industrial servers. The main brain of the station is a dual-core POWER 5+ processor.

Although announced back in 2005, the system is serious stuff even now. Judge for yourself: 4 GB RAM (max capacity 32 GB), with a disk subsystem that has 2×146 GB SCSI drives (max disk storage 1.2 TB). It has a self-diagnostic system and memory “self-healing” technology known as ChipKill, a remote HMC (Hardware Management Console) and a pair of NICs working at 1 Gbit. This system is unbeatable for an entry-level enterprise server and simply forces you to take another respectful look at IBM  — Big Blue creates innovative and striking products.

Well, that’s enough of an introduction. Let’s learn Linux installation and operation on IBM hardware. And later decide how it is possible to effectively exploit Linux on Power.

Remote access

IBM produces equipment that has OpenFirmware (OF) inside. This is analogous to the traditional PC BIOS used on x86 systems. With OF’s help, you can assign which source should be used to start an OS, perform a number of diagnostic procedures, etc. OF itself uses a ServiceProcessor — a special unit embedded into the big tower. When you plug in the power cord, first the ServiceProcessor starts. That initially sets up a remote access option, and then awaits the user’s response.

The user has to press the hardware Start button on the front panel. So, when plugged in, IntelliStation is never completely turned off — even with the main CPUs off, the ServiceProcessor doesn’t sleep. The scheme is reminiscent of a similar product — iLO, developed by Compaq/HP. iLO also lets one start and control a server remotely.

It’s worth noting that IBM also has additional functions run by HMC (Hardware Management Console), among which are planning and allocation of physical resources to logical partitions (LPAR/DLPAR), splitting main CPU performance onto logical CPUs (Capacity On Demand) and related actions that provide virtualisation management on POWER-based processors. Unfortunately, I can only mention these capabilities, and not go any deeper into the subject, because that would be beyond the scope of this review.

So, in order to establish an access link to the ServiceProcessor and later install Linux, you will need an RS232(F)<->RS232(F) cable and a dedicated workstation, from which you can directly control your IntelliStation 285. As a console, any PC with an installed command-line tool like minicom or surecom (a GUI alternative) will suit. Set the communication speed to 19,200 bit/s, the standard default rate for IBM hardware, plug in the power cord and wait for the login prompt after running minicom -D /dev/ttyS0 -s 19200 -o. See Figure 1.

Figure 1: Control Power hardware via RS232 cable

To start the whole system and gain access to OF, from where you can select an OS source,  choose: 1. Power/Restart Control -> 1. Power On/Off System -> 8. Power on. After that, in approximately two minutes, you will hear the noise of the fans — the big system has started initialisation and a minute later the hardware will be completely initialised, signalled via two speaker beeps.

At the same time, on the console, you should see a message from SMS (System Management Services) as in Figure 2, where you choose 1 to enter the system OF menu and then select 1. Select Install/Boot Device to choose the boot device (which you will run the installer from).

Figure 2: SMS greeting before entering OpenFirmware menu

You should see something like Figure 3, where I chose 4. IDE, because the built-in CD-ROM is connected to the IDE connector. In your version, it might be 3. CD/DVD.

Figure 3: Choose installation source

In the subsequent menu (Figure 4), I chose 2. Normal Mode Boot, which is suitable for installation, and confirmed exit from SMS. My SLES 11′s Linux kernel correctly identified the IntelliStation 285.

Figure 4: Choose boot mode

The installation process will proceed as follows:

Welcome to SuSE Linux Enterprise 11!

Type  "install"  to start the YaST installer on this CD/DVD
Type  "slp"      to start the YaST install via network
Type  "rescue"   to start the rescue system on this CD/DVD

Welcome to yaboot version r22.8-r1190.SuSE
booted from '/pci@800000020000003/pci@2,3/ide@1/disk@0:1,\suseboot\yaboot.ibm'
running with firmware 'IBM,SF240_403' on model 'IBM,9111-285', serial 'IBM,0206ABB30', partition '0'
Enter "help" to get some basic usage information
boot:
Please wait, loading kernel...
Allocated 01800000 bytes for executable @ 03000000
Elf32 kernel loaded...

SuSE Linux zImage starting: loaded at 03000000-0469cd30 (4000000/0/02039a68; sp: 02c9fd50)
uncompressing ELF header done. (00000100 bytes)
Allocated 0164c090 bytes for kernel @ 04800000
Leave 0122a5ba bytes for initrd @ 034668bb
uncompressing kernel done. (00f5a920 bytes)
entering kernel at 04810000(34668bb/122a5ba/02039a68)

The installation procedure reminds me of what happens on the x86, with just one difference — in our case, control is via a serial line in text VT102 mode, so some characters may not be displayed properly as you can see in Figure 5.

Figure 5: SUSE Linux installation could be fun

Several menu items, such as the network address, may require you to return to re-edit these fields. We can use Tab/Alt+Tab to move between text interface fields. These keyboard shortcuts are functional even in this very minimal mode.

Embedded Linux on ServiceProcessor

In addition to control via a serial line, IntelliStation (and in general, all IBM products) offers management via an ordinary Web browser. This Web control mechanism (Advanced System Management — see Figure 6) is provided by a tiny computer within the IntelliStation, with Linux and BusyBox utilities.

Figure 6: Management via Web interface

This ServiceProcessor also uses Power technology — a PowerPC 405 CPU from IBM [Datasheet PDF] but with a much smaller form factor. This uses a low-power processor FSP (Flexible Service Processor) running at about 200 MHz (see Figure 7).

Figure 7: Embedded Linux runs on PowerPC 405 from IBM

ASM provides the same controls as the serial-line SMS but in a more usable manner (Figure 8). It lets you manage the system remotely — start/stop it, view logs, allocate resources (like Capacity on Demand parameters), etc.

Figure 8: ASM's user-friendly controls presentation

Let’s briefly see how this subsystem is launched. When you connect the mains power to the box, the ServiceProcessor automatically starts the embedded Linux. After initially testing  some components of a larger block, ServiceProcessor displays on a front panel the readiness status for full system start. When you hit the “Power On” button, OpenFirmware loads and ultimately passes control to your Linux boot loader, yaboot.

Like with the large system, this small subsystem has two independent Ethernet controllers, referred to as HMC 1 and HMC 2. It makes sense to connect them to separate LANs/VLANs for a special management network. First, it helps access restriction and security. Second, you can avoid a network traffic overload on a single LAN.

IP addresses for these ports can be supplied by a DHCP server on a management network. If one isn’t found, default addresses are automatically assigned: 192.168.2.147 (port C7-T1, on HMC1) and 192.168.3.147 (port C7-T2, HMC2). You can log in via telnet, with the default credentials admin/admin.

$ mount
/dev/mtdblock/0/3 on / type cramfs (rw)
none on /dev type devfs (rw)
proc on /proc type proc (rw)
/dev/mtdblock/0/1 on /opt/extucode type jffs2 (rw)
/dev/mtdblock/0/1 on /etc type jffs2 (rw)
/dev/mtdblock/tmpram/tmpram on /tmp type jffs2 (rw)
none on /var type tmpfs (rw)
/dev/mtdblock/pcscore/pcscore on /core type jffs2 (rw)
/dev/mtdblock/pcsram/pcsram on /opt/p1 type jffs2 (rw)
shm on /var/shm type shm (rw)
/dev/mtdblock/1/1 on /alt/extucode type jffs2 (rw)
/dev/mtdblock/2/3 on /opt/fips type cramfs (rw)
/dev/mtdblock/nvram/nvram on /opt/p2 type zofs (rw,sync)
$ uptime
8:49am  up 1 day, 14:53, load average: 0.52, 0.20, 0.07
$ uname -a
Linux fsp 2.4.18-rc4 #1 Wed Mar 25 15:01:22 UTC 2009 ppc unknown
$ cat /proc/version
Linux version 2.4.18-rc4 (root@mcpbuild6) (gcc version 3.2.3 20030401 (prerelease)) #1 Wed Mar 25 15:01:22 UTC 2009

As we see, Embedded Linux uses JFFS/CRAMFS filesystems, which are common in tiny products. An interesting feature is NVRAM memory mounted as storage (/dev/mtdblock/nvram/nvram). Reading data from its files gives the status of different subsystems. You can also change some values using commands from /opt/fips/bin — particularly, you can even try to launch several subsystems (or maybe the full system box) with /opt/fips/bin/powr_fsp_spcn, which checks the current system status, and accordingly launches /bin/powr_L4 or /bin/powr_sqh. The ASM Web server (named webs), when you click the button Save settings and power on does the same.

Available distros for POWER

Originally, I planned to use Red Hat Enterprise Linux as the main OS on this system. However, neither RHEL 5.7 nor 6.2 Beta, nor even 6.2 started correctly. RHEL 6.2 Beta and a more recent version 6.2 spews a kernel trap error during initial startup. Yes, the IntelliStation 285 wasn’t in the supported hardware list, but neither was it for SLES 10/11. Still, SLES 10 and 11 support it unofficially. Let us see how the installation process goes, and whether we can bring the system to production mode.

In addition to RHEL and SLES, numerous systems based on the POWER processor even supported Ubuntu 10.04 (LTS edition). However, my experience proved that this model wasn’t suitable for Ubuntu — it cannot start properly. Moreover, newer versions of Ubuntu come without any POWER/PowerPC architecture support at all, unfortunately.

I checked if the most recent release (6.0.3) of Ubuntu’s parent distribution, Debian, could boot. It wasn’t able to start — it drops directly into OpenFirmware. Another failure! Well, let’s not despair. Quite possibly, the Debian community will fix it.

Oddly enough, a completely amateurish project called Crux PPC has a fully working distribution — Crux PPC 2.7a, which not only loads on Power hardware, but also provides video output via correctly-set framebuffer mode. None of the other distributions mentioned can boast of that! All provided only a serial-line text mode. In general, Crux PPC runs as a LiveCD and has no installer, so I advise professionals to use it. Again, this topic is out of the scope of this article, so I will leave it for later.

Performance

As I mentioned a bit earlier, IBM products are one level, or a “head above” their competitors. Comparing the very different Power and x86 architectures is hard, because there are no objective criteria for such a comparison. However, from an ordinary user’s perspective, we can try the 7Zip archiver in its benchmark mode. This program is completely open source, so anyone can compile it.

Let us compare IntelliStation based on the POWER5+ processor with 2 cores and 4 GB RAM, manufactured in 2005, with an Intel Core 2 Duo (2 cores with hyper-threading) and 4 GB RAM, but released three years later (2008). First, the IntelliStation:

linux:~/src/p7zip_9.20.1/bin # ./7za b

7-Zip (A) 9.20  Copyright (c) 1999-2010 Igor Pavlov  2010-11-18
p7zip Version 9.20 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,2 CPUs)

RAM size:    3632 MB,  # CPU hardware threads:   2
RAM usage:    425 MB,  # Benchmark threads:      2

Dict        Compressing          |        Decompressing
      Speed Usage    R/U Rating  |    Speed Usage    R/U Rating
       KB/s     %   MIPS   MIPS  |     KB/s     %   MIPS   MIPS

22:    1931    99   1891   1878  |    24309   100   2198   2194
23:    1871   100   1916   1907  |    24132   100   2212   2209
24:    1816    99   1964   1953  |    23917   100   2221   2219
25:    1780    99   2043   2032  |    23525   100   2213   2212
----------------------------------------------------------------
Avr:           99   1954   1942               100   2211   2209
Tot:          100   2082   2076

Next, let us test the Core 2 Duo system:

Intel(R) Core(TM)2 Duo CPU     E6550  @ 2.33GHz
7-Zip 9.04 beta  Copyright (c) 1999-2009 Igor Pavlov  2009-05-30
p7zip Version 9.04 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,2 CPUs)

RAM size:    4006 MB,  # CPU hardware threads:   2
RAM usage:    425 MB,  # Benchmark threads:      2

Dict        Compressing          |        Decompressing
      Speed Usage    R/U Rating  |    Speed Usage    R/U Rating
       KB/s     %   MIPS   MIPS  |     KB/s     %   MIPS   MIPS

22:    2588   138   1831   2518  |    33730   165   1850   3045
23:    2532   136   1903   2580  |    32265   159   1853   2954
24:    2588   142   1958   2783  |    32828   165   1843   3046
25:    2540   144   2011   2900  |    30299   155   1838   2849
----------------------------------------------------------------
Avr:          140   1925   2695               161   1846   2974
Tot:          150   1886   2834

As you can see, the performance doesn’t differ much. Even a slightly outdated IBM station can compete with a relatively new x86 product.

Despite the fact that equipment based on the Power processor is marketed by IBM as a corporate power-horse for commercial operating systems like AIX and IBM i (produced by IBM itself), we have seen that it can also be used with Linux. Thus, virtually the entire software stack that successfully works on x86 can also be run on Power — Apache, Java, WebSphere, MySQL, etc.

Taking into account the fact that IBM hardware usually comes with unique technologies like the hardware management console and the hardware virtualisation hypervisor, you can easily create an effective solution by combining the best features from both the hardware and software sides — the corporate and the public world.

‘Oneiric’ means ‘dreamy’ and in his blog, Mark Shuttleworth writes at length about choosing a suitable alliterative adjective to describe the ocelot, a small wild leopard. He even quotes from T.S. Eliot’s famous poem on “The Naming of Cats”. He finally settles on “Oneiric Ocelot” because it seems to capture how innovation happens — “part daydream, part discipline.”

This release is cosmetically pleasing, and gives developers even more options to create efficient interfaces that are aesthetically delightful also.

The Ubuntu installation — ‘Say Cheese’

The re-tweaked Ubuntu installer is going to amaze you with its new picture-taking abilities. If you’re installing Ubuntu 11.10 on a notebook or netbook equipped with a camera, it asks you to take a picture of yourself; this picture will recognise you in account settings, the login screen and the lock screen.

Ubuntu Install 'Say Cheese'

The rest of the installation is the same as in the previous release. While installing, keep your Internet connection on, or your installer will get stuck. Also don’t forget to tick “Install 3rd party codecs/restricted drivers”. The installer is very fast, and won’t let you wait for long.

A lightweight ‘LightDM’

As soon as the system reboots, you will be greeted with the slick, light-weight LightDM login screen. This new débutante is a very fast desktop manager, and offers you options for Unity 3D (default) and Unity 2D sessions. If your card doesn’t support Unity 3D, you can choose Unity 2D from LightDM. The Gnome Shell is completely dropped from Ubuntu, but you can install it from the Ubuntu Software Centre, or by using apt-get install. (See the box with suggestions at the end of the article on 11 things to install on a fresh Oneiric install.)

LightDM login screen

The ‘Lenses’ included in Unity Dash

After receiving lots of complaints, Ubuntu developers refined and re-polished the Unity interface, and added lenses for App Launcher, File Search and Music Search. App lenses let you find stuff faster. File lenses do all the remembering, so you don’t have to. It gives you myriad filtering options. For example, Music lenses keep track of your music collections, what you have and what you don’t.

The Unity sidebar now shades itself according to the desktop wallpaper. The interface is translucent, with bigger icons. Compiz also hides a lot of oomph under the hood.

Unity Dash

Music Lenses

Unity Sidebar

Multi-task in style

A new addition to this release is a modified Alt-Tab switcher with preview features, in which you can use the down arrow key to see a preview. This really cool feature adds a plus to Ubuntu’s “coolness rating”. The workspace switcher also got touched up; it displays an orange border around the active workspace. You can also move applications across different workspaces.

Alt-Tab Switcher preview

Workspace Switcher

A completely revamped USC

The Ubuntu Software Centre got a complete makeover — and with this release, Ubuntu dropped Synaptic completely. There are thousands of apps to choose from. The USC also adds new “top-rated” views to the main category and all sub-category pages, along with significant speed improvements for standalone .deb installer files. It allows you to edit and delete your own software reviews.

Another new addition worth mentioning is “One Conf”; enable it from the File menu –> Sync between Computers, and it keeps your installed apps in sync between computers! This feature comes handy when you have more than one Ubuntu device. It also gives options for adding applications to the launcher right after install finishes. With this release, USC is upgraded to 5.0.

Ubuntu Software Centre home screen

A few welcome new defaults

With every incremental Ubuntu release, new software defaults come as a surprise. Thunderbird 7 is the new emailing client, because it has got better plugin support, and includes better menu and launcher integration. The Déjà Dup application is included as a default backup tool. It makes it easy to upload backups to Ubuntu One, the cloud storage initiative by Ubuntu.

Déjà Dup backup application

Déjà Dup options

Ubuntu One ‘graduated’

Ubuntu One debuted with Ubuntu 9.04 Jaunty Jackalope, and as promised, Ubuntu developers delivered it completely integrated with Android, iOS and Windows devices. Ubuntu One provides you with documents, pictures and music syncing across computers and mobile devices, apart from the Ubuntu One music store to stream the tracks you have to your mobile devices (and buy the music you don’t have). The Ubuntu One Bookmark syncing feature has been discontinued with this release, due to performance-related issues.

Ubuntu One comes with 5 GB of free space, and fulfils all your requirements. You can also opt for a 20 GB pack, by spending approximately US$ 30 per year.

Go social with Gwibber

Gwibber, the much-talked-about social-networking client, is completely rewritten from scratch, to give you a hassle-free social experience online. It’s got improved performance, and a new interface using the most recent GNOME technologies.

The nitty-gritty

There are some details worth mentioning, such as a better universal bar, windows controls hidden by default on maximised apps (they reappear when you hover your mouse on the top left-hand side).

The power button is reincarnated and is much more useful now; you can access the Update Manager and GNOME Control Centre, and can switch between accounts without much hassle. Indicators got a refresh, as they are ported to the GTK3-based indicator stack. Launchers and panels also show improved performance, as they too are ported to GTK3.

Power button menu

A windows-snapping feature is also included in the new avatar of Compiz, which mimics Windows ‘Aero snap’. There is multi-architecture support, which enables you to install 32-bit apps to 64-bit installs. This version also has better short-cut key integrations. The boot time from a live USB was a mere 29 seconds on a Core2Duo laptop, and one minute 6 seconds on my netbook. Battery backup performance still requires a lot of work, though.

Window snapping

Application window preview

“Ubuntu” is an ancient African word that means “Humanity to others.” It also means, “I am what I am because of who we all are,” and Ubuntu OS actively works towards delivering the spirit of Ubuntu to the world of computers with its every release. Enjoy the new release of Ubuntu!

After this release, Mark Shuttleworth also announced the Ubuntu 12.04 LTS release, codenamed “Precise Pangolin”.

Plone is a content management framework built on top of Zope. It is the most popular application using Zope. Plone continued to use Zope 2, and did not migrate to the Zope 3 application server as the migration cost was considered too high. The Zope community also realised that it was better to enhance Zope 2 with the new component architecture features, which were the core of the Zope 3 architecture.

This has enabled projects to enhance their applications without having to redesign or rewrite the whole system. As a result, Plone 4 finally uses the current release of Zope, and also uses Python 2.6 instead of Python 2.4. The Plone community has also made it relatively easy to migrate from Plone 3 to Plone 4, despite the major changes in it.

However, the focus of this article is how to get going if you were starting afresh with Plone 4.

Installation

A major concern with a complex application built on top of many components is to ensure that all the pieces fit, and work well. An upgrade in one component may break the system. Hence, it is best to work with a known set of versions.

The installation technique used by Plone is the Zope Buildout, which uses a list of specified Python egg versions to build and install a local Plone environment. It builds a Python 2.6 environment by default, so as not to depend on the distribution to provide a supported version.

You will need to download the current release of Plone’s unified installer, which is version 4.1 at the time of writing. You will find the installation instructions in README.txt, but the simplest option is to run the following command:

sudo ./install.sh standalone

You will find the installation in /usr/local/Plone, with the sub-directories buildout-cache, Plone-docs, Python-2.6 and zinstance. The role of the first three directories is pretty clear. This leaves zinstance, which must then contain the Zope instance of the Plone application.

The installer also creates a plone user account, which will be used to run the Plone server.

First steps

You will be working in /usr/local/Plone/zinstance to run Plone-related commands and to alter Plone configuration files. Start the Plone server with the following command:

sudo u=plone bin/plonectl start

You can now browse the site at http://localhost:8080/. The startup page offers you a button to create a Plone site (Figure 1).

Figure 1: Plone after a fresh installation

Once you have done that, you will want to create one or more users of the site. You need to select the Site Setup option from the upper right corner, which will give you the option of Users and Groups.

You may create a user named Writer, who will be adding content to the site. This user need not be a member of any of the suggested groups. However, you will want to add the role of a Contributor in addition to the role of Member.

Plone organises content in Folders, much like the desktop paradigm. Hence, as an administrator, create the folder, Articles. You can do this on the home page using the Add New... option. The newly created folder will be shown, and its state would be Private, which you should change to Published.

Now sign in as the user Writer. You will notice that the options available to this user are fewer. You can add a page in the Articles folder tab. You may enter the content using a visual editor. If you like writing HTML code by hand, you have the option to do so as well!

Create your first article. Its state will be private, and you will notice that you may submit the article for publication — but cannot publish it. Submit it, and the state changes from Private to Pending Review
(Figure 2).

Figure 2: A page after submitting for publication

Publishing can be done by a user with the role of Reviewer. The administrator has all the privileges, so at present you may use the administrator account to publish the article.

Clicking on Articles will display items within the folder. This is normally not very attractive. Hence, you may choose the Display option to “Select a content item as default view”. Try it and see the difference.

Model-based content

A great capability of Plone has been to easily manage content objects based on schema definitions, and not just HTML pages. Archetypes has been the framework for this task. Further, ArchGenXML converts your schema in UML to working Python code for Plone. See ArchGenXML Getting Started guide to get an idea of the possibilities.

However, the future seems to belong to another package — Dexterity. It is an example of an enhancement in Plone, which has leveraged Zope 3 technologies. For me, the most interesting part was that it uses the grok framework behind the scenes. So, you get a CMS that is extensible by a model-driven system. The possibilities are immense. Grok, incidentally, is functionally analogous to Rails or Django.

Currently, Plone does not include Dexterity in the core, so you will need to install it. Modifications to the buildout configurations can be confusing in the beginning. In the zinstance directory, you will find a number of cfg files.

The key file is buildout.cfg. You need to tell buildout about a suitable set of versions needed for Dexterity. You can find the latest set at here. You should change the extends section of buildout.cfg to look like what is shown below:

extends =
    base.cfg
    versions.cfg

http://good-py.appspot.com/release/dexterity/2.0-next

You will also need to include the egg for Dexterity in your Plone instance. The eggs section in your buildout.cfg will look like what follows:

eggs =
    Plone
    Pillow
    lxml
    plone.app.dexterity

You should stop Plone and run buildout. If all is well, then start Plone:

sudo u=plone bin/plonectl stop
sudo bin/buildout
sudo u=plone bin/plonectl start

Sign in as the administrator. From the Site Setup page, choose Addons. You should see the option, “Dexterity Content Types — Plone Integration 1.0rc1″.

Activate it. The Site Setup should now include the option “Dexterity Content Types”. Selecting it will allow you to create a new content type. Create a new type called Resume. Now edit it to add fields, e.g., Title — a text line, i.e., a string; Birthdate — date/time; Mugshot—image; Experience –Rich text field; etc.

You can select the settings option of each field to change some of the attributes, like Required. In particular, you have to use the field name Title, as it is needed by Dexterity. In the mandatory field, Title, that you have created, you want the content to be the person’s name. Hence, it is better to change the label to an appropriate description. So, replace the default label Title by Name.

Select the behaviour option and disable “Dublin core
metadata” to ensure that it does not show the additional fields Title and Summary.

You should now create another folder, Authors, from the home page. You may notice that there is now an additional content type, Resume. For the Authors, in Add new, choose Restrictions and allow only content of the type Resumeto be added. Now, if you add a Resume, you will get a form. Once the form is filled and published, all users will see a pretty decent HTML page for it (Figure 3).

Figure 3: A page with a Dexterity type content

Capabilities like customising CSS and themes for a great-looking site are obviously possible. In case you need proof, have a look at the University of Washington site.

Plone 4 with Dexterity enhancements based on grok makes it an even more exciting framework. It should definitely be an option considered by anyone looking at a new content management framework.

VirtualBox

Sun Microsystems, and now Oracle, oversee the development of the emulation project called VirtualBox. However, this package couldn’t be found in the OpenIndiana (OI) repositories. To install it in OI, grab the gzipped package here and manually install it. The archive is called “VirtualBox 4.1 for Solaris hosts x86/amd64″. Please unpack it, and then run pkgadd:

root@openindiana:/home/anton/Install# pkgadd -d VirtualBox-4.1.0-SunOS-r73009.pkg

The following packages are available:
1  SUNWvbox     Oracle VM VirtualBox
                  (i386) 4.1.0,REV=2011.07.19.12.47.73009

Select package(s) you wish to process (or 'all' to process
all packages). (default: all) [?,??,q]: a

Processing package instance <SUNWvbox> from </home/anton/Install/VirtualBox-4.1.0-SunOS-r73009.pkg>

[...snip...]

The following files are being installed with setuid and/or setgid
permissions:
/opt/VirtualBox/amd64/VBoxBFE <setuid root>
/opt/VirtualBox/amd64/VBoxHeadless <setuid root>
/opt/VirtualBox/amd64/VBoxNetAdpCtl <setuid root>
/opt/VirtualBox/amd64/VBoxNetDHCP <setuid root>
/opt/VirtualBox/amd64/VBoxSDL <setuid root>
/opt/VirtualBox/amd64/VirtualBox <setuid root>
Do you want to install these as setuid/setgid files [y,n,?,q] y

This package contains scripts which will be executed with super-user
permission during the process of installing this package.

Do you want to continue with the installation of <SUNWvbox> [y,n,?] y

Installing Oracle VM VirtualBox as <SUNWvbox>

[...snip...]

Installation of <SUNWvbox> was successful.

Running VirtualBox in OpenIndiana

File operations, and the general VirtualBox used in OI, are no different than on Linux. You can even exchange VMs created in OI with Linux, and vice-versa.

QEMU

However, some developers need to deal with platforms other than x86 — for example, ARM and PowerPC. So, what’s the alternative to VirtualBox? The solution is straightforward — QEMU. It can emulate x86 systems and a dozen other architectures; e.g., Linux for ARM with qemu-system-arm, or MacOS X with qemu-system-ppc64.

The build process for QEMU 0.15 requires the gettext@0.5.11 package, as well as developer packages that contain definitions of mathematical functions. I performed the following operations:

root@openindiana:/home/anton# pkg info | egrep "math|gettext"
Name: developer/gnome/gettext
FMRI: pkg://openindiana.org/developer/gnome/gettext@0.5.11,5.11-0.151:20110523T143743Z
Name: system/library/math
FMRI: pkg://openindiana.org/system/library/math@0.5.11,5.11-0.151:20110523T150249Z
Name: system/library/math/header-math
FMRI: pkg://openindiana.org/system/library/math/header-math@0.5.11,5.11-0.151:20110523T150250Z

I was able to build QEMU 0.15 without problems. However, I have to disable GuestAgents support, mainly because QEMU 0.15 calls functions with O_ASYNC parameters, which isn’t supported on Solaris.

QEMU 0.15 compiled on OI; VM with Ubuntu Server

Windows 2003 EE in QEMU 0.15

You could compile the previous version, 0.14, or do a quick hack on line 493 in qemu-ga.c, from:

fd = qemu_open(s->path, O_RDWR | O_NONBLOCK | O_ASYNC);

…to:

fd = qemu_open(s->path, O_RDWR | O_NONBLOCK);

Or, as mentioned earlier, compile it without GuestAgents support:

./configure --prefix=/opt/qemu-0.15 –disable-guest-agent
make && make install ## run as root

After that, you should prepare a file image for the virtual OS to install to, and run it as follows:

/opt/qemu-0.15/bin/qemu-img create ubuntu2.img 2000M
/opt/qemu-0.15/bin/qemu -hda ubuntu2.img -cdrom /home/anton/ISO/ubuntu-10.10-server-i386.iso -M pc -m 768 -vga cirrus -no-acpi

Similarly, you can use other OSs, for example, Windows 2003 EE:

/opt/qemu-0.15/bin/qemu -hda windows2003.img -cdrom /home/anton/ISO/win2003_sp2.iso -M pc -m 1024 -vga cirrus

Disk management

Let’s imagine that you have a new drive to be used for data storage. It could be a special, dedicated database storage pool. This drive should be initialised first, partitioned with a file format that is used by OI. You can use the format command (it can be used in interactive mode):

root@openindiana:/home/anton# format
Searching for disks...
Failed to inquiry this logical diskdone

AVAILABLE DISK SELECTIONS:
       0. c1d0 < cyl 2868 alt 2 hd 255 sec 63>
          /pci@0,0/pci-ide@1,1/ide@0/cmdk@0,0
       1. c2d1 <QEMU HAR-QM0000-0001-2.00GB>
          /pci@0,0/pci-ide@1,1/ide@1/cmdk@1,0

We can format the whole drive with the format option in the menu (not shown), or assign a label using volname.

The last step is to add the drive to the ZFS pool—and the new storage space is ready to use:

root@openindiana:/home/anton# zpool create pool c2d1

You can list the available pools and see that both
pools (i.e., disks) are online:

oot@openindiana:/home/anton# zpool list
NAME    SIZE  ALLOC   FREE    CAP  DEDUP  HEALTH  ALTROOT
pool   1.98G   124K  1.98G     0%  1.00x  ONLINE  -
rpool  21.9G  9.17G  12.7G    41%  1.00x  ONLINE  -

Zones management

In addition to VirtualBox and QEMU virtualisation, OI (and OpenSolaris) offers fairly well-developed virtualisation within the OS, called Solaris Zones. Unfortunately, OI does not yet support zones that can run Linux (though it was available in the previous OpenSolaris version). OI supports mere native zones — when the system runs zones (or containers) with OI inside them. Let’s explore how to create them. Begin by using the following code:

root@openindiana:/home/anton# zonecfg -z NewZone
NewZone: No such zone configured
Use 'create' to begin configuring a new zone.
zonecfg:NewZone> create
zonecfg:NewZone> add net
zonecfg:NewZone:net> set physical = rtls0
zonecfg:NewZone:net> set address = 192.168.254.200
zonecfg:NewZone:net> end
zonecfg:NewZone> set zonepath=/pool/NewZone
zonecfg:NewZone> commit
zonecfg:NewZone> exit

You have created a new zone. It is stored under /pool/NewZone on the disk you just attached and initialised. For a zone to be complete, you must install the bare OI system into this area:

root@openindiana:/home/anton# zoneadm -z NewZone install
A ZFS file system has been created for this zone.
   Publisher: Using openindiana.org (http://pkg.openindiana.org/dev-il/ ).
       Image: Preparing at /pool/NewZone/root.
Refreshing catalog 1/1 openindiana.org
Caching catalogs ...
       Cache: Using /var/pkg/download.
Sanity Check: Looking for 'entire' incorporation.
  Installing: Core System (output follows)

               Packages to install:     1
           Create boot environment:    No

[...snip...]

Postinstall: Copying SMF seed repository ... done.
Postinstall: Applying workarounds.
        Done: Installation completed in 771.344 seconds.

Next Steps: Boot the zone, then log into the zone console (zlogin -C)
              to complete the configuration process.

The system is installed into an isolated container. Let’s run it!

root@openindiana:/home/anton# zoneadm -z NewZone boot

zone 'NewZone': WARNING: rtls0:1: no matching subnet found in netmasks(4): 192.168.254.200; using default of 255.255.255.0.

Now, perform a minimal configuration of this zone.
Connect to a virtual console with zlogin -C NewZone:

root@openindiana:/home/anton# zlogin -C NewZone
[Connected to zone 'NewZone' console]
61/99
85/99
99/99
Hostname: NewZone

Loading smf(5) service descriptions: 3/3

What type of terminal are you using?
 1) ANSI Standard CRT
 2) DEC VT100
 3) PC Console
 4) Sun Command Tool
 5) Sun Workstation
 6) X Terminal Emulator (xterms)
 7) Other
Type the number of your choice and press Return: 6
Creating new rsa public/private host key pair
Creating new dsa public/private host key pair
Configuring network interface addresses: rtls0.

System identification is completed.

rebooting system due to change(s) in /etc/default/init

[NOTICE: Zone rebooting]

SunOS Release 5.11 Version oi_151 64-bit
Copyright (c) 1983, 2010, Oracle and/or its affiliates. All rights reserved.
Hostname: NewZone

NewZone console login: root
Password:
Aug  8 14:09:54 NewZone login: ROOT LOGIN /dev/console
OpenIndiana (powered by illumos)    SunOS 5.11    oi_151    July 2011

The one-time configuration of the new zone is done. Review the new zone’s available resources. They’re completely isolated, like the whole environment, in general:

root@NewZone:~# df
/                  (pool/NewZone/ROOT/zbe): 3007372 blocks  3007372 files
/dev               (/dev              ):       0 blocks        0 files
/proc              (proc              ):       0 blocks    29917 files
/system/contract   (ctfs              ):       0 blocks 2147483588 files
/etc/mnttab        (mnttab            ):       0 blocks        0 files
/system/object     (objfs             ):       0 blocks 2147483418 files
/etc/svc/volatile  (swap              ): 5920888 blocks   578264 files
/lib/libc.so.1     (/usr/lib/libc/libc_hwcap1.so.1): 3007372 blocks  3007372 files
/dev/fd            (fd                ):       0 blocks        0 files
/tmp               (swap              ): 5920888 blocks   578264 files
/var/run           (swap              ): 5920888 blocks   578264 files

Restarting NewZone does not interrupt the core system;
rebooting takes less than a minute:

root@NewZone:/# reboot
Aug  8 14:15:37 NewZone reboot: initiated by root on /dev/console

[NOTICE: Zone rebooting]

SunOS Release 5.11 Version oi_151 64-bit
Copyright (c) 1983, 2010, Oracle and/or its affiliates. All rights reserved.
Hostname: NewZone

NewZone console login: root
Password:
Aug  8 14:16:18 NewZone login: ROOT LOGIN /dev/console
Last login: Mon Aug  8 14:09:54 on console
OpenIndiana (powered by illumos)    SunOS 5.11    oi_151    July 2011
root@NewZone:~# date
Mon Aug  8 14:16:22 CEST 2011

I propose to build a QEMU package, so it can be installed later inside NewZone. Why is this so important? It could sometimes be essential to have a standalone package, if it’s new and not in the OI repository yet. Or, in the opposite case — for your own corporate program which you don’t wish to redistribute. As an example, let’s analyse how to create a package from the set of programs in /opt/qemu-0.14.

The first step is to prepare two files, prototype and pkginfo.

# echo 'i pkginfo' > prototype
# pkgproto /opt/qemu-0.14/  >> prototype

In prototype, you should specify those files and directories that the future package will contain. The pkginfo file will contain all information about this package:

root@openindiana:~/pkg# cat pkginfo
BASEDIR=/opt/qemu-0.14
TZ=PST
PATH=/sbin:/usr/sbin:/usr/bin:/usr/sadm/install/bin
PKG=qemu
ARCH=x86
NAME=qemu
VERSION=0.14
CATEGORY=application
DESC=QEMU virtualization
VENDOR=QEMU.ORG
EMAIL=qemu@qemu.org
PKGSAV=/var/sadm/pkg/qemu/save

Begin building the package itself:

root@openindiana:~/pkg# pkgmk -b /opt/qemu-0.14 -r /
## Building pkgmap from package prototype file.
## Processing pkginfo file.
WARNING: missing directory entry for </opt>
WARNING: parameter <PSTAMP> set to "openindiana20110814071557"
WARNING: parameter <CLASSES> set to "none"
## Attempting to volumize 84 entries in pkgmap.
part  1 -- 123944 blocks, 428 entries
## Packaging one part.
/var/spool/pkg/qemu/pkgmap
/var/spool/pkg/qemu/pkginfo
/var/spool/pkg/qemu/root/opt/qemu-0.14/bin/qemu
[...snip...]
/var/spool/pkg/qemu/root/opt/qemu-0.14/share/qemu/vgabios-stdvga.bin
/var/spool/pkg/qemu/root/opt/qemu-0.14/share/qemu/vgabios-vmware.bin
/var/spool/pkg/qemu/root/opt/qemu-0.14/share/qemu/vgabios.bin
## Validating control scripts.
## Packaging complete.

The package is ready, and is stored in /var/spool/pkg. The last step is to convert it to a special pkg format:

root@openindiana:~/pkg# pkgtrans -s /var/spool/pkg/ qemu.pkg

The following packages are available:
  1  qemu     qemu
              (x86) 0.14

Select package(s) you wish to process (or 'all' to process
all packages). (default: all) [?,??,q]: 1
Transferring <qemu> package instance
root@openindiana:~/pkg# ls -l /var/spool/pkg/
total 58668
drwxr-xr-x 3 root root        5 2011-08-14 08:15 qemu
-rw-r--r-- 1 root root 59996160 2011-08-14 08:19 qemu.pkg

Now, transfer qemu.pkg to the isolated area, and install it in NewZone:

root@NewZone:/export# pkgadd -d qemu.pkg

The following packages are available:
  1  qemu     qemu
              (x86) 0.14

Select package(s) you wish to process (or 'all' to process
all packages). (default: all) [?,??,q]: 1

Processing package instance <qemu> from </export/qemu.pkg>

qemu(x86) 0.14
QEMU.ORG
## Processing package information.
## Processing system information.
## Verifying disk space requirements.
## Checking for conflicts with packages already installed.
## Checking for setuid/setgid programs.

Installing qemu as <qemu>

## Installing part 1 of 1.
/opt/qemu-0.14/bin/qemu
...
/opt/qemu-0.14/share/qemu/vgabios.bin
[ verifying class <none> ]

QEMU installation in the zone was successful. You’ll also notice that the core system now has a new virtual device rtls0:1, which will filter all traffic in and out of the isolated container:

root@openindiana:~# ifconfig rtls0
rtls0: flags=1000843<UP,BROADCAST,RUNNING,MULTICAST,IPv4> mtu 1500 index 3
        inet 10.1.0.136 netmask ffffff00 broadcast 10.1.0.255
        ether e2:62:0:a4:d5:24
root@openindiana:~# ifconfig rtls0:1
rtls0:1: flags=1000843<UP,BROADCAST,RUNNING,MULTICAST,IPv4> mtu 1500 index 3
        zone NewZone
        inet 192.168.254.200 netmask ffffff00 broadcast 192.168.254.255

OI combines tools from the Linux world (ls, bash, gcc) and those native to Solaris (svcadm, pfexec, newtask, beadm). The CDDL licence (similar to GPL) made possible the emergence of the Nexenta distribution, which uses the OS/Net (OpenSolaris) core, much like OI. However, Nexenta has only GNU applications, and isn’t built on mixed technology like OI.

However, as we have already seen, this mixed environment is closer to Linux than to Solaris. The use of interesting options like ZFS and zones lets you look differently at existing solutions in Linux — for instance, LVM and lxc. Who knows, maybe one day, we’ll see a Linux distribution offering ZFS as the default root filesystem!

Once upon a time, there was Sun Microsystems. Not just an IT industry flagship, but also a legendary firm. Famous for SPARC processors, the Java programming language, and for the decades it spent developing its own UNIX OS, Solaris. Solaris’ successor is the OpenIndiana project.

Solaris and Sun

The history of Sun Microsystems is truly amazing. Started in 1982 to further develop the project born in Stanford University, the acronym (SUN) itself stands for Stanford University Network. Over time, the company was involved in many interesting projects. Slogans such as, “A computer is a network” and “Write Once, Run Everywhere” reflect fundamental milestones in the development of modern technologies that we are today so familiar with.

Commercially, Sun marketed SunOS, and later Solaris. Note that another of its achievements, the Berkeley Software Distribution (BSD), has been used not only in Solaris, but in a number of other commercial implementations like AIX/HP-UX, and open systems like FreeBSD/NetBSD/OpenBSD. To some extent, all BSD-derived systems (read, modern *NIX) and Linux share several fundamental concepts and features.

BSD is the root of many modern operating systems

In the first half of the last decade, Sun was too slow in turning Solaris from a closed to an open source product, i.e., OpenSolaris. This lost the company the server segment in enterprise-level deployments. Some studies indicate that if Sun hadn’t been so conservative in the 2000s, it is possible that a large part of the server segment would now be OpenSolaris hosts, rather than Linux.

OpenSolaris took another blow when Sun, in a bad financial condition, was bought by Oracle in 2010. The latter can hardly be called an open source friendly company, so it wasn’t surprising when the OpenSolaris community decided to develop their own fork, independent of Oracle’s corporate games. This resulted in the 2010 announcement of OpenIndiana.

As mentioned, OpenIndiana is the Illumos core from OpenSolaris, which is being independently developed by Oracle, plus GNU user-land tools. It is worth mentioning that in 2007, Sun specially hired Ian Murdock (the Debian founder) for the development of “Project Indiana”, to transform Solaris into OpenSolaris, and combine the latter with a number of open source products, such as GNOME. In general, we can assume that Project Indiana has successfully grown into OpenIndiana.

Installation

Right, so let’s try OpenIndiana. I downloaded the Server ISO with the development release 151 and loaded it on a regular x86_64 machine with 2 GB of RAM (later increased to 4 GB). The server needs you to use the command-line via the console or SSH. However, there’s a desktop version as well — the “Live DVD desktop ISO” for those who love GUIs: a choice of GNOME 2.30/XFCE 4.8/LXDE 0.5/KDE 4.7. I burned the ISO on a DVD and booted it, chose the Installer menu option “Install OpenIndiana” and began.

OpenIndiana has a pretty simple installer

Though the OS needs only about 3 GB, I allocated the entire HDD (22 GB). The rest of the allocated space will be used by /home and swap partitions. Please remember, the swap space consists of three different items!

Disk selection for installation

I set the hostname to “openindiana”, set a password for root, and created a single user for myself (“anton”). Network configuration was left as automatic; you can later change settings after logging in. Next, I hit F2 (Install) and waited for the installation to complete. After reviewing the installation log, I chose option “5 Reboot”, to try my very first steps with OpenIndiana!

Installation Log

OpenIndiana reminds you of the old UNIX console

Post logging in, you can configure a static IP address. First disable nwam (NetWork Auto Magic):

# svcadm disable network/physical:nwam

Add a name server (DNS) IP to /etc/resolv.conf, and add your current gateway to /etc/defaultrouter. Also, manually add the gateway to the routing table (necessary only for the current session) with route -p add default GATEWAY. Assign the static IP address with ifconfig, and start the network service:

# svcadm enable network/physical:default

Now, when you restart you workstation/server, this static network configuration will be applied.

Package management

The first thing that comes to mind is: how does one install extra packages.

Personally, I like Midnight Commander — a simple console file manager. To install it, I relied on the pkg package manager. As root (sudo bash), check if you have registered repositories:

# pkg publisher
PUBLISHER                             TYPE     STATUS   URI
openindiana.org          (preferred)  origin   online   http://pkg.openindiana.org/dev-il/

Yes, we can install new packages. But before that, let’s do a system update:

root@openindiana:/home/anton# pkg image-update
Creating Plan
Packages to update:   332
Create boot environment:   Yes
DOWNLOAD                                  PKGS       FILES    XFER (MB)
system/extended-system-utilities        19/332     57/2077    0.4/103.9
library/libtecla                        39/332    121/2077    0.6/103.9
system/network/ppp/pppdump              65/332    231/2077    2.3/103.9
system/library                          75/332    302/2077    4.0/103.9
system/kernel                          326/332   2063/2077  102.2/103.9
Completed                              332/332   2077/2077  103.9/103.9

PHASE                                        ACTIONS
Removal Phase                                120/120
Install Phase                                114/114
Update Phase                               5868/5868

PHASE                                          ITEMS
Package State Update Phase                   664/664
Package Cache Update Phase                   332/332
Image State Update Phase                         2/2

A clone of openindiana exists and has been updated and activated.
On the next boot the Boot Environment openindiana-1 will be mounted on '/'.
Reboot when ready to switch to this updated BE.

If you want, you can install the mc package (Midnight Commander), after checking if it’s in the repository:

# pkg search mc
INDEX      ACTION VALUE                   PACKAGE
basename   dir    usr/share/doc/mc        pkg:/file/mc@4.7.3-0.151
basename   dir    usr/share/mc            pkg:/file/mc@4.7.3-0.151
basename   file   usr/bin/mc              pkg:/file/mc@4.7.3-0.151
pkg.fmri   set    openindiana.org/file/mc pkg:/file/mc@4.7.3-0.151

root@openindiana:/home/anton# pkg install mc
Creating Plan |
Packages to install:     2
Create boot environment:    No
DOWNLOAD                                  PKGS       FILES    XFER (MB)
runtime/python-24                          0/2    294/2271     1.1/10.6
file/mc                                    1/2   2119/2271     9.3/10.6
Completed                                  2/2   2271/2271    10.6/10.6

PHASE                                        ACTIONS
Install Phase                              2457/2457

PHASE                                          ITEMS
Package State Update Phase                       2/2
Image State Update Phase                         2/2

The Midnight Commander (mc) file manager

For a package list, run pkg list; for more verbose output, run pkg info. Searching for, and attempting to install Apache yields the message “No updates necessary for this image”, which means it was already installed in the initial deployment. To check if a package is installed, use the following command:

root@openindiana:/home/anton# pkg list | grep apache
web/server/apache-22                          2.2.16-0.151    installed  -----

Let’s try to install the nginx Web server, which isn’t in the OpenIndiana repository, by downloading the source and compiling it. Create a src folder, set your HTTP proxy if required, and use wget to download the tarball. However, no GCC compiler is installed. What’s the compiler package name?

root@openindiana:/home/anton#  pkg search gcc | grep set
description  set  GCC Runtime libraries   pkg:/system/library/gcc-3-runtime@3.4.3-0.151
pkg.description set  GCC Runtime - Shared libraries used by gcc and other gnu components pkg:/system/library/gcc-3-runtime@3.4.3-0.151
pkg.summary  set  GCC Runtime libraries   pkg:/system/library/gcc-3-runtime@3.4.3-0.151
description  set   gcc - The GNU C compiler  pkg:/developer/gcc-3@3.4.3-0.151
pkg.description set   GCC Runtime - Shared libraries used by gcc and other gnu components pkg:/system/library/gcc-3-runtime@3.4.3-0.151
pkg.summary  set  gcc - The GNU C compiler   pkg:/developer/gcc-3@3.4.3-0.151

The package we need is called “pkg:/developer/gcc-3 @ 3.4.3-0.151″, so we can install it with the following command:

root@openindiana:/home/anton# pkg install pkg:/developer/gcc-3@3.4.3-0.151

Next, compile nginx with the thoroughly familiar ./configure –prefix=/opt/nginx-1.1.0 and make recipe. We can omit the output as unnecessary.

As a hosting platform, OpenIndiana could be surprisingly good. Besides Web servers, you can also find PHP, Python, Ruby, Java and several other packages in the repository, which can be configured or installed with minimum effort. However, some packages need extra care, like PostgreSQL. Let’s see what happens when we install it:

root@openindiana:/home/anton# pkg install pkg:/service/database/postgres-84@8.4.4-0.151
               Packages to install:     2
           Create boot environment:     No
               Services to restart:     1
DOWNLOAD                                PKGS       FILES       XFER (MB)
Completed                               2/2        211/211     9.6/9.6

PHASE                                   ACTIONS
Install Phase                           1/352 The Boot Environment openindiana-2 failed to be updated.
A snapshot was taken before the failed attempt and is mounted here /tmp/tmpfWSs0u. Use 'beadm
unmount openindiana-3' and then 'beadm activate openindiana-3' if you wish to boot to this BE.

pkg: The requested operation cannot be completed due to invalid package metadata.  Details follow:

The action 'dir group=postgres mode=0755 owner=postgres path=var/postgres' in package
'pkg://openindiana.org/service/database/postgres-84@8.4.4,5.11-0.151:20110523T151027Z' has invalid
attribute(s):
  '//var/postgres' cannot be installed; 'postgres' is an unknown or invalid user.

To install PostgreSQL, you need to have created both a user and group named “postgres”. Otherwise, the package simply won’t be able to assign the right permissions to the newly created /var/postgres.

Note the interesting point: the package manager always lets you not just remove the package, but even roll it back, in case it was installed improperly. Because of the underlying ZFS, the package is originally installed into a temporary location, and only after successful installation is the temporary location integrated with the main filesystem, known also as BE (Boot Environment). In the example above, the package has been installed into the temporary location “openindiana-3″.

root@openindiana:/home/anton# beadm list
BE            Active Mountpoint Space Policy Created
openindiana   -      -          5.92M static 2011-07-01 16:11
openindiana-1 -      -          448M  static 2011-08-05 12:10
openindiana-2 NR     /          2.39G static 2011-08-05 12:20
openindiana-3 -      -          56.0K static 2011-08-05 12:45

You can force the integration process, so an unsuccessful package installation would be joined with the main filesystem with something like: beadm activate openindiana-3. However, it’s highly recommended to have proper installation without errors. Create the “postgres” user and group, and then reinstall PostgreSQL.

Service control

It’s time to learn how to control services. The svcs command shows a list of all services. The svcadm command lets you start/stop the desired service. The svccfg and svcprop commands are intended for fine-tuning.

Here’s how to first check service status (disabled == not running), and then start a service:

root@openindiana:/home/anton# svcs apache22
STATE          STIME    FMRI
disabled       Aug_08   svc:/network/http:apache22

root@openindiana:/home/anton# svcadm enable apache22
root@openindiana:/home/anton# svcs apache22
STATE          STIME    FMRI
online         10:02:37 svc:/network/http:apache22

Filesystem organisation

Yes, I’m talking about the structure of ZFS.

root@openindiana:/home/anton# df -h
Filesystem            Size  Used Avail Use% Mounted on
rpool/ROOT/openindiana-2
15G  3.0G   12G  21% /
swap                  2.4G  368K  2.4G   1% /etc/svc/volatile
/usr/lib/libc/libc_hwcap1.so.1
15G  3.0G   12G  21% /lib/libc.so.1
swap                  2.4G   48K  2.4G   1% /tmp
swap                  2.4G   72K  2.4G   1% /var/run
rpool/export           12G   32K   12G   1% /export
rpool/export/home      12G   32K   12G   1% /export/home
rpool/export/home/anton
16G  4.4G   12G  29% /export/home/anton
rpool                  12G   46K   12G   1% /rpool
/dev/dsk/c2t0d0s2     549M  549M     0 100% /media/OpenIndiana_Text_X86
/export/home/anton     16G  4.4G   12G  29% /home/anton

You may recall that we allocated 22 GB of space to OI. However, the root system occupies just 15 GB (the first line). Where is the rest? Note that there are three swap partitions used, mounted at /var/tmp, /tmp, and purely for system usage as /etc/svc/volatile. These swaps “ate” ~7 GB! The rest of the space is dynamically reallocated for the home directory, mounted and seen as /export.

Please keep in mind that ZFS is extremely powerful, in terms of the used features. Briefly, what are these? First, you can see the ZFS sections that are on duty:

root@openindiana:/home/anton# zfs list
NAME                       USED  AVAIL  REFER  MOUNTPOINT
rpool                     10.4G  11.1G    46K  /rpool
rpool/ROOT                3.96G  11.1G    31K  legacy
rpool/ROOT/openindiana    5.92M  11.1G  1.70G  /
rpool/ROOT/openindiana-1   448M  11.1G  1.66G  /
rpool/ROOT/openindiana-2  3.51G  11.1G  2.92G  /
rpool/ROOT/openindiana-3    56K  11.1G  1.90G  /
rpool/ROOT/openindiana-4    91K  11.1G  1.90G  /
rpool/ROOT/openindiana-5    55K  11.1G  1.90G  /
rpool/dump                1.00G  11.1G  1.00G  -
rpool/export              4.36G  11.1G    32K  /export
rpool/export/home         4.36G  11.1G    32K  /export/home
rpool/export/home/anton   4.36G  11.1G  4.36G  /export/home/anton
rpool/swap                1.06G  12.1G   132M  -

Check the history of the changes made to the filesystem:

root@openindiana:/home/anton# zpool history
History for 'rpool':
2011-07-01.16:11:03 zpool create -f rpool c1d0s0
2011-07-01.16:11:04 zfs set org.openindiana.caiman:install=busy rpool
2011-07-01.16:11:07 zfs create -b 4096 -V 1024m rpool/swap
2011-07-01.16:11:10 zfs create -b 131072 -V 1024m rpool/dump
2011-07-01.16:11:32 zfs set mountpoint=/a/export rpool/export
2011-07-01.16:11:33 zfs set mountpoint=/a/export/home rpool/export/home
2011-07-01.16:11:37 zfs set mountpoint=/a/export/home/anton rpool/export/home/anton
2011-07-01.16:22:50 zpool set bootfs=rpool/ROOT/openindiana rpool
2011-07-01.16:24:40 zfs set org.openindiana.caiman:install=ready rpool
2011-07-01.16:24:41 zfs set mountpoint=/export/home/anton rpool/export/home/anton
2011-07-01.16:24:45 zfs set mountpoint=/export/home rpool/export/home
2011-07-01.16:24:49 zfs set mountpoint=/export rpool/export

View the current load on ZFS:

root@openindiana:/home/anton# zpool iostat
capacity     operations    bandwidth
pool        alloc   free   read  write   read  write
----------  -----  -----  -----  -----  -----  -----
rpool       9.45G  12.4G      0      0  1.39K  3.27K
----------  -----  -----  -----  -----  -----  -----

Check the integrity of the filesystem:

root@openindiana:/home/anton# zdb -c rpool

Traversing all blocks to verify metadata checksums and verify nothing leaked ...

        No leaks (block sum matches space maps exactly)

        bp count:          280189
        bp logical:    10321356800      avg:  36837
        bp physical:   10087483904      avg:  36002     compression:   1.02
        bp allocated:  10148575232      avg:  36220     compression:   1.02
        bp deduped:             0    ref>1:      0   deduplication:   1.00
        SPA allocated: 10148575232     used: 43.21%

You can prepare filesystem snapshots (or backups). Decide exactly what parts of the filesystem you want to copy (there’s no reason to snapshot the entire filesystem, especially if the critical parts are stored only in /export/home/anton).

# zfs snapshot -r rpool/export/home/anton@snap4

Later, you will be able to recover it with:

# zfs rollback rpool/export/home/anton@snap4

If a rollback isn’t advisable, but you want to retrieve lost data, you can mount this snapshot at any directory, and copy the required data out:

# zfs clone -o mountpoint=/tmp/snapshot/ rpool/export/home/anton@snap4 rpool/export/home/anton_bak

The possible operations with ZFS, as well as ZFS itself are very promising. It combines backup/restore features, data compression on the fly, LVM manager, etc.

It looks like the Illumos Foundation, responsible for current and future OpenIndiana development, has every chance of bringing, not a rival, but rather, a competitive technology into the Linux world.

In a subsequent article in this series, we will discuss the virtualisation, disk and zone management aspects of OpenIndiana.

According to Wikipedia: “Virtualisation, in computing, is the creation of a virtual (rather than actual) version of something, such as a hardware platform, operating system, a storage device or network resources.” For the purposes of this article, I will deal primarily with operating system virtualisation.

Operating system virtualisation allows one OS (the guest) to be run completely within another OS (the host), like an application. For example, Windows can be run on Linux, or Mac OS X.

Virtualisation is one of the technologies that will shape the way the world computes in the future. It makes it possible to carve up, allocate and manage compute resources in new ways, allowing new degrees of freedom in systems design.

While virtualisation has already found a solid footing in the enterprise market, it is still a relatively new technology in the user space. I will compare three popular virtualisation products, and grade them on ease of use, performance, features, licensing and support. As I go through the comparisons, I will attempt to cover not only the specifics of the products themselves, but also the underlying concepts. Finally, I will analyse the scores of different products from the standpoint of different types of users.

The products I will be comparing are VMWare Player, VirtualBox and KVM. I have chosen these since they are all free of charge for personal use, and have large user communities. I have deliberately excluded VMWare ESX and Xen, since they are both targeted at enterprises. Due to this, despite the fact that they shine on expensive enterprise-grade servers, neither is designed to work with commodity hardware. ESX, for example, refused to install on my test system, altogether.

Some basics

Virtualisation being a relatively new technology, its language is still evolving. Most terms in the virtualisation space have several meanings, depending on which vendor you speak to. In order to avoid confusion, here are translations into English for some of the jargon that I will use:

• Virtual machine: A VM is a completely isolated instance of an operating system (guest) running inside another operating system (host).
• Hypervisor: A hypervisor, or virtual machine manager, is a software layer that presents the virtualised hardware platform on which the VM instances run. There are two types of hypervisors:
• Type 1 hypervisors run on “bare metal” — that is, they do not require a host OS. In this case, the hypervisor acts almost as the OS itself.
• Type 2 hypervisors require a host OS, and run as an application.
• Full virtualisation: In full virtualisation, every part of the underlying hardware is virtualised and presented to the guest. This means that the guest can be completely unaware that it is running in a VM and not a physical machine.
• Para-virtualisation: In para-virtualisation, the underlying physical hardware performs tasks that function poorly in a virtual environment. This requires the guest OS to be aware that it is running in a virtual instance. Some virtualisation products provide this functionality as a set of drivers to be installed into a guest OS, while others require the OS itself to be modified.
• Snapshots: A snapshot is a point-in-time capture of the VM. Different products classify snapshots differently. However, the most common understanding of the feature is that a snapshot preserves the machine in suspended animation — that is, the contents of memory and state of the CPU are written to disk, as is. When the machine is restored, the operation resumes from where it was left off. This allows point-in-time recovery, and an ability to roll back unwanted changes.
• Live migration: In the context of virtualisation, live migration is the seamless transfer of a running guest from one physical host to another. Live migration is an advanced feature, and many hypervisors impose restrictions on the source and destination system, most commonly that the CPUs of both need to be identical (homogeneous systems). Live migration between non-homogeneous systems is more complex, and consequently supported by fewer hypervisors.

Test system

For the purposes of the evaluation, I used an Ubuntu Server (Natty Narwhal) installation on a white-box desktop-class machine, with an AMD Phenom II X6 1090T hexa-core processor, 8 GB of RAM, and a Seagate 7200 RPM, 1 TB SATA hard drive.

Asking the right questions

One route to evaluating anything is to understand the need. The first question on this route is: “Why, if at all, should I use virtualisation?”

This question is important, because unless you understand your need, it is very simple to get stuck with the wrong solution — and nothing is worse than
spending weeks tweaking your VMs to get them configured just enough to work, and then discovering that the feature you need is available out of the box in a different product.

Some reasons to virtualise:

• You need a different OS to run a particular application — for example, games that run only on Windows, code that can only be compiled on a native Linux machine, etc.
• The need to standardise environments across a group, such as a locked-down development environment for a contractor, several developers collaborating on an open source project, etc.
• Centralising, optimising and sharing resources, as in virtual desktops/servers sharing data-centre hardware.

The list goes on and on. Ultimately, there are as many use-cases for virtualisation as there are users. While it is possible to analyse one’s use-case to the last CPU cycle, and choose the right product based on mathematics, it is usually overkill from the standpoint of the average user. It is often simpler to make a choice based on the user’s skill level and patience.

The question then becomes: “How do you classify yourself as a user?” I usually see users in four categories, based on their profile (see the Box). Given that the user’s profile usually correlates to the use-case, at least in a broad sense, it is simpler to choose the product that works best for the user.

Later in this article, I will apply this approach and rate the products, first objectively, and then relative to the user profile.

VMWare Player

VMWare is one of the oldest players in the virtualisation market. Founded by Diane Greene, Mendel Rosenblum, Scott Devine, Edward Wang and Edouard Bugnion in 1998, VMWare launched its first product, VMWare Workstation, in 1999. VMWare Player is a clipped down version of the paid VMWare Workstation product.

Let’s take a look at its features.

Figure 1: The VMware Player Inventory

Figure 2: The VM interface on VMware Player. Threadbare or minimalist?

Creating, editing and managing VMs

Initially, VMWare Player did not allow users to create their own VMs. After version 3, this limitation no longer applies, though several features available in VMWare Workstation are missing on VMWare Player. For example, VMWare Player defaults to a SCSI hard disk during VM creation. This cannot be changed, unless the VM is edited in VMWare Workstation. While this does not pose a problem for the average user, power users who like to tweak configurations will find this irritating. The same limitation also applies to the virtual NIC.

One cool feature during VM creation is EasyInstall, which allows you to customise the guest OS with such things as licence keys and user accounts, directly through VMWare Workstation, without interacting with the guest during installation. This means that you can now start that long OS installation in your VM before hitting the sack, and wake up to a fully installed OS.

The network stack on VMWare Player is also noteworthy. VMWare allows three modes of networking for the guest: bridged, NAT and host-only. What I particularly like is that in NAT mode, VMWare creates a virtual network interface and assigns an IP to the host on the same subnet as the guest, allowing network communication between the guest and the host over the NAT interface. VMWare’s approach to virtual networking makes it very easy for the user to switch between networks. It is almost akin to pulling your LAN cable from one switch and plugging it into another.

Device support

While VMWare may be finicky about the hardware that it uses for its bare-metal hypervisor, the support for end-user devices that VMWare Player inherits from VMWare Workstation is quite good. VMWare is usually able to recognise the device type (for example, my installation could differentiate a USB webcam from a pen drive) and treat it accordingly.

One of the most beloved features of VMWare Player/Workstation is virtual printing, enabled through VMWare’s partnership with ThinPrint Inc. Essentially, any printer installed on your host can be used by applications running in the VM, without installing additional drivers. This is a super feature when it comes to convenience, since most printer driver installers take forever to download and install, on account of bloat-ware.

Other features

VMWare Workstation offers the ability to snapshot incrementally, thereby allowing multiple points of recovery. VMWare Player, however, does not have the snapshot feature at all. If you really wanted to back up your machine, you could copy the VM folder altogether, providing a poor man’s snapshot capability. However, VirtualBox and KVM both come with snapshot support out of the box in the free and open source versions.

The Unity feature allows applications running in the guest to integrate seamlessly with the host. This works particularly well when the only reason to run a guest at all is to use a particular application. With Unity, you can continue to use your own familiar desktop, with the application from the guest fully integrated. The only limitation is that the guest application continues to see the filesystem of the guest. However, with the ability to share folders between guests and hosts, this is easy to work around.

Another much-touted VMWare feature is the ability to drag and drop files between the host and the guest, and between guests. While “drag and drop” works well when both the host and the guest are running Windows, it is somewhat limited for other OSs, such as Linux.

Ease of use

VMWare Player is one of the easiest products to use, because of VMWare’s great packaging and simplified user interface, particularly if it is used for its intended purpose, which is to run pre-built VMs. Several VM appliances, preconfigured for common use-cases (like a LAMP server, Ubuntu Desktop, etc) are available for download, and can be run with little or no configuration changes in VMWare Player.

Installation

The VMWare download site was particularly slow on both my broadband connection and high-speed data card. It took about three hours and two attempts to download the 105 MB binary. Also, since VMWare requires you to sign up and accept several pages worth of legal agreements before any download, there is no link that can be used to download directly from the command line. Since I was running a headless system, with no browser, I had to download to my desktop and then copy the file over the network. However, after the download, the installation was fairly simple.

Administration

VMWare’s administrative tools are usually rather slick. However, much of the goodness of the VMWare Workstation UI is missing in VMWare Player. The entire experience is of using something that can do more, but has been artificially stripped down. The VM runs in a floating window on your desktop, or in full screen mode, while the VMWare Player inventory stays in the background as a separate window.

There is no ribbon with convenient power buttons as with the paid version. All options are tucked away under menus. The Virtual Machine settings page allows you to change machine settings — except, of course, the hard drive.

Figure 3: VMware Player’s VM hardware settings. No HDD :-(

Figure 4: Options settings on VMware Player

Look and feel

Having been in the desktop user-space for a while, VMWare has learnt its UI lessons well. VMWare Player definitely scores high on the look-and-feel aspect. Even over a remote X server connection, the VM display remained smooth and responsive. The mouse-pointer integration works extremely well. Cute features from the paid version, like “quick switch” and “docked view”, would definitely be nice to see in the free version.

Performance

VMWare uses a mix of full virtualisation and para-virtualisation. According to VMWare documentation, VMWare combines the best of all worlds, and picks the appropriate virtualisation strategy for each task. On VMWare’s bare-metal hypervisor ESX, the para-virtualisation support allows fairly drastic performance improvements. However, on VMWare Player, I found the performance relatively poor (see Table 1 towards the end of this article for a comparison).

In my experience with VMWare, your mileage will definitely vary on the performance front. As long as you comply with the draconian VMWare Hardware Compatibility List (HCL), you get the benefits of all of VMWare’s proprietary technology. However, any deviation from the HCL and you are on your own.

Licensing and support

VMWare Player is distributed “free, as in beer”, with a closed-source licence for most of its constituent parts. This immediately makes it unattractive from an open source standpoint. Since VMWare’s focus is enterprise, they have several partnerships and collaborative efforts in place with industry biggies like Cisco and Dell. As a result, much of VMWare’s development is directed towards industry-standard operating systems, with support for bleeding-edge releases of Linux OS flavours somewhat lagging.

There is an open source project that stays ahead of the curve on VMWare Tools features (open-vm-tools) but again, as with non HCL-compliant hardware, you’re on your own with it.

Moreover, I have increasingly found that VMWare’s communities are dominated by enterprise users, and finding community support to solve tricky configuration issues at the bleeding edge is difficult.  VMWare’s exorbitantly priced support is also unresponsive when it comes to uncommon support issues, particularly with non-compliant or experimentally supported hardware.

Score

On a scale of 5:

• Features: 3
• Ease of use: 4
• Performance: 3
• Licensing and support: 1

VirtualBox

Oracle VM VirtualBox, or simply VirtualBox, was originally developed by German software company Innotek, which was acquired by Sun Microsystems in 2008. Sun, in turn, was acquired by Oracle in January 2010. VirtualBox supports most common virtualisation features extremely well, and some uncommon ones as well.

Figure 5: VirtualBox Manager

Creating, editing and managing VMs

Creating VMs on VirtualBox is at least as easy as on VMWare Player. The edge that VirtualBox has over VMWare Player in this regard is a wider range of options to choose from, with regard to virtual hardware. For example, you can choose what model of network card should be emulated (PCNet PC II and III, Intel PRO/1000 and virt-io), as well as the disk type (SCSI, SAS or IDE).

VirtualBox allows the addition of virtual hard disks after creation, a feature missing on VMWare Player. VirtualBox also supports several disk formats, including the VMWare VMDK, which makes it easy for users to migrate to it. You could simply boot your VMWare disk on VirtualBox (some limitations on the VMDK type do apply) and test out the functionality for yourself before porting over, if at all required.

VirtualBox provides the same networking modes as VMWare Player (Bridged, NAT and Host Only), but without network connectivity between the guest and the host in NAT mode. To reach the guest from the host, or vice-versa, you need to set up a second interface with host-only or bridged networking.

Figure 6: VM Hardware Settings on VirtualBox

Device support

In this department, VirtualBox lags somewhat behind VMWare Player. USB 2.0 support is only included as a closed source extension. VirtualBox also doesn’t have the same class of printer support as VMWare does, which means you have to install drivers for all your printers in the guest OS.

Other features

VirtualBox fully supports snapshots, including multiple snapshots and branching of snapshots. This means you can use VirtualBox to maintain several versions of the same VM. The shared folders work extremely well, as does the clipboard integration, making VirtualBox all the more desirable as a desktop virtualisation solution.

Live migration is supported between non-homogeneous hosts, something that even VMWare and Citrix enterprise hypervisors struggle with. While this may not be something the average home user would use, from a systems design standpoint, this is definitely interesting.

VirtualBox also officially (albeit experimentally) supports Mac OSX guests — and that too, without any hacks on the OSX DVD!

Installation

VirtualBox is installable from official software repositories of most common Linux distros, which means that it’s downloaded from the closest mirror, making for a relatively quick download. Once the defauly distro installer is done with the installation (which is usually running a single command), there are no additional steps required to get the software up and running.

Administration

VirtualBox comes with a great administration interface that allows users to create, modify and manage VMs. Command-line intervention is usually only required for very advanced experiments. Most operations that an administrator would need are available and easy to access. Some of the settings, like the hard-disk-management page, are somewhat hard to find — but overall, the platform is extremely easy to run and manage.

Look and feel

The look and feel of VirtualBox is comparable to VMWare’s in terms of the smoothness of the experience. Mouse-pointer integration is smooth, and VirtualBox is fairly verbose about what it is going to do with regard to the mouse, even without the guest additions installed in the VM. Things like scaling and resizing of the VM display to fit the application window are adequate, even if not in the same league as VMWare.

Performance

One of the major distinguishing features of VirtualBox is its claim that it does no para-virtualisation. In fact, VirtualBox and KVM seem to be at loggerheads over the subject. VirtualBox’ site says: “VirtualBox is [also] different from so-called ‘para-virtualisation’ solutions [such as Xen], which require that the guest operating system be modified.”    On the other hand, KVM says: “So-called ‘full virtualisation’ is a nice feature because it allows you to run any operating system virtualised. However, it’s slow because the hypervisor has to emulate actual physical devices such as RTL8139 network cards. This emulation is both complicated and inefficient.”

Religious debates aside, while libvirt (KVM’s almost-but-not-quite para-virtualisation library) provides phenomenal performance (see Table 1 for comparison), VirtualBox is not too far behind. Moreover, despite the comments about para-virtualisation on the site, VirtualBox also supports the KVM virt-io standard for the virtual network adapter, which allows it to provide almost comparable transfer speeds to KVM. However, virt-io requires the guest to be virtualisation-aware. So while this works out-of-the-box for newer Linux distros with libvirt included, Windows systems will require an installation of the virt-io driver.

Licensing and support

VirtualBox comes as an open source core system supplemented by proprietary, pre-compiled extension packs for additional functionality, such as RDP, PXE boot and USB 2.0 support. The extension packs are released under the Oracle PUEL (Personal Use and Evaluation License), while the core is released under GPLv2. All of the components are free of cost, with the proviso that the extension packs will be used under the guidelines of the PUEL. Most of VirtualBox’s features are available in the open source version. The only notable absentee is USB 2.0 support.

The VirtualBox community is extremely vibrant and responsive, and solutions for most user issues are merely a Google search away.

Score

On a scale of 5:

• Features: 4
• Ease of use: 4
• Performance: 4
• Licensing and support: 4

KVM

KVM, or Kernel-based Virtual Machine, is a virtual machine implementation that uses the Linux kernel. Invented and maintained by Qumranet, a technology start-up acquired by Red Hat in 2008, KVM is included out-of-the-box with Linux kernel versions 2.6.20 and above.

Figure 7: KVM’s GUI virt-manager

Figure 8: KVM’s VM Console

Creating, editing and managing VMs

Creating VMs is simple enough with the virt-manager tool. However, importing an existing VM (from both VMWare as well as VirtualBox) and converting it to run on KVM was nightmarish. For some reason, when KVM is told to use an existing disk, it silently assumes that the disk it is being pointed at is a raw disk format, even if the disk file has a different extension. In order to get my KVM machine to boot, I had to export the VM definition as an XML file, change the disk type manually, and then reimport it.

KVM offers, by far, the most choice of all the three products reviewed here on virtual hardware selection. Several different types of hardware can be emulated, based on user selection. KVM also allows both NAT and bridged networking. However, the bridged network mode requires setting up a bridge on the host, manually, which can be tedious.

Figure 9: Choosing the bridged device in KVM

Device support

Since KVM is part of the Linux kernel, it supports most devices that Linux does. Moreover, since KVM has a large open source developer community behind it, support for new devices is usually quick to appear. However, KVM’s device support is far more appealing from the perspective of server virtualisation than the desktop, at least for the average user.

Other features

KVM’s feature set is mainly systems-oriented, without too many cute user-land baubles. Live snapshots of guest VMs are supported, from the command line. There is no concept of shared folders or clipboard. USB support is included out of the box. KVM also supports live migration of guests between non-homogeneous hosts.

Ease of use

KVM is the least user-friendly of the three products reviewed here. It has all the distinctive signs of a product by, and for, the elite geek or the expert systems architect.

Installation

Simply put, none required. KVM comes backed in with the Linux kernel. The only installation I required was that of virt-manager, a graphical tool to manage VMs, which was a simple installation from the distro’s package repository. Unfortunately, I also had to install several X libraries on an otherwise headless system, and then access it through a remote X session. The alternative was to spend several hours mastering the command-line language of KVM and virsh, the command-line tool for managing VMs.

Administration

Even with virt-manager, which simplifies things drastically, KVM’s administration requires familiarity with virtualisation. If you know exactly what you are looking to accomplish, KVM will probably have the means to accomplish it. However, if you are unsure of your need, it is very easy to get lost within KVM’s myriad options. Also, the administration console is not very good at giving user feedback.

For example, changes to a VM that require a reboot can still be made while the machine is running, and will be applied the next time the machine reboots. However, after the change is queued up, there is no visible indication that a change is pending, until the reboot happens, and the change takes place. For an inexperienced user, this sort of behaviour can be quite confusing.

Look and feel

KVM is definitely not in the same league as VMWare Player or VirtualBox when it comes to look and feel. The VM display is over VNC, the quality of which is dependent on the network link between the client and the KVM server. On my installation, the VNC display refused to recognise several keys altogether, resulting in my having to use a different VNC client. Mouse-pointer and clipboard integration are also not as good as the other two products.

Performance

Performance is where KVM outshines both VMWare Player and VirtualBox (see Table 1 for a comparison). The secret behind KVM’s success is the use of the libvirt libraries and the VirtIO network and hard disk interfaces. VirtIO is very similar to para-virtualisation, the only difference being that while para-virtualisation requires the entire guest OS to be modified (for example, Xen’s requirement that guests run the Xen kernel), VirtIO works by installing components inside the guest. These components are included as the libvirt libraries in most of the new Linux distros. However, for Windows guests, this means that a VirtIO driver needs to be installed.

For disk I/O, KVM allows the virtual hard disk to be mounted in write-back or write-through mode. In write-back mode, the process of writing data to disk receives an acknowledgement of the write having occurred immediately after the I/O subsystem receives it, even if it has not been committed to disk. This means that processes run faster. However, data in transit (written but not committed) is stored in volatile memory, and so a crash or power outage will result in data loss.

For mission-critical systems that require high data integrity, the write-through mode is preferable, since it guarantees a commit to disk. However, the existence of the write-back mode means that KVM machines can be tweaked to perform disk I/O at super-fast speeds.

Licensing and support

KVM’s licensing is hard to beat for attractiveness, since it’s completely open source, with all the components released under the GPL or the LGPL. The KVM user community is somewhat biased towards developers and systems designers rather than end users, so finding solutions to problems requires some background and understanding of the platform. Essentially, you can find help, but you really do have to read the manual.

Score

On a scale of 5:

• Features: 2
• Ease of use: 1
• Performance: 5
• Licensing and support: 4

Analysis

To sum up the comparison, look at Table 2.

From a look at the score board, VirtualBox clearly outshines the other two products by being better than average in all the categories, even if it doesn’t top any of them, with KVM next, and VMWare Player last.

Let us now see what these scores mean, from the viewpoint of different types of users.

The enthusiast

From the enthusiast’s standpoint, KVM would seem like the best choice, since it has the most configuration options. Enthusiasts will find plenty of new combinations of settings to experiment with. KVM’s lack of end-user features and complexity of use also give it the flavour of being a tool for the elite, which the enthusiast is likely to find appealing.

Next in line is VirtualBox, which offers fewer options, but still enough to keep a geek interested. Moreover, getting bragging rights on VirtualBox doesn’t require you to have a PhD. Simply reading the manual and following the forums will suffice.

VMWare Player is last in line for this category of users, since it offers very limited customisability.

The architect

For architects, the requirement determines the choice of component. For server virtualisation with an emphasis on performance and scale, KVM is the clear choice. For end users, VMWare Player is the best choice, since it can run a VM authored on Workstation in a manner that makes it extremely easy to use, particularly for a user who’s not tech-savvy. However, for prototyping and getting off the ground quickly, VirtualBox’ superior feature set makes it the tool of choice.

The executive

From the executive’s standpoint, VirtualBox is the product with the likelihood of meeting the most requirements at the least cost. If budget was not a constraint, VMWare Player’s paid version, VMWare Workstation, could give VirtualBox a run for its money on features. VirtualBox provides many more features in the free version than VMWare. The exception to this is if the VM is being authored elsewhere, and VMWare Player is being used only for access. In that scenario, VMWare Player is much easier to use than either of the other two.

KVM is not really a solution for the executive at all.

The follower

From the follower’s viewpoint, the ideal and often only supportable option is to use VMWare Player to run existing VMs (created by Workstation). Next in line is VirtualBox. As with the executive, KVM is not an option for the follower.

The Intel 8085 is an 8-bit microprocessor that was launched by Intel in 1977 and hence is something that we have never seen around. So why do we need to learn about the assembly of this old microprocessor?

The microprocessors we use are all for general-purpose computing, but there are other applications of computers such as making automatic solar-tracking-panels, automatic power-controls, or security control systems. For such applications, general-purpose CPUs are unnecessary — a waste of resources; a low-powered CPU is what we need. The Intel 8085 is one of the candidates.

To program this piece of hardware, we first need to know the programming model — the logical structure of the programmable registers, flags, and the instruction set. The Intel 8085 has seven internal general-purpose 8-bit registers A, B, C, D, E, H, L and 5 flags — S (sign), Z (zero), AC (Aux Carry), P (Parity) and CY (Carry). The BC, DE and HL registers can be used as register pairs and work as 16-bit registers, with some specific instructions. Besides these, there are two other registers: one is the program counter (PC), which is a 16-bit register, and always points to the memory address of the next instruction to be processed; the other is the stack pointer (SP), a 16-bit register that points to the top of the stack.

The processor has a total of 246 instructions with which we can manipulate data in the processor registers and memory, and also perform conditional branching in code with the help of flag values, which are set by the instructions, depending on the result. This is a brief overview of the programming model; see the References section at the end of this article for links to more information.

Programming the Intel 8085 or similar microprocessors is not like present-day programming — there is no editor, compiler or assembler, and not even a monitor. You can probably have a 7-segment display, which has to be manually interfaced, to show the memory content. You need to burn in the assembled program (essentially, some numbers in memory), connect the memory with the processor, and the microprocessor starts to run the code.

There are programmers to burn the code into memory, and microprocessor kits that help you program the microprocessor interactively by providing additional controllers, 7-segment displays, a 4×4 keyboard, the interfacing, etc. However, you still have to hand-assemble the code.

Now, no code is perfect the first time; that’s why we have bugs. Debugging code on an 8085 itself is a real pain. Even if you use a microprocessor kit with a debugging facility, the limited debugging features make it a complex and slow process, not suited for a beginner. So, essentially, to know if your code is correct or not, completely depends on your skills, the expected outputs of the code, and the minimal debugging interface.

Wouldn’t it be great to be able to test the code and develop it completely before even touching the actual processor? This is what a simulator lets you do — the very purpose of the GNUSim8085 Intel 8085 Microprocessor Simulator.

About the simulator

The 8085 microprocessor simulator simulates the Intel 8085 programming model, with the same instructions available as on the real system. The input and the output of the actual machine and the simulator are identical, although the internal processing method may differ. The simulator lets you view the contents of the registers, the memory and I/O port values, execute one instruction at a time, and also write code in mnemonics instead of hand-assembled code.

While I was pursuing my undergraduate course, I began to look for a FOSS-based 8085 simulator. Simulators supplied with text books, and others available on the Internet either did not fulfil my needs, or were not FOSS. Then I recalled that LINUX For You had once published a review of GNUSim8085, and downloaded the software. The basic features listed on the official site are:

• It comes with an 8085 assembler.
• The editor has syntax highlighting.
• Register and Flags display are available.
• Has a hex-to-decimal converter.
• Provides a view of memory, I/O and stack contents.
• Step-by-step execution support.
• Print support.
• Has UI in different languages.

Now, let’s take a detailed look at this software.

The interface

When the software is launched, the editor starts with a template — sample code you can edit — or, you can open a new file, and start coding. The editor lines are numbered. The code highlighting is good, and makes it easier to read the code. To run or assemble code, you need to save it first, before compilation is allowed.

On the left-hand pane, all the registers and flags are listed in a very easy-to-read manner. All the register values are displayed in hexadecimal format. The hex-to-decimal conversion box, which is very useful in such applications, is in this pane. Personally, I feel that the implementation ought to have been a bit different. To convert from decimal to hex, or vice-versa, you need to type in the number and click the correct button to make the conversion. I would have liked it if it automatically converted as the input box value change; this would make things much faster and more convenient.

Then the I/O Ports space is displayed as a spin-box. The spin-box index is the port number, and the text box beside it shows the contents of this I/O port. Similarly, the memory space is shown with another spin-box. Note that the values shown in both are all in decimal. The default input for these is in decimal, but to enter a value in hex, you add an h after it; if the number starts with a letter of the alphabet, you need to add a zero before it. For example, AB is entered as 0abh.

On the right-hand side, there are three tabs. The Data tab shows the data variables you have defined with the assembler EQU pseudo opcode (discussed later). The next tab shows the stack state. After you initialise the stack pointer (SP) and execute PUSH, CALL or other stack-manipulation instructions, this tab will show the address and value of the entire stack, along with the associated pushed register pair or program label (for call).

This is especially helpful when you are debugging code with many nested subroutines, or using stack-manipulation instructions like XTHL. When pushing the contents of the PSW register (Accumulator and Flags), the Register name under the Proc/Reg field is incorrect, although the performed operations have no problem. This is a really helpful tool for debugging.

The third tab contains a virtual keypad, consisting of keys corresponding to each instruction. It looks good, but I do not think this is a feature that will get used a lot. It is much easier and simpler to type in mnemonics, than to click buttons to code.

In the text box on the top labelled “Load me at”, you can enter an address location, and make the assembled code load, starting at that memory location. The default input is decimal; to enter hex, use the same rules as before. An empty or invalid address means the program will be loaded at 4200h by default.

The Assembler menu has three items. The first, Assemble (F8), is used to assemble the program and load it into memory (at the load address). There is no practical use of only assembling the code in the current version, as you cannot generate an output assembled binary file that you could burn into the 8085′s memory. The next, Execute (F9), would execute the compiled program.

The following entry is Show Listing (Ctrl + L), which shows you the assembled machine code, along with the memory address opcodes, mnemonics and comments. This window is especially useful when you have successfully run a program in the simulator, and are ready to run it on the actual 8085; you simply need to enter the proper load location, and then either display the listing, or save it into a file and print it out, before entering it into the actual machine. This saves you from the hassles of hand assembly.

The Debug menu has the Step in (F5), Step Over(F6) and Step Out(F7) options, along with the program breakpoint management. These features are very helpful for debugging code by inspecting the register and memory contents at each step, or at breakpoints.

From the Reset menu, you can reset the state of registers, I/O ports, flags and memory, individually or all at once. It is useful when you want to remove old data from the simulator without writing extra 8085 code.

The toolbar is concise and clutter-free. It contains the normal save, load and new icons, apart from execution and debug shortcut buttons. The icon of the big red cross is to stop (terminate) execution when you are stepping through code, or in between.

At the bottom of the window is the assembler error message output panel, where you see any errors, with the line number and a brief description of the error. Clicking the error message highlights the line with the error.

Assembler

This simulator comes with an assembler: you write the code in Intel 8085 mnemonics, and it is converted to machine code by the assembler, freeing you from the pain of hand assembly. The assembler supports four types of syntax parts:

1. The assembler Intel 8085 mnemonics: The instruction strings as in the manuals.
2. Labels: A named point in the code, the target for JMP or CALL instructions.
3. Comments: Anything on a line after a semicolon (;) is ignored by the assembler, and used to write comments explaining the code.
4. Pseudo opcodes: Are not actual opcodes, but instructions to the assembler that provide some features to ease the coding process.

Instead of repeating the assembler features of the simulator here, I recommend you read the official site, where every detail is documented. From version 1.3.7, this assembler tutorial is included with the software, available at Help –> Assembler Tutorial.

After using this software for quite a long time, I have found some positive and negative points about it, which I will discuss below.

The highs (and the lows)

• Has a detection mechanism for when your code goes wild. For example, if you forget to place a HLT to stop processing, the simulator will automatically stop program execution and warn you about this.
• If you do more POP operations than PUSH, the simulator stops execution and tells you to check the logic. Although there is no warning on the real 8085 (it cannot — it would simply take the contents of SP as the top of the stack), this is very helpful, because such unbalanced stack operations are hard to detect in a large program.
• The stack view and tracing is a good feature and is really helpful for debugging code with many subroutines and a lot of PUSH, POP and other stack-related instructions.
• Like most simulators, this has a very good and easy-to-read register and flag views, which helps in programming.
• It provides an assembler and lets you enter the program in Intel 8085 mnemonics instead of hand assembly as on the real 8085 (when programmed manually).
• Has debugging features.
• Has assembler listing with address location, opcodes, mnemonics and comments — all as a single list. This listing can be followed when entering the code manually on the real 8085, and also keep the mnemonics of the opcodes at hand. Good for documentation.
• The editor has good highlighting, which makes the code easier to read.
• Most importantly, it has a very simple and clutter-free interface.

Here are some points that I felt needed improvement:

• The label line needs to be assigned at least a line of code. For example, if you do something like the following:

  mvi c, 0ah
  mvi b, 05h
  xra a
  loop:
  add b
  dcr c
  jnz loop

  The above code would not assemble, as the line with the label “loop” does not have any code. Either you have to move the ADD B to the “loop:” label line, or simply include a NOP beside the label “loop”.

• The memory and I/O contents are displayed in decimal, which causes a lot of confusion as the registers’ displays are in hex. Thus, each time, you need to convert the values and check the output. Also, because of this difference, if you are working with code that manipulates a good amount of data from memory, it becomes even more difficult to trace, as each time you need to pay attention to the base of the number you are looking at.
• Representation of the I/O, and the memory editing with the spin-box makes memory data entry and inspection very slow. For example, if you enter some data manually in memory, then you need to: click on the text box, enter data, click Update… and continue like this. I would recommend that memory and I/O should be editable with the mouse and also with easy keyboard shortcuts. For example, a grid display with scrollbars showing 10-20 memory locations, navigable with the keyboard, would be extremely helpful.
• The editor has only one tab — so if you open another file when one file is already open, the new replaces the old. An MDI feature would be great, but as it is, this is not much trouble, in my opinion. (See the Bugs section below for more on this)

Bugs

While using and testing the 8085, I have found some potential problems, bugs and glitches in the simulator, which are listed here.

• The PUSH PSW shows an invalid string for the register name in the Stack debugging tab.
• There is a bug related to opening and closing files. When you are working with one file and then open another, the editor displays the new file — but what is not obvious is that the old file (which you were working on) is not closed. This is not much trouble, since the limit for the maximum open files is quite large by default (run ulimit -n), but this should be fixed. You can check it by first launching the program, and then keeping an eye on the output of watch ls -l /proc/$(pidof gnusim8085)/fd.
• There is a severe problem with the simulator if you accidentally or intentionally put your code in an infinite loop — the simulator freezes, looping forever, and there is no way you can stop it except by killing it. The interface does not work in such a case. Running the interface and the execution module in separate threads would help, I guess.
• A minor glitch detected while boundary testing is that if you attempt to enter a negative program-load address, or an address greater than ffffh or 65535 in decimal, the simulator does not complain, but automatically detects an invalid range and loads the assembled code at the default loading address, 4200h. But consider this scenario: you load code at fff0h, and the length of your code is more than 15 (which will try to go beyond the ffffh memory limit). With this, if you assemble/run the code, the simulator immediately crashes. This should wrap around memory and continue to be executed from 0000h after reaching the limit ffffh, or simply notify the user about this and stop.
• Although this is a minor bug, I think it is worth pointing it out: if you enter an invalid decimal value in the decimal text box, the hexadecimal conversion shows an invalid value in the hexadecimal box. I think giving some warning of an invalid input would help users.

Version 1.3.7 v/s 1.3.5

Version 1.3.7 came out recently, almost one year after the last one. On the official website, the 1.3.7 Windows binary (with and without GTK runtime) and the 1.3.7 source code is available. The .deb is obsolete. There are not many externally visible differences in these two versions, but some nasty bugs were killed.

Version 1.3.6 was released in March 2010, but did not fix the real bugs in 1.3.5 — like in 1.3.5, clicking Help –> About would crash the program immediately. If you changed source code in an open file and clicked new, loaded another file, or simply closed it, there was no prompt to save the document. These were fixed in 1.3.7.

The really nasty DAA bug was killed in 1.3.7, for which reason you should avoid using 1.3.5. In 1.3.5, if you ran DAA after adding 99h and 01h, the accumulator ought to have contained 00h, and the carry flag should have been set, but though the accumulator was 00h, the carry flag would not get set. Try adding 59h and 45h and then apply DAA. The result would be in an invalid BCD form. Thankfully, this nasty bug was killed in 1.3.7. I would like to make you aware that there are a lot of simulators that have implemented DAA incorrectly, so please confirm DAA operation with the above sample, or with the real machine.

Some other bugs have been fixed as well, so I recommend you download the latest version 1.3.7 if it is available from your distro repository, or if not, install from source.

Have a look at the version release notes here.

Still to implement

• The RST instructions (a 1-byte call instruction, jumping to a predetermined jump location).
• RIM and SIM instructions — you would not be able to test any interrupt or serial I/O-related code. You would notice the Int-reg register in the simulator interface, which apparently represents the interrupt register that holds the masks, the pending interrupts, etc. This is non-functional.
• There are problems when printing on Windows, and the Linux environment implementation is very primitive.
• If you carefully look at the opcodes, you will notice that there are some unused ones that have no mnemonics associated. These unused opcodes are actually used, and are undocumented instructions, of which the Intel 8085 has 10 (they are not documented because they are not supported by 8086 and higher processors). These instructions and the related undocumented flags are not supported by the simulator. This will not bother many people, since, being “undocumented”, they are not generally used. Implementation of these is not that urgent, but the availability of the undocumented instructions would definitely make this simulator special and draw attention as these instructions can make some composite operation with a single instruction.

What you need to remember…

This is essentially a very good simulator to work with for educational purposes. If you have to practice code for your college exam, or to test the code in the practical copies, then I would recommend that this simulator. Some of my friends and I have used it during our engineering course, and had no problems. It has a very simple and clutter-free interface, an assembler, and the best part is that being under GPL v3, you can see the code and even edit it if you like — or request any feature update from the developers.

Programming in the simulator is easy, but it should be kept in that mind that if you are doing a course, then you need to hand-assemble and enter the code when presented with the actual 8085 in your college course. It is good to make a habit of hand-assembling and directly entering code on the actual machine, to keep in touch.

References

• Official Site
• Wikipedia article on 8085
• GNUSim8085 Wiki
• GNUSim8085 Announcements
• Microprocessor Architecture, Programming, and Applications with the 8085 by Ramesh Gaonkar

It is quite well-known that the two behemoths among free software operating systems, the ones that both represent and impact GNU/Linux, are Red Hat’s Fedora and Ubuntu from Canonical. Ubuntu’s latest version, 11.04, also known as the Natty Narwhal, was released on April 28, and a review of this version appeared in the June. Fedora followed on May 24 with version 15, codenamed Lovelock. Now, when you have two such similar releases at practically the same time, it creates rather a “Big Choice”, and it might even create a “Big Dilemma”. So, how do the two stack up against each other?

Delving into the core

Examining the core first, we find that the foundations of both are almost the same. The kernel is at version 2.6.38 in Natty, with Lovelock’s just a few point releases ahead. Kernel version 2.6.38 brings a lot of desktop-oriented improvements, resulting in much better desktop performance than was previously the norm.

Both distributions have the xorg-server at 1.10.1, udev version 167 and freetype version 2.4.4. However, while Ubuntu has already been using GRUB 2 at version 1.99rc1, Fedora staunchly continues with GRUB 1 at version 0.97. Whichever version you use, this aspect does not create much of a hassle — just the method of configuring GRUB differs in the two versions. Another area of difference is GCC. Lovelock includes version 4.6.0 of the compiler collection, while Natty includes 4.5.2 — so developers who want that wee bit more, may be happier with Lovelock.

With the preliminaries over, let’s get around to the more visible aspects and look at the giants from the outside!

The desktop environments

We will not compare KDE on the two distros. The first reason is that, both of them include version 4.6.2 of KDE; second, KDE is not the default environment of either distribution; and third, KDE 4.6 is not as radically different from 4.5 as the default environments of Lovelock and Natty are from their previous counterparts.

Lovelock and GNOME 3

Lovelock is the first major distribution to include GNOME 3 as the default desktop environment (see Figure 1) and GNOME 3 is… well, there’s a lot to say about GNOME 3. Even if you are not biased, you have to admit that GNOME 3 makes almost everything harder than it was previously.

Figure 1: GNOME 3 desktop

A major issue with software developers is their desire to reinvent everything from scratch. This is not essentially a bad thing, and GNOME up to its major version 2, GNOME was definitely plagued by legacy code such as CORBA. However, the problem with the developers and maintainers of GNOME is that they prioritise simplicity to the extent of bordering on the simplistic. This is exactly the case with GNOME 3.

The default dual-panel setup of GNOME has been replaced by a single panel at the top, and a translucent, hidden notification area at the bottom. The top panel displays the clock in the centre. Clicking on the clock opens up an enhanced version of the standard calendar, which allows managing your events from the calendar itself (Figure 2).

Figure 2: GNOME 3 calendar

The top-right portion of the panel contains the usual system management icons, including the Network Manager, the interface of which has changed somewhat in Lovelock. The networking menu displays a simplified version of the available networks, each with a representation of a toggle switch to the right (Figure 3).

Figure 3: GNOME 3 network menu

Simply clicking a network’s entry turns it on or off. The network settings and systems settings windows have also changed (Figures 4 and 5, respectively); the latter was named Control Centre in previous versions of GNOME. The system settings window appears similar to the KDE one, but some important features have been removed from the user interface. One is that you can no longer customise the desktop theme using the built-in tools as easily as you could in previous versions. In fact, the default tools don’t have any option to change the theme at all! Another UI change is that now there are no buttons present to minimise or maximise windows. To do that, either right-click the title bar and select the appropriate option, or use the keyboard to achieve the same effect—both much more cumbersome than the established norm.

Figure 4: GNOME 3 network settings

Figure 5: GNOME 3 system settings

The top panel’s default menu has also been replaced by an Activities entry. You can either click on it, or point your mouse to the top-left corner of the screen. This opens up a screen with bookmarked applications on the left and those that are currently running in the middle, along with an Applications tab that lists all installed apps. However, the convenience of having the applications listed in groups (Accessories, Internet, etc.) is gone. The right side of the Activities screen shows the currently available virtual desktops. There is always one more than the number you are using, so you can keep creating as many as you like.

GNOME 3 is new software, and, just as was the case with KDE 4, this first version still has issues that need to be sorted out. For example, Figure 6 shows the Activities screen along with an error notification at the bottom. This particular error is not fatal, but it keeps recurring, and diminishes one’s confidence in the software. Notifications in GNOME 3 are unobtrusive, and can be pulled up at a later time, as shown in Figure 7. The Activities screen also allows you to search for applications and files (Figure 8).

Figure 6: Activities — multitasking — error

Figure 7: GNOME 3 ABRT

Figure 8: GNOME 3 search

Another deviation from the norm is the user menu in the top-right corner of the screen (Figure 9). The restart and shutdown options are now gone, and only ‘Log Out’ and ‘Suspend’ remain. To restart or power off the computer, either press and hold the Alt key while the menu is open, which replaces the ‘Suspend’ item with an option to power off or restart — or log out and then proceed to shutdown from the login screen.

Figure 9: GNOME 3 user system menu

If you have more than one window open in GNOME 3, to switch between them, you either press Alt+Tab or open the Activities screen. The panel no longer has a task-bar to list open windows.

So it seems that GNOME 3 will take some time getting used to. Let’s see how Natty fares.

Natty and Unity

The developers at Canonical have not adopted GNOME 3 for Natty, although they will for its successor, the Oneiric Ocelot. Ubuntu already had a netbook interface, which was somewhat similar to Natty’s new interface, Unity — Canonical wanted to create a uniform look-and-feel across its desktop and netbook versions.

Also, the folks at Canonical were not entirely in favour of all the proposed changes in GNOME 3. Whatever be the reason, the decision to not use GNOME 3 in Natty has resulted in a much more stable environment than the one in Lovelock. So, what is Unity and what does it bring to the table?

Unity is just a shell running on top of GNOME. In Natty, therefore, you can select the Ubuntu Classic session from the login screen, if you want the default GNOME 2 interface instead of Unity. Figure 10 shows a customised Unity desktop on Natty.

Figure 10: The Unity desktop shell in Natty

Like GNOME 3, Unity also uses a single top panel, but there is no notification area at the bottom. Notifications appear in the top-right portion of the screen, as in previous versions of Ubuntu. Additionally, the top panel now serves as an integrated menu bar for almost all applications, similar to the way the Mac OSX UI works. This provides maximum vertical screen space (Figure 11). However, the absence of a taskbar even here means that to switch between open windows, you either press Alt+Tab or use the launcher.

Figure 11: A maximised window in Unity merges nicely with the top panel

The launcher is a bar on the left side of the Unity screen that holds bookmarked applications and some lenses. Lenses are screens that show searchable lists of your applications, files, results on the Web, etc. However, unlike the GNOME 3 Applications list, you can view the categorised lists of your installed applications. Also, the applications lens shows random selections of the apps available for installation from Natty’s configured software repositories, making it a useful place to discover new apps.

When you open a window, the launcher hides itself if the window needs its space, just as in the case of a maximised window. To get the launcher back, either hold your pointer at the left edge of the screen, or press and hold the Super (Windows) key on the keyboard. The latter action also causes the launcher to display numbers and letters on top of its icons. You can press a number or letter to open the corresponding window/application.

Also, right-clicking an icon on the launcher opens a context menu with useful actions. You can remove any application from the launcher, and you can also drag items in the launcher to re-position them. All of this is much more than what the default GNOME 3 panel or Activities screen does.

In the top-left corner of the screen is the icon for the Dash, a feature similar to the applications lens, which allows you to search for or browse installed applications. The shortcut key for the Dash is the OS (Windows) logo key.

As for the rest, since Unity runs atop GNOME, the basic interface is that provided by GNOME itself.

The outer reaches

We now come to the outermost aspect of our giants — the environment they provide for actually getting work (or play) done on the computer. The most famous component of this environment is probably the office suite. Both Lovelock and Natty include version 3.3.2 of LibreOffice, the new fork of the popular OpenOffice.org suite of applications.

LibreOffice is owned and operated by the community, so there is no concern of it being monopolised by any single entity. Also, the new suite has the crucial support of several big companies. It will be best if OpenOffice.org can be merged into LibreOffice, thus liberating it from Oracle, but as of now, most major GNU/Linux distributions are switching over to LibreOffice.

Apart from this, the rest of the software is also pretty standard and up to date. What is not available in the live or installation discs can, of course, be installed from the repositories. The installers are, as usual, radically different in the two distros. The venerable Synaptic Package Manager is available in Natty, just as it should be.

However, the new software manager, Ubuntu Software Centre, has seen some improvements. It now allows for purchasing software directly through its interface (although a bug prevented me from actually going through with a purchase at one go), and it also now shows libraries and other non-GUI software in search results, on demand, apart from providing some recommendations based on your searches and installations.

The standard PackageKit installer in Lovelock, on the other hand, seems pretty bare-bones in comparison. It allows simple configuration of the software sources, but is nowhere near Synaptic in power. However, YUM, the installation back-end on Lovelock, scores an extremely important point over the Debian Apt in Natty — it allows delta packages to be downloaded. A delta is just the code that is different in a new version of a package that is already installed. Downloading deltas instead of entire packages saves huge amounts of time and bandwidth for data transfers during upgrades.

However, yet another factor negatively affecting Lovelock is that Fedora does not have integrated repositories for proprietary software. It depends on the external RPM Fusion repositories, and they may not always follow the latest Fedora release on time. For example, RPM Fusion did not have the proprietary drivers for the Broadcom BCM4312 Wi-Fi chip for the current Lovelock kernel even several days after the Lovelock release (they are available now, though there is no guarantee that they will be available on time in case of a kernel upgrade).

Ubuntu, on the other hand, has always had integrated proprietary software repositories. They are not supported by Canonical, of course, but they do track the latest Ubuntu release correctly and Natty is no exception.

The verdict

Instead of beating about the bush, it is better to admit that, as of now, Natty is much more usable than Lovelock. However, there are some points that must still be taken into consideration. First of all, the future of GNOME is GNOME 3. Even the next version of Ubuntu will have GNOME 3 as its base for Unity. So, whether you like it or not, if you want to stay with GNOME, you will have to consider GNOME 3 sometime or the other.

Thus, you may want to delve into it right away, and report whatever bugs and missing features you encounter, so that the software matures more quickly; after all, free software is dependent not on corporations, but on users. And besides, KDE version 4.6 also has some serious bugs (such as PolicyKit randomly crashing at the end of a session), which have not yet been addressed by the developers.

Also, Fedora is known for its leadership and innovation in the GNU/Linux field. If you want to stay absolutely current on the Free Software front, Fedora is the way to go. Lovelock, for example, has a dynamically configurable firewall, which means that you do not have to stop and restart the firewall to effect some changes to its rules.

You also should keep in mind that if you choose Fedora, you will not just start up to date, but you will also stay up to date. For example, a Fedora release will, as long as it is supported, keep getting the latest versions of all its software, including the kernel and desktop environment, which is not the case with Ubuntu.

The final decision is, of course, up to you. Both Lovelock and Natty are critical releases that pave the way for the future of the GNU/Linux desktop. Whether you are comfortable with handling the latest stuff, with the occasional trip-up, or want the relative safety of a traditional environment, the choice is yours.

Whichever you choose, you will be a participant in one of the most important revolutions in the free software world, instead of being a mere spectator.

In Natty, Unity is the default desktop atop GNOME; it requires a 3D graphics accelerator, as it uses Compiz Fusion heavily — however, you can switch to GNOME Classic from the login menu, if you don’t have the right hardware. Ubuntu 11.10 will be shipped with a 2D version of Unity, for systems with average graphics cards.

Natty replaces Ubuntu Netbook Edition for all PCs and netbooks. Available in the usual variants — Kubuntu (KDE), Xubuntu (XFCE), Edubuntu and more — the software defaults have also changed. LibreOffice 3.3.2 is now the default office suite; Firefox 4 is the default browser; and Banshee replaces the Rhythmbox music player.

The Ubiquity installer has ‘graduated’

The Ubiquity installer is getting much smarter and understandable with every incremental release. People new to Linux (who fear messing up their existing OS while doing a dual-boot installation), and those who don’t understand what swap space is, or how much they need of it, will like Ubiquity.

Ubiquity installer

This installer is quite impressive; it guides you at every step, letting you know what’s happening, what you might want to do, and how it can be done. It detects whether you are installing on a system with an existing Windows installation, or upgrading from an earlier Ubuntu install, etc. It also has an expert partitioning option for experienced Linux users.

Once you enter the required choices, the installer begins copying files in the background, while you fill in additional information like the time zone, user details and more. The migration assistant, too, works flawlessly, and migrates your documents, pictures, user settings and so on without any hassle. You can also choose to install third-party software like Flash, MP3 codecs, Java, etc.

Install third-party stuff right from the installer

Installation is not much speedier. Boot time from a live USB was less than a minute on a Core2Duo laptop, and two minutes on my netbook.

The Unity bar is here to stay

Like it or hate it, the Unity bar is clearly here to stay. It’s had a major face-lift since 10.10, though it still sits atop GDE. It’s not much different once you get past the layout and some basic controls. The new Unity interface is very innovative and neat, and saves screen real estate. It has a dock-style bar on the left with common applications, and a standard panel across the top. It auto-hides when you maximise windows, and comes back when you hover the mouse in the upper-right corner. The Unity bar scrolls icons when you hover the mouse pointer over the icons stacked like a deck of cards in the lower-right corner.

Click app icons to start them. A caret sign appears to the left of the icons for apps that are already running; a caret on the right of the icon shows the currently active app. Shift-clicking an icon launches a new instance of an already-running app; tiny lights show multiple instances. You can drag-and-drop to rearrange icons, and remove an icon by dragging it off the bar. To quit an app, right-click and select Quit from the menu.

The Ubuntu button (top-left corner of the screen) gives you an iPad-like home screen, with high-resolution icons for your favourite destinations. The Workspace Switcher feature, accessed via a sidebar icon, defaults to four virtual desktops.

Workspace switcher

Mac-like app menu bar

The Ubuntu 10.10 netbook edition missed the very important unified menu bar. Yes, Natty has made some Apple-like changes — the top bar serves as a universal app menu bar, displaying the application’s menu bar (when they have one) here, instead of in the app window. Natty thus provides users the maximum possible vertical screen space.

Universal menu bar

Unity’s keyboard navigation

Another addition with Unity is navigation for keyboard shortcuts, most of which use the Windows key. Holding down the Windows key shows numbers for each dock item; launch one by pressing the corresponding number. Tap the Windows key for a quick-search box from the upper-left corner, which lets you launch applications, search files and folders, and access system settings and utilities. For a wallpaper with a complete keyboard shortcuts listing, visit askubuntu.com.

Quick search bar

Updated software defaults

The Linux kernel is now the much more stable version 2.6.38.2, so users get improved overall system performance. The open source Banshee 2.0 Music Player, which replaces Rhythmbox, was originally named Sonance, until 2005. It uses the Helix and GStreamer platforms for handling media formats. It supports bookmarks, the Amazon MP3 store, video support, audio books support for libraries, metadata fix-up, integration with the sound menu, and a few more features.

Natty uses LibreOffice 3.3.2, developed by The Document Foundation, which is a fork of the well-known OpenOffice.org. With the same features as OpenOffice.org, it will be easy for users to switch to LibreOffice. Firefox 4 débuts as the default browser in 11.04. With an improved user interface, “door-hanger” notifications, a redesigned extension manager and Firefox Sync, users now have a modern browser.

The updated Software Centre, Ubuntu’s version of an app store, is already well-liked by users since the release of Ubuntu 10.10. The Ubuntu One control panel now supports selective file synchronising, and the synchronisation itself is improved. The launcher icon also displays file sync progress. In the visual improvements department, scrollbars are now “zero-size”, the icons much better, and the overall feel one of an iOS device.

Software Centre

Things to do after installing

First, of course, install all recommended updates using the Update Manager and restart the machine.
For a pleasant Unity experience, hardware drivers must be updated, since Unity demands 3D acceleration. If Unity isn’t working, run the Additional Drivers program and activate the driver. If you have an nVidia graphics card, then you have to install it using a PPA, as follows:

sudo add-apt-repository ppa:ubuntu-x-swat/x-updates
sudo apt-get update
sudo apt-get install nvidia-current nvidia-current-modaliases nvidia-settings

When you restart your system, you should be greeted with the new Unity interface.

Install Ubuntu Tweak, which enables customising Ubuntu the way you like it, from the Software Centre, or through a PPA, as follows:

sudo add-apt-repository ppa:tualatrix/ppa
sudo apt-get update
sudo apt-get install ubuntu-tweak

Basic applications you should install

• GIMP
• VLC
• Chromium browser
• Multiget, a very nice and easy direct-downloads manager for Ubuntu
• Bleachbit, a system cleaner that cleans out all useless packages, freeing space on the root filesystem for better performance.

If there is something you want that is not available through Software Centre, you can still download it from the Web in .deb format, and open it with /usr/bin/gdebi-gtk (you must have gdebi and gdebi-core installed). A package installer window appears; hit “Install”, and it’s done.

I enjoyed the new improvements a lot. I suggest you take the plunge and see what’s available for you in Ubuntu Linux 11.04 “Natty Narwhal”.

GNU/Linux is not all work and no play. Not content with the creation of work software, the Free Software community has produced a rich selection of games, quite a few of which are as entertaining as their proprietary cousins.

Strategy games are perhaps the most imaginative and fun in the whole gaming repertoire. So are you new to strategy gaming? Fellow FOSS fan, just visualise chessmen on the board. Done? Now endow the chessmen with human life or magical powers. Put them into fantasy or historic story-lines. What you get is a strategy game. Just add a computer, and you get graphical effects to rival your own fertile imagination.

Allow such joys to unfold (after work) as you become a magician and put all comers to flame and sword in Glest. Populate the wild, wild American West and win independence from the British in FreeCol. Take the path of expansion and forge alliances or make war in FreeCiv. If peace, not war, gives you enjoyment, become an urban planner and tackle pollution to render your city idyllic, in LinCity. Here is entertainment that engages your capabilities to strategise. The best part is that all these brilliant games are free/libre software!

Pit magic against technology in Glest

Glest — Opposing factions summon dragons and golems to battle. Screenshot from the Glest website.

Set in a medieval era, Glest pits the minions of magic against those of technology. Whichever side you take (the other is played by the computer, or you could play with others over the Web), you’ll stockpile gold, wood and stone, maintain stocks of grain at all times, and raise a host of foot soldiers and cavalry, with reserves of armour and even flying contraptions, demons and dragons. In Glest, the rhythm is: when you are not fighting, build fighters. Finishing off opponents is the only objective (does it have to be?).

As for battles, tactically position individual soldiers or groups of them. Reconnoitre locations, lay ambush, block paths, organise battlefronts and cripple your enemy in subsequent skirmishes. In the meanwhile, try and grow your force as fast as you can, though casualties will pile up. Choose armoured or mounted fighters over unarmed foot soldiers.

Glest is just complex enough to be enjoyable. Certain fighting units require certain buildings to function. These buildings need natural resources. Natural resources need miners. But hey, soldiers are needed, too, to defend the fort during mining. And you’ll always find yourself short of time in this arms race. So, you have multiple pressures on resources, personnel and time.

How do you balance infrastructure construction with army recruitment? That is where strategic thinking is called for. The capability to quickly build a large army and to strategise in battle should lead to a win. Mind you, the Glest AI is designed to be hard to beat. You’ll need to browse the Glest manual on wikia (see below) for tips and tricks.

Unlike turn-based strategy games, Glest works in real time. It will make you think fast. There is no respite in Glest, which feels like work sometimes. Ah, but if only building magical creatures was work…
Glest is recommended for fantasy and medieval history buffs. You will also appreciate Glest’s decent 3D graphics and its quality animations, which are somewhat rare in GNU/Linux. And this game is not only stable, but also fast.

A disclaimer: Glest reduces your screen resolution to 1024×768. So reset the resolution every time you quit the game. But what’s a minor irritant like that when it comes with so much entertainment?
This game’s on-board tutorials will teach you the game in half an hour. Extensions and addons are on Glest’s website. Most big distributions carry the game in their software repositories; Ubuntu does. With 2 GB of RAM and a dual-core processor, the game is snappy.

More than the final results of playing this game, you enjoy the sensations of a world where magic exists and you communicate with fantastic creatures. And you won’t have to use your imagination: instead, watch dragons in action on your screen. But Glest should have had a bigger and greater storyline. Strategy games have the potential to rival the experience of fantasy-genre books. Surely the fantasy genre is about more than magical creatures and rampaging around. It’s fun, but is that enough?

Conquer the world with FreeCiv

FreeCiv: A civilisation with railroads, workers, machinery and un-upgraded swordsmen

If you search around the Web for FreeCiv, you’ll read of FreeCiv addiction. Strategy buffs can’t quit before FreeCiv is finished, which may amount to three to eight hours (surely the Save Game concept is real?). Maybe that is because FreeCiv has you making so many micro-level decisions, that its heart-warming graphics, its gripping complexity and its rich storyline keep you hooked at every turn.

FreeCiv has a rich story. It is based on the history of man. FreeCiv rewards you for exploring your continent. Sometimes you find advanced technology through exploration of unknown places; you’ll find villages to annex to your kingdom; or gold and friendly mercenaries. On the other hand, you might disturb a village full of hostile pirates! Meanwhile, multiple things are taking place in your kingdom.

In FreeCiv, terrain is king. Choose your sites for cities with a strategic eye, to sustain a balance between food production and natural resources. The coastal cities are good for maritime trade, but vulnerable to invasion. Forested sites are fine for harvesting raw materials but not necessarily for food production.

The better the terrain, the quicker the population grows. A growing population lets you build more cities, which speeds up the rate of scientific development and military power. Expand your kingdom further by colonising uninhabited territories, raise garrisons, optimise infrastructure production in cities, change tax rates, construct the wonders of the world (which confer manifold military and technological advantages) like the Hanging Gardens, the pyramids, Leonardo’s workshop and Isaac Newton’s college; fund research in literacy, trade, metallurgy, mathematics, physics, and naturally, build an even greater army and raise hell.

You do these things simultaneously! The unit of progress in FreeCiv is a turn; it is known as a turn-based strategy game. You shift multiple units in one turn. There are no tutorials with this game, but there’s an excellent help system.

Politics is crucial in FreeCiv. Strike alliances and keep the peace, share technology with allies, even exchange strategic cities. But note that the computer AI will revoke treaties even when you are not any threat to it. Keep upgrading your standing army. You might play other people online, which can be a violent experience by all accounts. Why can’t people just get along?

Win FreeCiv by shedding virtual blood, or, if your civilisation is sufficiently advanced, by designing a spaceship and sending it to the distant star of Alpha Centauri!

Though rich in graphics, FreeCiv does not offer 3D effects like Glest does. But when your imagination is harnessed, what difference does fancy graphics make? Being 2D, FreeCiv will run in 1 GB of RAM, though 2 GB is recommended.

FreeCiv is as much about exploration and discovery as about building and fighting. It gives you continuous thrills when your civilisation speeds up its technology development. Turn by turn, the game keeps you entertained. There lies its adventure-novel-like charm, and you’ll play it for hours on end.

Colonise America in FreeCol

FreeCol: A wagon train moves from a large manufacturing colony to a supporting ore-mining colony. Also seen are tribal villages and a rival's colony (in red).

Although FreeCol is far less complicated than FreeCiv, its historical storyline that’s based on colonisation will appeal to adults more. The remarkable game puts the player in the shoes of a sea-faring migrant to a new continent. (You won’t have to call the continent North America.) By far, FreeCol is more story-like than the previous games. You are the governor of a new colony. Again, explore the continent no Westerner has discovered, raise your colonies on prime locations, where farmland, lumber and ores are in plenty, and maintain a respectful distance from Apache, Inca, Arawak and other tribes, many of whom are less than happy at your arrival, and ultimately, make peace with them.

Of course, other Westerners want the country — so arm your settlers! And while some tribes like the Arawak and the Iroquois are friendly, and just wish to trade with you, the Apache and the Inca are excessively warlike, and might attempt extortion during hard times. Try making periodic gifts to them, and stay on their right side. Keep sufficient hi-tech weaponry like field cannons, to deal with the more hostile tribes and other colonial powers. Note that other colonial powers are more likely than the tribes to violate treaties with you.

In FreeCol, your ethics will be tested through your choices. Do you coexist with the tribes, or wage war against them? Do you extract tribute from them because you are more powerful? Do you respect their rights to their country, or run them off it? Trading with the tribes pays dividends in FreeCol. The tribes pay well for your goods, and no taxes go to the crown, which is raising an army against you.

FreeCol isn’t about mindless mayhem. Unlike most strategy games, FreeCol has the objective of winning independence from a colonial ruler. To do so, form an army and navy, and win the citizens’ support by establishing a rebel government. And while you’re at it, start newspapers and printing presses to stoke a pro-freedom feeling among your people!

FreeCol’s charm is in its fantastic possibilities of alternate history. The emotions it inspires, though, feel real.

Urban governance in non-violent Lincity

LinCity: Mines, a pottery workshop, a market and two residential buildings in a basic village

Technically, Lincity is not a game, but a simulation. But it’s a welcome breather after the slash-and-burn of the previous games, and it involves strategy. We’ve become a mature civilisation; now let’s make the city sustainable in Lincity. The game offers no opportunity to wage wars, since there is no military. Our foes are underdevelopment, unemployment and pollution.

Lincity is not as complicated as it looks. That is because it deals with urban concerns. Start with a blank board, with a single village or with an existing city with problems. Lincity offers you not only 3D graphics, but also sound effects that will evoke the hustle and bustle of industry, transport and city living. Your micro- and macro-management skills are tested in this real-time game. Ensure that your residential sectors are close to markets/job centres, healthcare facilities, education and civic amenities. Keep your polluting manufacturing sectors at arm’s length from residences. Match infrastructure development to income to keep the economy in the black. When you can, build a port and start exporting. Get cracking on your civic services, as your city progresses from the pottery age to the space age.

There are two ways to “win” Lincity: crafting a sustainable economy, or building a spaceship and settling another planet. With no wars or violence, Lincity charms you with its 3D cartoon-style evocation of the sights and sounds of that complex organism, the city.

Installation instructions

All these games are accessible by default through the software manager on your system. It’s straightforward to install the first three games. In your software manager, search for their names. In the case of Lincity, though, don’t install the package called lincity; install lincity-ng instead, and you’ll get the 3D graphics as promised. Note that these games are big downloads: Glest is about 55 MB, FreeCiv about 30 MB, FreeCol about 44 MB and Lincity about 51 MB.

Another thing: if Lincity is crashing, it’s probably due to a bug in the graphics driver on your system. Try updating to the latest driver or (shudder!) install the proprietary driver. Then donate a bit of green to the free software driver developers.

Enjoy!

While it’s a known fact that gaming choices on GNU/Linux are fewer than on Windows, how many games do you really need in order to have a great time? Fifty? You’ll find more than that on GNU/Linux. For a comprehensive list of games, refer to websites like linuxgames.com, tuxgames.com and happypenguin.org.

Technical note: To cure FreeCiv addiction — use the sudo apt-get install willpower command.