Step 1 for me was to just play with the core clock. I have my VRAM underclocked to 1/3 of the core clock – it is unneeded in bitcoin mining and running it fast only serves to create more heat. I nudged the core clock north, but hit a pretty hard wall around 816 MHz. I wasn’t going any further on this overclocking journey without applying a little more voltage to the GPU cores. However, all the overvolting tools for ATi are Windows-only! After extensive googling, I found a project that someone wrote to overvolt his/her Radeon 5850 – named [radeonvolt]. It didn’t quite work for me as-is, but after some hacking I was able to get the program to recognize both cores of each of my 5970′s, and change my core voltages successfully.

If you’re interested, click [here] to download a .patch file of my modifications. Otherwise, I will explain the few changes that needed to be made below.

1) Fix the card locating loop. Find the lines that look like this:

if(dev->device_class == PCI_CLASS_DISPLAY_VGA &&
dev->vendor_id == 0×1002 && dev->device_id == 0×6899) {

and change them to look like this:

if(dev->device_class == PCI_CLASS_DISPLAY_VGA ||
dev->device_class == PCI_CLASS_DISPLAY_OTHER) {

One GPU core registers as a VGA compatible controller, the other is just a “helper core” with no outputs, so it gets the DISPLAY_OTHER identifier. We also strip out the vendor and device ID checks – this allows us to attempt to probe the I2C bus of any video card detected. This appears safe still, I’ve tried the code with non-reference GPUs and nothing broke, the software properly reported it was incapable of modifying non-reference cards.

2) The radeon 5×70 cards, unlike the 5×50 cards (for which radeonvolt was originally written), use power profile slot #3 for high-performance, not slot #2. So, we just have a couple more changes to make. Find the line:

float voltage = vt1165_get_voltage(i2c, 2);

and change the “2″ to a “3″:

float voltage = vt1165_get_voltage(i2c, 3);

additionally, make a similar change on this line:

vt1165_set_voltage(&i2c, 2, value);

…should of course read…

vt1165_set_voltage(&i2c, 3, value);

And that’s all, folks. Compile, use, and enjoy. I was able to push my core voltage to anything I wanted, but with great power comes great responsibility. Running my core at 1.1125 volts, I have now achieved a rock-stable 900 MHz core clock. Just be sure to keep an eye on the VRM temperatures!

[root@localhost ~]# radeonvolt
Device [6]: Device 689c
Current core voltage: 1.1125 V
Presets: 0.9500 / 1.0000 / 1.0375 / 1.1125 V
Core power draw: 70.55 A (78.49 W)
VRM temperatures: 83 / 89 / 84 C

Device [7]: Device 689c
Current core voltage: 1.1125 V
Presets: 0.9500 / 1.0000 / 1.0375 / 1.1125 V
Core power draw: 63.58 A (70.73 W)
VRM temperatures: 115 / 114 / 113 C

Device [14]: Device 689c
Current core voltage: 1.1125 V
Presets: 0.9500 / 1.0000 / 1.0375 / 1.1125 V
Core power draw: 67.06 A (74.61 W)
VRM temperatures: 87 / 89 / 89 C

Device [15]: Device 689c
Current core voltage: 1.1125 V
Presets: 0.9500 / 1.0000 / 1.0375 / 1.1125 V
Core power draw: 66.19 A (73.64 W)
VRM temperatures: 108 / 108 / 111 C

I think that qualifies as a “milky color”. Yikes. Ok, so time to start pulling the engine apart to get to the head gasket. After about 4 more hours of labor and a few smashed arm incidents (those head bolts are tight!), I finally got the head off, and saw this:

Now, a lot of this coolant got in there while I was taking the head off, so it’s really not as bad as it seems. But, notice that cylinder #1 (leftmost) is slightly more full than the others. After drying the water out, the problem became much more apparent:

Yikes again! And so was it really the gasket? I inspected the head and didn’t find any cracks. Then, taking a closer look at the gasket, I found the problem:

So long story short, it was another 5 hours of labor to get everything back together into good working order. I think the total job ran me about $285, which isn’t bad considering I did pretty much an entire upper engine rebuild. That price includes new head bolts (which you should always do – if you reuse, they can snap. If they snap, you’re done), two oil changes, new exhaust manifold, more coolant, and all the associated gaskets.

Photo of the lake behind my apartment, the water is supposed to stop a few feet short of that fence you see sticking up.

The crushed stone is supposed to be a dam all the way across the end of the lake, with probably a good 10-foot drop-off. As you can see, the water does no dropping. Houses past this dam had at least two feet of water against their walls.

River, errr, Route 1. This is the view from the Route 95 overpass. Looking north, there were a few cars that had gotten stuck. The water was halfway up their windshields.

Run “adb shell” on a computer connected to the droid to enter these commands.

mv /data/local/12m /data/local/12m.bak
ln -s /data /data/local/12m

Now, reboot the phone. When it comes back up, adb shell into it again and run:

rm /data/local/12m
mv /data/local/12m.bak /data/local/12m
mv /data/local.prop /data/local.prop.bak
echo ro.sys.atvc_allow_netmon_usb=0 > /data/local.prop
echo ro.sys.atvc_allow_netmon_ih=0 >> /data/local.prop
echo ro.sys.atvc_allow_res_core=0 >> /data/local.prop
echo ro.sys.atvc_allow_res_panic=0 >> /data/local.prop
echo ro.sys.atvc_allow_all_adb=1 >> /data/local.prop
echo ro.sys.atvc_allow_all_core=0 >> /data/local.prop
echo ro.sys.atvc_allow_efem=0 >> /data/local.prop
echo ro.sys.atvc_allow_bp_log=0 >> /data/local.prop
echo ro.sys.atvc_allow_ap_mot_log=0 >> /data/local.prop
echo ro.sys.atvc_allow_gki_log=0 >> /data/local.prop

Reboot the phone again. When it comes back up, adb to it a third time, but this time notice that you have a root prompt! Setting atvc_allow_all_adb to 1 disallows adb from dropping its root privileges. Now, to make this accessible to the device, run:

mount -o remount,rw /dev/block/system /system
cat /system/bin/sh > /system/xbin/su
chmod 4755 /system/xbin/su

Now, go into the market and search for the “superuser” application. Install the one with the jolly-rogerish logo, then run it and have it install its su binary. Once that’s done, we need to remove the su application we created, so in the adb shell you still have open, run:

rm /system/xbin/su
mount -o remount,ro /dev/block/system /system
sync

That’s it! You’re all set. Enjoy having root on the droid 3!

1) No one is perfect
“Best practice” documents are generally written by an idealist. This person has the responsibility to make the product or technique about which they are writing perform optimally. This means there is very little consideration for outside variables. Points in best practice documents tend to be very black and white – Do this, do not do this other thing, etc. Yet, how often is it the case that a reader is concerned with making only one piece of a puzzle work flawlessly? The answer is a resounding “never”, it takes the other 499 pieces of the puzzle working in tandem as well to produce something worthwhile and appealing.

