As Wolfgang Lonien recently pointed out , Solaris isn't the only systemwith ZFS, as you can also get it in at least FreeBSD. Despite theseports, I believe that Solaris generally remains your only solid choiceif you need ZFS.

The problem is that ZFS is currently incomplete, with both missingfeatures and significant problems . Thismeans that the work of integrating ZFS into other systems is notcomplete, and there are two potential issues with the remaining work.

The first is the most straightforward: you are taking

Here's something that I've seen illustrated more than once : layering buffering on top ofbuffering is almost always a bad idea .

One of the reasons is that it can be tricky to write a correct version.For example, consider all the things that you have to get right if youwrite a file IO buffering layer on Unix, including:

• you must remember that you've seen an EOF, and return this indicationto the next level up without doing another underlying read() .
• you must return

In an earlier entry I mentioned that theLinux kernel takes the top 1 gigabyte of a process's address space foritself. In fact this is not just address space that the kernel reservesfor its own use; the entire kernel itself actually lives in the topgigabyte of every process's memory map.

(You can't read it or run it because it is protected address space,accessible only when the system is in kernel mode, except for the VDSOit exports to processes these days.)

The

Courtesy of having an Eee around and being curious about how to maximizethe battery life, here are some measurements about what bits seems touse how much power. All of these measurements are for a '4G Surf' model;your mileage may vary on other ones.

First, a disclaimer: all of these measurements are made with a powermeter while the Eee was on wall power. It's possible that the Eeebehaves differently when running on battery power (although I wouldbe somewhat surprised).

Here's something from my previous entry thatI should clarify: lab notebooks are not changelogs .

Lab notebooks and changelogs are two different things. Lab notebooksare scribbled at the time for yourself, and should includeeverything. Changelogs are written after the fact for other people, andshould include only the things that actually turned out to matter.

In other words, changelogs are the sysadmin equivalent of lab reportsand scientific papers. You can no more use a lab notebook as a changelogthan you could submit a lab notebook

Yesterday, a coworker and I were working on a performance issue we'rehaving with our new SAN RAID controller. We had a hypothesis about whatmight provoke the problem, so we sat down, fired up some tests, andwatched our logs; nothing showed up. Later on in the day, we saw someodd indications in other logs and wanted to see if they correlated withthe tests we'd done, but you can already guess the punchline: we hadn'trecorded when we started and stopped

Like most organizations, the university has what I call administrativemanagement systems , the computers thathandle core business record keeping like payroll, accounts payableand receivable, HR, and (this being a university) crucial studentinformation like enrollment and marks. This is serious stuff, runusing expensive software on expensive databases on expensive hardware(and behind paranoid firewalls), and, like most places, is considered apretty crucial thing.

But it turns out that it has quietly become not the most crucialsystem the university runs.

Over the course of the Python code that I've written, I've noticedcertain patterns that seem to reoccur relatively frequently. One ofmy common ones is a pattern that I'll call the Mutating Proxy.

Python doesn't have much use for plain proxy objects, objects thatjust relay things to another one, since duck typing means that you canusually just use the original object instead. A mutating proxy is aproxy that's used in order to change the behavior of the underlyingobject,

One of the things that irritate me about ZFS is the interactionbetween snapshots and quotas, specifically that ZFS snapshots countagainst a filesystem's quota. I can only call this robot logic ; it is in a sense completely correct and itprobably simplifies the implementation, but it is not useful .

The problem is that snapshots are a system level thing; having themcount against user quotas is a problem waiting to happen. Considertrying to explain to a user that they have 'run out' of disk spacebecause the