ArChr

#!/bin/bash
# ArChr: a tool to help install Arch Linux on a Chromebook without support for BIOS/legacy boot.
# This code is public domain. No warranty of any kind is expressed or implied.

if [[ $EUID -ne 0 ]]; then
    echo "This script must be run as root."
    exit 1
fi

# This definitely won't run on a 32-bit system or an ARM.
if [[ `uname -m` != "x86_64" ]]; then
    echo "This script only works on x86_64."
    exit 1
fi

RUNPATH=`readlink -f .`
KERNEL=`uname -r`
echo "Installing Chrome OS kernel $KERNEL to $RUNPATH..."

# Make sure the root directory exists. Normally we don't care whether directories exist, but if this isn't here then you're definitely in the wrong place.
if [ ! -d root ]; then
    echo "Root directory doesn't exist. Are you running this in the directory your Arch install is mounted?"
    exit 1
fi

# Look for Chrome OS utilities. cgpt and vbutil_kernel are needed. Other utilities are optional but will be copied if they exist in the same directory.
CHROMEBIN_DIR=/usr/bin/old_bins
# This was the contents of /usr/bin/old_bins on my system:
CHROMEBINS=( cgpt chromeos-tpm-recovery common_minimal.sh crossystem dev_debug_vboot dev_sign_file dumpRSAPublicKey dump_kernel_config enable_dev_usb_boot gbb_utility make_dev_firmware.sh make_dev_ssd.sh resign_firmwarefd.sh set_gbb_flags.sh tpm-nvsize tpm_init_temp_fix tpmc vbutil_firmware vbutil_kernel vbutil_key vbutil_keyblock vbutil_what_keys )
if [ ! -x $CHROMEBIN_DIR/cgpt -o ! -x $CHROMEBIN_DIR/vbutil_kernel ]; then
    # If old_bins doesn't exist, use which to locate them.
    # We search old_bins first because if they ARE in old_bins, the scripts returned by "which" are something different and won't work.
    CHROMEBIN_DIR=`dirname $(which cgpt 2>/dev/null) 2>/dev/null`
    if [ ! -x "$CHROMEBIN_DIR/cgpt" -o ! -x "$CHROMEBIN_DIR/vbutil_kernel" ]; then
        # If they still weren't found, bail.
        echo "Chrome OS binaries not found (need cgpt and vbutil_kernel)."
        echo "Did you forget to exit your chroot?"
        exit 1
    fi
fi
echo "Found chrome binaries in $CHROMEBIN_DIR."

# We also need dev key files from /usr/share/vboot/devkeys (or /usr/share/chromeboot in the Arch install). I don't know of any other place to find these, so give up if they're not there.
CHROMEDEV_DIR=/usr/share/vboot/devkeys
CHROME_DEVKEYB=$CHROMEDEV_DIR/kernel.keyblock
CHROME_DEVPRIVK=$CHROMEDEV_DIR/kernel_data_key.vbprivk
if [ ! -f $CHROME_DEVKEYB -o ! -f $CHROME_DEVPRIVK ]; then
    CHROMEDEV_DIR=/usr/share/chromeboot
    CHROME_DEVKEYB=$CHROMEDEV_DIR/kernel.keyblock
    CHROME_DEVPRIVK=$CHROMEDEV_DIR/kernel_data_key.vbprivk
    if [ ! -f $CHROME_DEVKEYB -o ! -f $CHROME_DEVPRIVK ]; then
        echo "Couldn't find developer keys. Sorry."
        exit 1
    fi
fi
echo "Found developer keys in $CHROMEDEV_DIR."

# Final sanity check: make sure modules and firmware are present.
MODPATH=/lib/modules/$KERNEL
if [ ! -d "$MODPATH" ]; then
    echo "$MODPATH not found. Sorry."
    exit 1
fi
echo "Found kernel modules in $MODPATH."
FWPATH=/lib/firmware
if [ ! -d "$FWPATH" ]; then
    echo "$FWPATH not found. Sorry."
    exit 1
fi
echo "Found linux firmware in $FWPATH."

# A standard regex to separate drives from partitions.
PARTREGEX='([0-9a-z_/]*[a-z_/])([0-9]+)$'