2) Context is key
While we’re on the subject of black and white bullet points, we should discuss context. While adhering directly to a “best practices” document, it becomes easy to miss apparent pitfalls right in front of you. The document might say, “XYZ should look like ABC.” It becomes increasingly easy to see only the fact that XYZ != ABC, and even easier to miss the circumstances that made XYZ a little different than ABC. As mentioned in point #1, the writer of the “best practices” document is concerned only with making XYZ the best it can be. Often it is the case, however, that the overall quality of a product can be increased by decreasing the effectiveness or simplicity of a single component in the equation. Hence, context really is everything.

3) Stagnation is an enemy
“Best practice” documents literally define the status quo. Anyone who uses the same product or technology that you use will have access to this document. Therefore, it follows that they will have the same setup, the same features, and the same problems as you. At this point, what sets you apart? Where is the innovation, the fresh ideas to shake up the ordinary? As I remember reading elsewhere, what would have happened if Google followed the search engine “best practices” set forth by Yahoo and Alta Vista? Where would Apple be today if they took pages from IBM’s book about personal computers? This all lends itself very nicely to the next point.

4) Opinions become squelched
Now suppose you or a member of your team has an idea that challenges something stated in the “best practices” document. Which do you follow? Who do you trust? Odds are that you or your team member has much more insight into the issue than a document. However, when adhering directly to one of these documents, it becomes way too easy to ignore the opposing opinions altogether and do what is recommended in the document.

Now, I’m not saying that “best practice” documents are complete garbage. Often they contain many helpful tips and tricks for getting the most out of whatever they are written about. Yet, it is important to remember they are not perfect. To summarize my feelings on the subject, context is everything, and if there’s one thing “best practice” documents lack, it is context.

There, I updated.

Basically, you’re going to need:
- Pandaboard
- 4+ gigabyte SD card (this is what I used, I’ll image a smaller card soon)

Features in the alpha version:
- Core system utilities
- Pandaboard wired and wireless network

Features planned for the beta version:
- Graphics
- Smaller SD card image

