View difference between Paste ID: NtFyycPG and vZBAmFtX

 #!/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!"