# Try to find out which kernel partition we're running. It should be 16MB in size and located right before the / partition.
# Check the output of mount first.
ROOTDEV=`mount | grep " on / type " | head -1 | cut -d' ' -f1`
KERNDEV=""
if [[ $ROOTDEV =~ $PARTREGEX ]]; then
    KERNDEV=${BASH_REMATCH[1]}$((${BASH_REMATCH[2]} - 1))
    [[ `lsblk "$KERNDEV" --output=size 2>/dev/null | tail -1 | tr -d ' '` != "16M" ]] && KERNDEV=""
fi
# If that didn't do it, try to find the device of / from lsblk.
if [[ $KERNDEV == "" && `lsblk --output=name,mountpoint | grep '/$' -B 1 | head -1 | cut -d' ' -f1` =~ $PARTREGEX ]]; then
    KERNDEV=/dev/${BASH_REMATCH[1]}$((${BASH_REMATCH[2]} - 1))
    [[ `lsblk "$KERNDEV" --output=size 2>/dev/null | tail -1 | tr -d ' '` != "16M" ]] && KERNDEV=""
fi
# If it wasn't found, ask the user to find the kernel.
lsblk
if [[ $KERNDEV == "" ]]; then
    echo "Kernel partition wasn't auto-detected; you'll have to type it yourself. It should be a 16MB partition in the above list (hint: try to find the partition above the one mounted as /)"
    echo "Kernel device path (e.g. /dev/mmcblkXpX): "
    read KERNDEV
    [[ KERNDEV == "" ]] && exit 0
else
    echo "Your kernel seems to be in $KERNDEV. If that's not right, type its device path now: "
    read KERNDEV2
    [[ $KERNDEV2 != "" ]] && KERNDEV=$KERNDEV2
fi

# Ask the user which partition they're installing to.
LINUXDEV=`mount | grep " on $RUNPATH type " | head -1 | cut -d' ' -f1`
if [[ $LINUXDEV == "" ]]; then
    echo "WARNING: Auto-detecting the Arch partition failed. Please make sure you're running this script in the root directory of your Arch install and that you have it mounted properly."
    echo "Enter the device path (e.g. /dev/mmcblkXpX) for your Arch install: "
    read LINUXDEV
    [[ $LINUXDEV == "" ]] && exit 0
else
    echo "Your Arch install seems to be in $LINUXDEV. If that's not right, type its device path now: "
    read LINUXDEV2
    if [[ $LINUXDEV2 != "" ]]; then
        LINUXDEV=$LINUXDEV2
        echo "NOTE: You should be running this script from the root directory of your Arch install. If the device you just saw was your USB or your Chrome OS partition, you're in the wrong place."
    fi
fi
# Apply the same logic as before to check for the kernel partition.
LINUXKERNDEV=""
[[ $LINUXDEV =~ $PARTREGEX ]] && LINUXKERNDEV=${BASH_REMATCH[1]}$((${BASH_REMATCH[2]} - 1))
if [[ $LINUXKERNDEV == "" || "`lsblk "$LINUXKERNDEV" --output=size 2>/dev/null | tail -1 | tr -d ' '`" != "16M" ]]; then
    echo "Enter the device path (e.g. /dev/mmcblkXpX) for your Arch kernel: "
    read LINUXKERNDEV
    [[ $LINUXKERNDEV == "" ]] && exit 0
else
    echo "Your Arch kernel seems to be in $LINUXKERNDEV. If that's not right, type its device path now: "
    read LINUXKERNDEV2
    [[ $LINUXKERNDEV2 != "" ]] && LINUXKERNDEV=$LINUXKERNDEV2
fi
# Make sure we can separate the partition no. from the disk for this device. It's important for chromeboot later.
if [[ ! $LINUXKERNDEV =~ $PARTREGEX ]]; then
    echo "I don't understand the partition layout on that disk. Sorry."
    exit 1
fi

