There are a number of events going on around WWDC this year. Brandon Kwaselow has the most comprehensive list I’ve seen so far, it even includes Three Wolf Tuesday!

WWDC Parties/events – WWDC 2009 – Brandon “Quazie” Kwaselow’s Blog.

Google Calendar with the events:

The solution is to use socat along with Unix98 pseudo-terminals (/dev/pts/*).

I set up the Virtual Machine to “Use named pipe”, “This end is the client”, “The other end is an application”, and “Yield CPU on poll”. I put the pipe in /export/vmware/DUT.serial0.

At host startup I run the following socat command using start-stop-daemon:

# start-stop-daemon --start --pidfile /var/run/socat.DUT.pid \
    --background --make-pidfile \
    --exec /usr/bin/socat -- \
    -ly -d -lpsocat:DUT \
    PTY,b115200,raw,link=/dev/ttyDUTSerial0,group=uucp,mode=660 \
    UNIX-LISTEN:/export/vmware/DUT.serial0,fork,owner=frank,group=frank,mode=755

DUT is a placeholder for the virtual machine’s name.

I can then make a minicom config using /dev/ttyDUTSerial0 for the serial port and work as usual.

The above is actually wrapped up in some Gentoo init scripts.

In /etc/conf.d/socat I have:

# socat configuration

# add dependencies to socat_use, socat_need, socat_before, and socat_after
socat_use="net"

# Common args used for all invocations. This is an Array.
#
# -ly : log to syslog
socat_args=( -ly -d )

# Configurations to auto-start. This is an Array.
socat_autostart=( WCBSerial0 )

# Lists of arguments for each configuration. These are arrays to better support
# embedded spaces in arguments.
socat_WCBSerial0=(
	"PTY,b115200,raw,link=/dev/ttyWCBSerial0,group=uucp,mode=660"
	"UNIX-LISTEN:/export/vmware/WCB.serial0,fork,owner=frank,group=frank,mode=755"
)

socat_WCBSerial1=(
	"PTY,b115200,raw,link=/dev/ttyWCBSerial1,group=uucp,mode=660"
	"UNIX-LISTEN:/var/run/vmware/WCB.serial1,fork,group=uucp,mode=755"
)

and in /etc/init.d/socat I have:

#!/sbin/runscript
# Copyright 2008 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/sys-libs/gpm/files/gpm.rc6,v 1.12 2004/07/15 01:02:02 agriffis Exp $

#NB: Config is in /etc/conf.d/socat
autostart_count=${#socat_autostart[@]}
socat=${socat:-/usr/bin/socat}

depend() {
	local t a
	for t in $deptypes $ordtypes ; do
		a="socat_${t}"
		a="${!a}"

		[ -n "$a" ] && $t $a
	done
}

checkconfig() {
	local i a n name

	for (( i=0; i< $autostart_count; i++ )) ; do
		name=${socat_autostart[$i]}
		a="socat_${name}[@]"
		a=( "${!a}" )
		n=${#a[@]}

		if [ $n -lt 2 ] ; then
			eerror "Too few args ($n) for socat.$name (${a[*]})"
			return 1
		fi
	done
}

start() {
	checkconfig || return 1

	local i a n name extra

	for (( i=0; i<$autostart_count; i++ )); do
		let n=i+1
		name=${socat_autostart[$i]}
		a="socat_${name}[@]"
		a=( "${!a}" )

		ebegin "Starting socat config $name ($n of $autostart_count)"
		#echo $socat "${socat_args[@]}" -lpsocat:$name "${a[@]}"
		start-stop-daemon --start --pidfile /var/run/socat.$name.pid \
			--background --make-pidfile \
			--exec $socat -- \
			"${socat_args[@]}" -lpsocat:$name "${a[@]}" \
			< /dev/null
		eend ${?}
	done
}

stop() {
	local i n name

	for (( i=0; i<$autostart_count; i++ )); do
		let n=i+1
		name=${socat_autostart[$i]}

		ebegin "Stopping socat config $name ($n of $autostart_count)"
		start-stop-daemon --stop --pidfile /var/run/socat.$name.pid \
			--exec $socat
		eend ${?}
	done
}

find /export -type f -print | perl -ne 'chomp; $count++; $total += (stat())[7]; END { print "$count files $total bytes total ", $total/$count, " byte average\n"; }

After running this, I was surprised at just how large the “average” size was, which led me to wonder just which average they were looking for here: mean or median? While I was at it, I decided to calculate the mode as well.

The one-liner evolved to:

find /export -type f -print | perl -ne 'chomp; $count++; $size = (stat())[7]; push @sizes, $size; $total += $size; $sizes{int(($size+511)/512)}++; print "$count\r" if ($count % 2048 == 0); END { $median = (sort @sizes)[$#sizes / 2]; $mode = 512 * (sort { $sizes{$b} <=> $sizes{$a} } keys %sizes)[0]; print "$count files $total bytes total ", $total/$count, " byte mean $median byte median $mode byte mode\n"; } BEGIN { $| = 1; }'


We can make this a bit more legible:

find /export -type f -print | perl -ne '\
      chomp; \
      $count++; \
      $size = (stat())[7]; \
      push @sizes, $size; \
      $total += $size; \
      $sizes{int(($size+511)/512)}++; \
      print "$count\r" if ($count % 2048 == 0); \
BEGIN { $| = 1; } \
END { $median = (sort @sizes)[$#sizes / 2]; \
      $mode = 512 * (sort { $sizes{$b} <=> $sizes{$a} } keys %sizes)[0]; \
      print "$count files $total bytes total ", $total/$count, \
            " byte mean $median byte median $mode byte mode\n"; }'

Let’s take it line by line. First, the shell pipeline find /export -type f -print | perl -ne 'stuff' recursively descends into the /export directory and prints the names of all regular files found, one per line. This output is piped into Perl, which processes the commands in the -e 'stuff' block once per line due to the -n flag.

The heavy lifting is done in the Perl program:

Gathering the Information

chomp; strips the trailing newline from the input line.

$count++; counts the number of lines.

$size = (stat())[7]; gets the size in bytes of the input file.

push @sizes, $size; saves the size in a list of all file sizes seen.

$total += $size; adds up the total number of bytes seen.

$sizes{int(($size+511)/512)}++; converts the size in bytes into a size in 512-byte blocks, and counts the number of files with a given block count. This creates a histogram of file sizes using 512-byte bins.

Showing Progress

print "$count\r" if ($count % 2048 == 0); prints a progress indication for every 512 files processed.

BEGIN { $| = 1; } is a BEGIN block, which means it is executed once at the beginning of the program. It sets the perl built-in variable $| to a true value, so that output is displayed immediately. With out this, the progress indication would not print until it had been output hundreds of times.

Calculating Results

Results a reported in the END {} block, which, as you may guess, is executed once at the end of the program. It starts with a few calculations:

$median = (sort @sizes)[$#sizes / 2]; sorts the list of sizes seen (sort @sizes), the selects the middle item from the sorted list ($#sizes is the index of the last element in the list, we use half of that as the index to get the middle element).

$mode = 512 * (sort { $sizes{$b} <=> $sizes{$a} } keys %sizes)[0]; calculates the mode (the most frequently-occurring item). Working from the inside out, keys %sizes gets a list of the keys from the %sizes hash. Then sort { $sizes{$b} <=> $sizes{$a} } keys %sizes sorts those keys by hash value in descending order, so that the most-frequently occurring element comes first. The first element is accessed at index 0, then multiplied by 512 to convert back to bytes.

Sorting The Data: The sort is done by passing a custom comparison routine { $sizes{$b} <=> $sizes{$a} } to the built-in sort function.

Perl’s sort will call this routine repeatedly with pairs of list elements in $a and $b. The routine should return 0 if the elements are equal, less than 0 if $a should come first, or greater than 0 if $b should come first.

The default comparison is $a <=> $b, which is a lexical sort. Since out data is numeric, we could use the equivalent $a <=> $b, which in this case would sort the list in ascending order by size. Reversing the comparison to $b <=> $a sorts in descending order by size. Finally, using the hash values rather than the keys sorts by frequency of occurrence.

Output Results

Now it’s a simple matter of displaying the results:

print "$count files $total bytes total ", $total/$count, " byte mean $median byte median $mode byte mode\n"; }'

SUBSYSTEM=="net", DRIVERS=="?*", ATTRS{address}=="00:0c:29:0b:02:d2", NAME="eth0"

These seemed to be silently ignored.

After an emerge --sync; emerge -u world last night, the vmware devices started getting IDs following the highest-numbered eth device. These rules would be added to 70-persistent-net.rules, and on the next boot the devices would move up even higher, causing all network device config settings to be ignored.

I noticed that the new rules added to 70-persistent-net.rules were of the form:

SUBSYSTEM=="net", DRIVERS=="?*", ATTR{address}=="00:0c:29:0b:02:d2", NAME="eth0"

(ATTRS was replaced with ATTR), which just means the match is done on the specific node rather than checking all of the parents.

After a lot of painful attempts to fix this, I finally found the problem. Apparently the DRIVERS key is unset at this point for the vmxnet driver. I removed that test, so that I have:

SUBSYSTEM=="net", ATTR{address}=="00:0c:29:0b:02:d2", NAME="eth0"

which now works.

Phew!