After a couple of hours of research, I found out a few things about my 1987 Oldsmobile Cutlass Ciera. For one, it has the tech-4 engine (sometimes incorrectly called the 4-tech). This is a later throttle-body injected version of the classic 1970′s GM Iron Duke Engine. 2.5 liters of displacement over 4 cylinders. The timing is set up in such a way that the cam and crank gears synchromesh together directly and are designed to be as simple as possible. Unfortunately, the gear that is likely to fail is on the camshaft, as it is a fiber-nylon mesh. This gear is hydraulically pressed on to the camshaft, making replacement difficult. However, it is not impossible – my Iron Duke is now running better than ever. Without further ado, I present the Iron Duke timing set in-car replacement!

Step 1 – Accessing the Timing Set.
1 ) Drain engine coolant. Some guides say to drain the oil and drop the oil pan – I found this step to be unnecessary as long as you let the oil drain to the bottom of the engine for a little while.

2 ) Remove the radiator overflow reservoir to clear some room to work. Your biggest enemy will be the lack of space between the engine and the chassis.

3 ) Remove the serpentine belt. The tensioner is on the engine block itself and is spring loaded – just push it back with a prybar to release.

4 ) Remove the crankshaft bolt and crankshaft pulley. The bolt isn’t that difficult to break free, but this step will probably require a friend’s help.

5 ) Remove the power steering pump. There are 3 bolts you need to take off. You will begin to hate this job when you realize one of the bolts is on the bottom of the pump. You must rotate the pump’s pulley and use the access holes provided to get to the 3 bolts. I tried using a universal joint and a 1-foot extension on my 3/8ths ratchet to get the bottom bolt, the u-joint just broke. I found the best method to be a 1/4″ ratchet with a long socket, plus a little persuasion from Mr. Hammer. You do not need to disconnect all the lines to the pump or drain the system, just lay it aside once it is free.

6 ) Remove the tensioner assembly. There are, again, 3 bolts holding this onto the engine. When you remove this assembly, a hole in the engine block will appear, so I seriously hope you followed step #1.

7 ) Remove the timing cover. There are 8 bolts in total that need to be removed. Then, using a razor blade or some such, slice the gasket between the timing cover and the oil pan. The timing cover will now come off easily by hand.

Step 2 – Replacing the gear.
8 ) Get a new timing gear (or two). I’m assuming you’ve now seen something similar to the picture above under your timing cover. [A new fiber gear runs about $30 on RockAuto.com.] I’ve heard of some people using all-metal gears, but I have my reservations about that. The fiber gear lasts well over 100,000 miles – a longer timing maintenance interval than most cars on the road today. Using pure metal will undoubtedly be louder, and may put the engine at risk when it fails. Shards of metal tend to be much less forgiving than shards of fibrous nylon. All proper documentation will tell you to replace the crankshaft timing gear while you’re in there. I don’t see why not, the crank gear comes on and off by hand. But, the engine is designed so that the fiber gear takes all of the abuse, so if you wanted to save some money and only replace the camshaft gear, you wouldn’t be the first person to get away with doing so.

9 ) Now comes the hard part, removing the old camshaft gear. Traditional service manuals will tell you to either pull the engine, or drop it in its cradle. I’m assuming you can’t or don’t want to do this – it’s ok, I didn’t want to, either. To evade a gigantic pulling process that requires special tools, drilling/tapping holes, and all-around suckiness, break the fiber off of the metal piece in the middle of the gear (the gear hub). Be extremely careful not to break the camshaft cover behind the gear – it is very fragile. Also be sure not to tap on the camshaft in any way. Doing so will lead to oil leaks at the rear-end of the engine. Then, using a dremel tool and a diamond bit, carve a hole in the middle of the hub. This process took me about 3 hours.

10 ) Clean up the mess you made. If you scored the camshaft while using the dremel, no big deal, just polish it up and remove any metal burrs that you may have created. The camshaft needs to be as smooth as possible to accept the new press-fit gear. Give the camshaft a good coat of oil as well to prevent rust under the gear. You will see that there is not a lot of room available:

11 ) Now the really hard part – getting the new gear on. The most back-asswards way of doing this is to torch up the hub on the new gear to expand it, then quickly slide it onto the camshaft. It’s a great idea in theory, but can easily damage the fibrous gear. I decided to go this route anyway for lack of a suitable timely alternative. It worked about 3/4ths of the way for me, then the hub cooled too much and I was stuck with a camshaft gear that wasn’t totally on the camshaft. I attempted to torch the hub for 5 minutes with a blue flame. If I was going to do this job again, I would torch the hub for 10 minutes and be much quicker about getting it onto the camshaft. Luckily, [my brother] happened to own a [10-ton Porta-Power], which has a [2" press attachment.] After my error, I had about 2.25″ of clearance. Phew! If you’re going to use the porta-power (which you may be able to rent), be sure to brace the backside of the engine, otherwise the porta-power will just push the whole thing over. I had fantastic results with this – the gear literally slammed into place with very little effort.

12 ) Timing. This is important. There is a dot in one of the troughs on the camshaft gear, and a dot on one of the teeth of the crankshaft gear. Make the two dots touch and you’re all set! Easy peasy.

