The apparent origins of some odd limitations in the iSCSI protocol

The iSCSI protocol has some odd features and defaults; yesterday I grumbled about how InitialR2T defaults to 'yes',for example. In many ways it is not the sort of protocol that you woulddesign if you were going to do a TCP-based remote block access protocol,even setting aside the idea of transporting SCSI commands across thenetwork.

Now, I wasn't there at the time, so I have no idea what the realreasons were for these protocol decisions; all I can do is


Our likely iSCSI parameter tuning

Now that I have some idea of what the various iSCSI parameters do andcontrol , I can think about how we mightwant to change them. The necessary disclaimer is that at the moment, allof this is theoretical, not tested and validated and useful.

My general belief is that our IO load is mostly reads and is somewherebetween truly random and short sequential reads (ie, sequential readsof short files). I expect that most of our writes are asynchronous,but some of them are synchronous as ZFS commits


Understanding the iSCSI protocol for performance tuning

We'd like to improve the performance of our iSCSI SAN (who doesn't, really?). iSCSI has abunch of tuning parameters with names like 'InitialR2T', but in orderto sensibly touch those you need at least enough knowledge of the iSCSIprotocol to get yourself into trouble. So I have been digging into iSCSIand thus into SCSI, and now I feel like writing down what I've learnedand worked out before it all falls out of my head again.

(You


How CPython implements __slots__ (part 2): access

In the first part I covered how the __slots__ instance attributes were stored (in an ad-hoc array of pointers thatis glued on the end of instance objects), but that's only half of thepuzzle. The other half is letting people access them, and that's whatthis entry is about.

As it happens, it's reasonably common in CPython for C-level types towant to give people Python-level access to fields in C structures,common enough that


Some notes on what __dictoffset__ on types means in CPython

I mentioned __dictoffset__ in passing in HowSlotsWorkI . Today I feellike expanding on that passing mention with some notes. All of this isspecific to CPython.

As mentioned in passing in HowSlotsWorkI , the __dictoffset__ attribute tells you the offset to where you find the pointer to the __dict__ object in any instance object that has one. It is inbytes. A positive value is an offset from the start of the object; anegative value is an offset from the end


Mail rejection stats for our external mail gateway

In my recent spam filtering stats ,I noted that some spam was rejected before it made it to the spamtagging and filtering system. Well, here's some stats on roughlythat; specifically, on how much email our external mail gateway rejects at SMTP time forvarious reasons. The numbers here are for almost the same seven daytime period as the previous stats; there is about a six and a half hourdifference in coverage due to when the two systems roll their logs (onedoes it at midnight,


A quick look at some spam filtering stats from our system

It's been a while since I thought about generating statistics aboutwhat our anti-spam systems are doing and seeing, which probably meansthat it's about time to do it again. I'm going to look at the pastweek's statistics, mostly because we upgraded the spam filtering machinerecently and we don't have old logs any more. Unfortunately this is notan ideal week to look at, since Friday was a holiday here so the numbersare going to be down from usual.


An important note about multi-line log message formats

I was vaguely planning to write a blog entry using some current statsfrom our anti-spam system (either 'how many connections were on theSpamhaus Zen' or 'how correlated is the results of the Spamhaus Zenand our commercial filtering software'). Then I went and looked at theformat of the logs from our mail system, which it turned out were notset up to make this at all easy.

In our configuration, Exim logs a warning message when a connectionfrom a DNSBL-listed IP address


Notes to myself on the priorities of Linux routing policy rules

Linux's policy based routing is done by writinga set of rules about what routing to do under various circumstances;this is implemented by ' ip rule ' (and kernel code, of course). Allpolicy rules have a priority, and rules are examined in priority order(low to high). Historically, I've given each rule a different priority(related rules get priorities that are close to each other). However,this is not required and I've come to think that it'


The Upstart dependency problem

We just ran into another issue with how Upstart handles startupscripts. The simple way to put it is that Upstart glues together thestartup script itself and ordering dependency information on when itneeds to be run. This is a problem because the startup script is 'owned'by the package but dependencies can be system dependent, which meansthat local sysadmins need to change them.

(This is similar to the previous Upstart coupling problem .)

Now, the old /etc/init.d system didn't exactly have