# Look for arch-chroot in the current directory, unless this is running from the Arch install, in which case it's not needed. If the utility isn't found, ask the user where it is.
ARCH_CHROOT=usr/bin/arch-chroot
if [ "$RUNPATH" != "/" -a ! -x $ARCH_CHROOT ]; then
    echo "arch-chroot not found in usr/bin. Please enter its location (e.g. /media/USB/usr/bin): "
    read ARCH_CHROOT
    ARCH_CHROOT=`readlink -f $ARCH_CHROOT/arch-chroot`
    [ ! -x $ARCH_CHROOT ] && exit 0
fi

# Ask if ArChr should be installed on the new partition.
SELF=`readlink -f $0`
echo "Copy this script to the disk? Enter the full pathname (e.g. \"/root/archr.sh\") or hit Enter to skip: "
read SELFINST

# Done preparing! Confirm with the user that they're ready to start.
echo "Ready to install! Press Ctrl+C to cancel or Enter to begin."
read

# Copy self if requested.
if [[ $SELFINST != "" ]]; then
    SELFINST="./$SELFINST"
    mkdir -p "`dirname \"$SELFINST\"`"
    cp "$SELF" "$SELFINST"
fi

# Use /proc/cmdline as a basis for the parameters for the new kernel. This helps the new install work better and avoids some kernel panics.
# However, remove the dm parameter, replace the root, change the ro mode to rw, and bring back the console (seeing a black screen until the TTY starts up is scary).
CMDLINE=`cat /proc/cmdline | sed -e 's/ dm=".*"//;s/ dm[^ ]*=*//g;s|root=[^ ]* |root=$PART_ROOT |;s/ ro / rw /;s/console= //'`

# Copy the existing kernel partition to the new kernel partition. We'll run chromeboot-update later to finalize it.
if [[ $KERNDEV != $LINUXKERNDEV ]]; then
    echo "Copying kernel partition..."
    dd if="$KERNDEV" of="$LINUXKERNDEV" >/dev/null 2>&1
    [ $? -ne 0 ] && exit $?
else
    echo "Source kernel is the same as destination, skipping copy."
fi

# Make a package for the linux kernel, linux firmware, and the new utilities.
echo "Copying modules..."
# Set up a build directory under /root.
BUILDDIR=root/chromeboot-temp
BDLINUX=$BUILDDIR/linux-chromeboot
BDFW=$BUILDDIR/linux-chromeboot-firmware
BDBOOT=$BUILDDIR/chromeboot
rm -rf $BUILDDIR
mkdir -p $BDLINUX/src/lib/modules
cp -a $MODPATH $BDLINUX/src/lib/modules
# Lots of embedded files coming...
# BEGIN PKGBUILD FOR linux-chromeboot
cat > $BDLINUX/PKGBUILD <<'EOF'
pkgname=linux-chromeboot
pkgver=<KERNEL>
pkgrel=1
pkgdesc="The Linux-<KERNEL> kernel and modules for booting on a Chromebook."
arch=('x86_64')
url="kernel.org"
license=('custom')
options=('!strip')
depends=('coreutils' 'linux-firmware' 'kmod' 'chromeboot')
optdepends=('crda: to set the correct wireless channels of your country')
provides=("kernel26-chromeboot=${pkgver}" "linux=${pkgver}")
conflicts=("kernel26-chromeboot")
replaces=("kernel26-chromeboot")