Step 3 – Reassembly and other tune-ups.

13 ) Put the timing cover back on, be sure to use a healthy amount of RTV along the mating surfaces between the timing cover and the oil pan. Leaks here would be bad, mmmk?

14 ) The rest of the assembly process is the reverse of step 1. Putting the 3rd bolt back into the power steering pump is way easier than taking it out. Start it by hand, then use a universal joint and a long extension. It works going back in because you can rest the joint against the suspension column, as opposed to just slipping off when attempting to remove the bolt.

15 ) There are a number of additional tune-ups you should perform while your engine is disassembled. I replaced the coolant, oil, oil filter, air filter, MAP sensor, EGR valve, serpentine belt, crankshaft oil seal, spark plugs, spark plug wires, and I added a cleaning agent to my crank case and fuel tank. I used a product called SeaFoam – works really well and can be added to pretty much anything.

At this point, your Iron Duke is ready for another 100k+ miles. This whole process took me about a week to complete, but if I had to do it a second time, I think I could accomplish the deed in two days. Just make sure to have all the tools you need ahead of time!

Enter puppet as, once again, the perfect solution to this dilemma. We start by creating a shell script to compile all of the SELinux .te files in a specific directory. This script gets put onto everyserver, a class we have which defines our standard build.

As a note, we define ${puppetfilespath} to be /var/lib/puppet/files, and ${cls} is set at the top of each class, defining class-local-storage, or the location where puppet can expect to find the fake-root for the current class.

[root@puppet ~]# cat /var/lib/puppet/files/everyserver/usr/bin/compile_selinux.sh
#!/bin/bash
MODDIR=/etc/selinux/mymodules

CHKMOD=/usr/bin/checkmodule
MODPKG=/usr/bin/semodule_package
SEMOD=/usr/sbin/semodule
LS=/bin/ls

for i in $(${LS} -1 ${MODDIR}/*.te); do
j=${i/te/mod};
${CHKMOD} -M -m -o ${j} ${i};
k=${i/te/pp};
${MODPKG} -o ${k} -m ${j};
${SEMOD} -i ${k};
done

Note that this script can take a while to complete, as the last command (semodule -i) installs the compiled module, and this usually takes a good 30-60 seconds to complete.

Now we need to manage this new script and the directory it needs using puppet:

file {
“/etc/selinux/mymodules”:
ensure => directory,
mode => 600;
“/usr/bin/compile_selinux.sh”:
content => template(“${puppetfilespath}/${cls}/usr/bin/compile_selinux.sh.erb”),
mode => 755,
require => File["/etc/selinux/mymodules"];
}

Then we need to define a exec in puppet for this script to be run:

exec {
“repackage-semods”:
command => “/usr/bin/compile_selinux.sh”,
cwd => “/tmp/”,
refreshonly=>true;
}

To make our lives easier, we define a simple custom type that runs this exec after a change is detected:

define myselmod()
{
file { $name:
owner => root,
group => root,
mode => 600,
path => “/etc/selinux/mymodules/${name}”,
notify => Exec["repackage-semods"],
require => File["/etc/selinux/mymodules"],
content => template(“${puppetfilespath}/${cls}/etc/selinux/mymodules/${name}.erb”)
}
}

Now, in the manifests, you need only do this to manage a custom SELinux module:

myselmod {“mybasicmodule.te”: }

And in that file:

[root@puppet ~]# cat /var/lib/puppet/files/everyserver/etc/selinux/mymodules/mybasicmodule.te.erb
module mybasicmodule 1.0;

require {
type snmpd_t;
type proc_mdstat_t;
class file { read ioctl getattr };
}

#============= snmpd_t ==============
allow snmpd_t proc_mdstat_t:file { read ioctl getattr };

Now suppose you want to add another SELinux rule to this module. All you need to do is edit the .te file and add in the rule you want. Then the client will check in and automatically compile and install the module for you. Really simple! Plus, another advantage is that this method now uses only text-files as opposed to binary data blobs, which is perfect for integration with your versioning system (if you use one). In fact, this is the original reason I decided to use this method over the built-in puppet semodule type. Dealing with .te files only is insanely easy, and takes a lot of the headache out of administering custom SELinux modules across an infrastructure, thus making everyone more likely to actually use SELinux rather than just disable it or put it into perpetual permissive mode.