package() {
    install=linux.install
    cd "$srcdir"
    cp -ar ./* "$pkgdir"
}
EOF
sed -i -e "s/<KERNEL>/$KERNEL/g" $BDLINUX/PKGBUILD
# Make an install file to run depmod like the regular kernel. No mkinitcpio (mkinitcpio has also been removed from dependencies) as it's useless with this setup. DO run chromeboot-update, though.
cat > $BDLINUX/linux.install <<'EOF'
post_install () {
    echo ">>> Updating module dependencies. Please wait ..."
    depmod <KERNEL>
    echo ">>> Running chromeboot-update..."
    chromeboot-update
}

post_upgrade () {
    echo ">>> Updating module dependencies. Please wait ..."
    depmod <KERNEL>
    echo ">>> Running chromeboot-update..."
    chromeboot-update
}
EOF
sed -i -e "s/<KERNEL>/$KERNEL/g" $BDLINUX/linux.install
# END PKGBUILD FOR linux-chromeboot

# Make a package for the firmware.
echo "Copying firmware..."
mkdir -p $BDFW/src/usr/lib
cp -a $FWPATH $BDFW/src/usr/lib
# BEGIN PKGBUILD FOR linux-chromeboot-firmware
cat > $BDFW/PKGBUILD <<'EOF'
pkgname=linux-chromeboot-firmware
pkgver=<KERNEL>
pkgrel=1
pkgdesc="Firmware files for Chromebook Linux."
arch=('x86_64')
url="kernel.org"
license=('custom')
options=('!strip')
conflicts=('linux-firmware-git'
           'kernel26-firmware'
           'ar9170-fw'
           'iwlwifi-1000-ucode'
           'iwlwifi-3945-ucode'
           'iwlwifi-4965-ucode'
           'iwlwifi-5000-ucode'
           'iwlwifi-5150-ucode'
           'iwlwifi-6000-ucode'
           'rt2870usb-fw'
           'rt2x00-rt61-fw'
           'rt2x00-rt71w-fw'
           'amd-ucode'
           'linux-firmware')
replaces=('kernel26-firmware'
          'ar9170-fw'
          'iwlwifi-1000-ucode'
          'iwlwifi-3945-ucode'
          'iwlwifi-4965-ucode'
          'iwlwifi-5000-ucode'
          'iwlwifi-5150-ucode'
          'iwlwifi-6000-ucode'
          'rt2870usb-fw'
          'rt2x00-rt61-fw'
          'rt2x00-rt71w-fw'
          'amd-ucode'
           'linux-firmware')
provides=('linux-firmware')

package() {
    cd "$srcdir"
    cp -ar ./* "$pkgdir"
}
EOF
sed -i -e "s/<KERNEL>/$KERNEL/g" $BDFW/PKGBUILD
# END PKGBUILD FOR linux-chromeboot-firmware

# Make a package for boot utilities.
echo "Copying utilities..."
mkdir -p $BDBOOT/src/usr/bin
mkdir -p $BDBOOT/src/usr/share/chromeboot
mkdir -p $BDBOOT/src/etc
# Copy Chrome OS' boot utilities
for BINARY in "${CHROMEBINS[@]}"; do
    cp -a "$CHROMEBIN_DIR/$BINARY" $BDBOOT/src/usr/bin
done
# If they exist, copy a few extra files so the firmware tools work
SHFLAGS=/usr/share/misc/shflags
if [ -f $SHFLAGS ]; then
    mkdir -p $BDBOOT/src/usr/share/misc
    cp -a $SHFLAGS $BDBOOT/src/usr/share/misc
fi
FLASHROM=`which flashrom 2>/dev/null`
DMIDECODE=`which dmidecode 2>/dev/null`
[[ $FLASHROM != "" ]] && cp -a "$FLASHROM" $BDBOOT/src/usr/bin
[[ $DMIDECODE != "" ]] && cp -a "$DMIDECODE" $BDBOOT/src/usr/bin
# Copy developer keys
cp -a $CHROME_DEVKEYB $BDBOOT/src/usr/share/chromeboot
cp -a $CHROME_DEVPRIVK $BDBOOT/src/usr/share/chromeboot
# Write chromeboot.conf based on the info we've gathered.
cat > $BDBOOT/src/etc/chromeboot.conf <<EOF
PART_KERN=$LINUXKERNDEV
PART_ROOT=$LINUXDEV
CMDLINE="$CMDLINE"

# Originally-installed CMDLINE based on Chrome OS:
#CMDLINE="$CMDLINE"
EOF
# Create chromeboot and chromeboot-update utils.
# BEGIN chromeboot SCRIPT
cat > $BDBOOT/src/usr/bin/chromeboot <<'EOF'
#!/bin/bash
if [[ $EUID -ne 0 ]]; then
    echo "This script must be run as root."
    exit 1
fi

if [ ! -f /etc/chromeboot.conf ]; then
    echo "/etc/chromeboot.conf not found. Aborting."
    exit 1
fi

source /etc/chromeboot.conf

ONESHOT=0
CHOICE="$1"

# Allow once to be written as either the first or the second param
if [[ $2 == once ]]; then
    ONESHOT=1
elif [[ $1 == once ]]; then
    ONESHOT=1
    CHOICE="$2"
fi

# Print usage if not invoked properly
if [ $ONESHOT -eq 1 -a $# -ne 2 ] || [ $ONESHOT -eq 0 -a $# -ne 1 ] || [ "$CHOICE" != chrome -a "$CHOICE" != linux ]; then
    echo "Usage: chromeboot chrome|linux [once]"
    echo "\"chromeboot chrome\" sets the default OS to Chrome while \"chromeboot linux\" sets it to Linux."
    echo "\"once\" can be added to the linux option to set the OS for the next boot only."
    exit 1
fi

# Piece together the command we want and then run it.
TYPE="-T 0 -S 1"
[[ $ONESHOT -eq 1 ]] && TYPE="-T 1 -S 0"
if [[ $PART_KERN =~ ([0-9a-z_/]*[a-z_/])([0-9]+)$ ]]; then
    # /dev/mmcblkX devices (maybe others too?) have a "p" before the partition, while /dev/sdX devices don't. Get rid of that.
    DISK=$( echo "${BASH_REMATCH[1]}" | sed -e 's/\([0-9]\)p$/\1/' )
    PART=${BASH_REMATCH[2]}
else
    echo "Unable to determine kernel partition."
    exit 1
fi
PRIO=5
[[ $CHOICE == chrome ]] && PRIO=0

CMD="cgpt add -i $PART -P $PRIO $TYPE $DISK"
echo $CMD
`$CMD`

EOF
# END chromeboot SCRIPT
# BEGIN chromeboot-update SCRIPT
cat > $BDBOOT/src/usr/bin/chromeboot-update <<'EOF'
#!/bin/bash
if [[ $EUID -ne 0 ]]; then
    echo "This script must be run as root."
    exit 1
fi

if [ ! -f /etc/chromeboot.conf ]; then
    echo "/etc/chromeboot.conf not found. Aborting."
    exit 1
fi

source /etc/chromeboot.conf

# Need to copy the kernel to a file on disk or else this won't work?
# vbutil_kernel CAN write block devices directly but they won't boot...
rm -rf /tmp/oldkernel /tmp/newkernel /tmp/kernelconf
echo "Updating kernel blob on $PART_KERN..."
dd if=$PART_KERN of=/tmp/oldkernel
echo $CMDLINE > /tmp/kernelconf
vbutil_kernel --repack /tmp/newkernel --oldblob /tmp/oldkernel --keyblock /usr/share/chromeboot/kernel.keyblock --version 1 --signprivate /usr/share/chromeboot/kernel_data_key.vbprivk --config /tmp/kernelconf
[ $? -eq 0 ] && dd if=/tmp/newkernel of=$PART_KERN
rm -f /tmp/oldkernel /tmp/newkernel /tmp/kernelconf

EOF
# END chromeboot-update SCRIPT
# BEGIN PKGBUILD FOR chromeboot
cat > $BDBOOT/PKGBUILD <<'EOF'
pkgname=chromeboot
pkgver=<KERNEL>
pkgrel=1
pkgdesc="Utilities for booting on a Chromebook."
arch=('x86_64')
url=""
license=('custom')
provides=('dmidecode')
conflicts=('dmidecode')
replaces=('dmidecode')

package() {
    cd "$srcdir"
    cp -a ./* "$pkgdir"
}

EOF
sed -i -e "s/<KERNEL>/$KERNEL/g" $BDBOOT/PKGBUILD
# END PKGBUILD FOR chromeboot

# Make the new scripts executable.
chmod +x $BDBOOT/src/usr/bin/chromeboot $BDBOOT/src/usr/bin/chromeboot-update

# Almost done! All that's left is to write a script to run in the chroot.
BOOTSTRAP=$BUILDDIR/bootstrap.sh
cat > $BOOTSTRAP <<'EOF'
#!/bin/bash
# Make-sure base-devel is installed or this won't work.
if [[ `pacman -Qs base-devel | wc -l` -eq 0 ]]; then
    echo "Error: Please install base-devel and try again."
    exit 1
fi

function checkfail {
    # Need to write exit status to a file because arch-chroot won't report it.
    [ $1 -ne 0 ] && echo $1 > /<BUILDDIR>/retcode && exit $1
}

# Build and install the packages. Use the -e flag since all we want to do is copy the files.
echo "Building 'chromeboot'..."
cd chromeboot
makepkg --asroot -ef >/dev/null
checkfail $?
echo "Installing 'chromeboot'..."
yes | pacman -U *.pkg.tar.xz >/dev/null
checkfail $?
echo "Building 'linux-chromeboot-firmware'..."
cd ../linux-chromeboot-firmware
makepkg --asroot -ef >/dev/null
checkfail $?
echo "Installing 'linux-chromeboot-firmware'..."
yes | pacman -U *.pkg.tar.xz >/dev/null
checkfail $?
echo "Building 'linux-chromeboot'..."
cd ../linux-chromeboot
makepkg --asroot -ef >/dev/null
checkfail $?
echo "Installing 'linux-chromeboot'..."
yes | pacman -U *.pkg.tar.xz >/dev/null
checkfail $?

# The linux* and mkinitcpio packages are usless now, so let's remove them.
echo "Removing unneeded linux packages..."
yes | pacman -Ru linux-docs >/dev/null 2>&1
yes | pacman -Ru linux-headers >/dev/null 2>&1
yes | pacman -Ru linux >/dev/null 2>&1
yes | pacman -Ru mkinitcpio >/dev/null 2>&1
yes | pacman -Ru mkinitcpio-busybox >/dev/null 2>&1

# Set linux to run at the next boot.
echo "Setting boot flag..."
chromeboot linux once >/dev/null
checkfail $?
echo 0 > /<BUILDDIR>/retcode

EOF
sed -i -e "s|<BUILDDIR>|$BUILDDIR|g" $BOOTSTRAP

# Run it.
echo "Building and installing packages..."
chmod +x $BUILDDIR/bootstrap.sh
if [[ $RUNPATH != "/" ]]; then
    eval $ARCH_CHROOT . "bash -c \"cd /$BUILDDIR && ./bootstrap.sh\""
else
    bash -c "cd /$BUILDDIR && ./bootstrap.sh"
fi
[ $? -ne 0 -o "`cat $BUILDDIR/retcode`" != "0" ] && echo "" && echo "Installation failed!" && exit 1

# Finished. Clean everything up.
rm -rf $BUILDDIR
echo ""
echo "Done! You can now reboot to load Arch."
echo "Your Arch kernel's boot configuration is stored in /etc/chromeboot.conf. To change it, first edit that file, then run chromeboot-update."
echo "The system's default OS is still Chrome. If you'd like to make Arch the default, run \"chromeboot linux\" within your Arch install. Try \"chromeboot\" to see more options."

# Offer to install a version of the chromeboot script for Chrome OS, unless we're in Arch or it's already been installed.
[[ $RUNPATH == "/" ]] || [ -x /usr/local/bin/linuxboot ] && exit 0
echo "Optional: install a script for Chrome OS to make switching back to Arch easier? [y/n] "
read EXTRAINSTALL
if [[ $EXTRAINSTALL == "y" || $EXTRAINSTALL == "Y" ]]; then
    # It has to be installed to /usr/local/bin because /bin and /usr/bin aren't writeable.
    mkdir -p /usr/local/bin
    cat > /usr/local/bin/linuxboot <<'EOF'
#!/bin/bash

if [[ $1 =~ ([0-9a-z_/]*[a-z_/])([0-9]+)$ ]]; then
    DISK=$( echo "${BASH_REMATCH[1]}" | sed -e 's/\([0-9]\)p$/\1/' )
    PART=${BASH_REMATCH[2]}
else
    echo "Usage: linuxboot <linux kernel partition>"
    echo "Sets Arch as the OS for the next boot."
    exit 1
fi

CMD="cgpt add -i $PART -P 5 -T 1 -S 0 $DISK"
echo $CMD
eval $CMD

EOF
    chmod +x /usr/local/bin/linuxboot
    echo "Done!"
    linuxboot
    echo ""
fi
echo "If you want to reinstall the packages you can do so by running this script again, either from Arch or from Chrome OS."
echo "If you have any problems running Arch, try playing around with your kernel parameters. Good luck!"