CrashPlan on FreeNAS using Iohyve



The better way to run CrashPlan on your FreeNAS…

With the 9.10 version of FreeNAS, comes a better way to virtualize functionality on your FreeNAS server. It also allows us to move away from the headaches we have seen with the Jails, particularly with the CrashPlan. The CrashPlan jail has required too many hours of tinkering with every upgrade, and after seeing everything break with the release of CrashPlan version 4.8, I decided there must be a better way to back up my data on my NAS.

The solution resides with Iohyve – a built in hypervisor that allows you to run virtual machines.

The first step is to ssh into your FreeNAS installation and identify the zpool you wish to install your virtual machine on – I have added a separate pool running on an SSD disk within my environment, and named the SSD storage zpool “SSD”.

zpool list

iohyve_set_con

 

Identify the correct zpool name in your environment.

Next, run the setup of iohyve on your identified zpool:

iohyve setup pool=SSD

setup

 

You also need to identify the correct interface, to bridge your VM to:

ifconfig

Once identified, set the interface to bridge your VM to, and set the correct kernel module to load:

iohyve setup net=alc0 kmod=1

 

Now create the ubuntu host (named ubuntu_crashplan), allocating 20GB of disk space:

iohyve create ubuntu_crashplan 20G SSD

create

 

Next we need to set the correct parameters for Ubuntu, first allowing to boot with grub, set the OS as debian based, configure the RAM, CPU count, and the con parameter (adjust RAM and CPU as needed):

iohyve set ubuntu_crashplan loader=grub-bhyve os=debian ram=1024M cpu=1 con=nmdm1

set_parameters

 

Now we need to fetch the ISO to install (or copy the link to your preferred version of ubuntu):

iohyve fetchiso http://releases.ubuntu.com/16.04/ubuntu-16.04.1-server-amd64.iso

Then install the ISO image

iohyve install ubuntu_crashplan ubuntu-16.04.1-server-amd64.iso

install_ubuntu

Give the installer a minute to start, then open up a second SSH session to your FreeNAS, and run the console command to connect to the new virtual machine:

iohyve console ubuntu_crashplan

ubuntu-setup

Step through the installer as normal, but once you arrive to the software selection screen of the installer, you may choose “OpenSSH server” to allow direct access to the virtual machine.

Once the installer completes, reboot the new virtual machine.

 Verify the status:

iohyve list

Start the virtual machine:

iohyve start ubuntu_crashplan

Set a static IP if you prefer, or set a DHCP reservation within your firewall. Then either SSH into your new ubuntu server or use the “iohyve console ubuntu_crashplan” command to gain access.

We have several considerations, before implementing CrashPlain:

  1. What paths do we want to mount?
  2. What file system do we use to mount these paths?

In my environment, I will be making the following mounts, with the mkdir command:

/mnt/Movies

/mnt/TV

/mnt/Photos

/mnt/Restore

We will then need to mount the appropriate folder to be backed up on the FreeNAS to the created mount points.

Example mounts of shares using CIFS

In my example, I am going to use CIFS and a separate service account to mount to the share:

sudo apt-get update

sudo apt-get install cifs-utils

Create a samba user:

sudo nano /etc/samba/user

Create (2) lines in the credentials file (I created an account with read-only permissions within FreeNAS for the SMB share)

username=samba

password=password

Use “control+o” to write the file, and “control+x” to exit from Nano.

Set the new user file to read only:

sudo chmod 0400 /etc/samba/user

Backup your fstab file:

sudo cp /etc/fstab /etc/fstab.bak

Edit your fstab file:

sudo nano /etc/fstab

We will need to add the various mount points on your FreeNAS with their associated path on your CrashPlan server. Please note that if you have a share name with a space, you must substitute the space with “\040” in your fstab file. For example:

//192.168.1.10/FreeNAS/Music\040Videos/ /mnt/Music_Videos/ cifs crednetials=/etc/samba/user,noexec 0 0

fstab_example

Suggestion: You will want to map out a restore folder to your NAS. That will direct downloaded files to your NAS instead of the 20GB virtual machine disk. For example, I created a /mnt/Restore directory on the CrashPlan VM that maps to a Downloads folder on my NAS.

Enter your mount points and mappings, and reboot your server to test. Once everything is mapped out correctly, you can install CrashPlan:

cd /tmp/

wget https://download.code42.com/installs/linux/install/CrashPlan/CrashPlan_4.8.0_Linux.tgz

tar -xzf CrashPlan_4.8.0_Linux.tgz

cd /crashplan-install/

sudo ./install.sh

Now we should be prompted with the CrashPlan installer. Use the defaults, except for the incoming backup data. I created a /mnt/Restore mapping in my example:

crashplan_installer

Once completed, some useful information:

crashplan_completed

Headless Setup:

Allow the server to listen to external connections:

sudo nano /usr/local/crashplan/conf/my.service.xml

Identify and change from:

<serviceHost>localhost</serviceHost>

To:

<serviceHost>0.0.0.0</serviceHost>

Copy the key from your Headless CrashPlan .ui_info file, and double checking the listening port:

cat /var/lib/crashplan/.ui_info

Into your local .ui_info on your computer.

This varies by operating system, so please refer to CrashPlan’s site for the file locations at:

https://support.code42.com/CrashPlan/4/Configuring/Using_CrashPlan_On_A_Headless_Computer

Once done, your client will have a .ui_info file that shows the correct port, the correct key, and the IP of the new virtual server. The virtual (and headless) server’s .ui_info will show the IP as 0.0.0.0 after we configure the my.services.xml file.

Complimentary .ui_info files – client on the left, server on the right:

ui_info_compared

Once these are in agreement, restart the crashplan service on the virtual server:

sudo service crashplan restart

Launch the local application from your machine with the correct .ui_info, and you should attach!

crashplan_intro

 

With this replacing a previous CrashPlan Jail, I simply adopted this computer after the login to replace my previous setup. All mount points were named to replicate the setup in the replaced FreeNAS jail.

Once you have connectivity between your client and your host, you can lock each .ui_info file with the immutable bit. For the Ubuntu Crashplan server, use:

sudo chattr +i  /var/lib/crashplan/.ui_info

For OS X, use:

sudo chflags nouchg /Library/Application\ Support/CrashPlan/.ui_info

This will lock both files, and prevent edits. To unlock the files, change the chattr attribute to “-i” (instead of +i) and the chflags attribute from “nouchg” to “uchg”.

 

Observium on the Raspberry Pi 2

Please note – I have also detailed the installation of LibreNMS on the Pi, which is a fork of Observium. Please take a look at my post at:

LibreNMS on the Raspberry Pi 2 or 3

I love Observium, an open source network monitoring platform. I monitor anything and everything with this tool: firewalls, servers, routers, switches, wireless access points, printers… the possibilities are endless. If you are not familiar with Observium, please check out everything you are missing at their site:

http://www.observium.org/

The Raspberry Pi 2 seems to render and handle Observium well in my lab. You will not be disappointed by the beautiful graphs and the constant flow of information that Observium will feed you via the Raspberry Pi 2.

For the installation, I will deviate off the beaten path by using a currently unsupported version of Ubuntu on the Raspberry Pi 2. I am aware that Snappy Core Ubuntu is available, but I did not want to gravitate away from my comfort zone, and elected to go with Ubuntu 14.04LTS Server…

First, I would recommend grabbing a decent Micro-SD card (I used a 32GB class 10), and installing Ubuntu 14.04LTS per:

https://wiki.ubuntu.com/ARM/RaspberryPi

Choose to install OpenSSH-Server during the installation. You will reboot the pi after the installation, and can log in using ubuntu/ubuntu for your username and password. You will first want to set a static IP address on the Pi so you always know how to find it, by editing the following file:

sudo nano /etc/network/interfaces.d

The file should instruct how to configure eth0, the ethernet interface on the Pi. For example:

iface eth0 inet static
address 192.168.0.10
netmask 255.255.255.0
gateway 192.168.0.1

Save the config with “control+o” to write the file, and “control+x” to exit the editor.

Now proceed by accessing your Raspberry Pi 2 via SSH (use Putty from Windows) with the static IP you assigned.

ssh ubuntu@192.168.0.10

Install you base packages required for Observium, making sure you document your MySQL password:

apt-get install libapache2-mod-php5 php5-cli php5-mysql php5-gd php5-mcrypt php5-json php-pear snmp fping \ mysql-server mysql-client python-mysqldb rrdtool subversion whois mtr-tiny ipmitool graphviz imagemagick

If you monitor libvert machines, you will need to install the following, if not, please skip:

apt-get install libvirt-bin

Make a directory for Observium, then change directory into /opt:

sudo mkdir -p /opt/observium && cd /opt

I will be working with the community edition of Observium, install it with the following command:

sudo wget http://www.observium.org/observium-community-latest.tar.gz 
sudo tar zxvf observium-community-latest.tar.gz

After downloading, change into the unpackaged Observium directory:

cd observium/

Copy the example php config into your working config:

cp config.php.default config.php

Create the MySQL database:

mysql -u root -p

<you will be prompted to enter your root MySQL password to continue>

mysql> CREATE DATABASE observium DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
mysql> GRANT ALL PRIVILEGES ON observium.* TO 'observium'@'localhost'         -> IDENTIFIED BY 'observium_db_password';
mysql> quit

MySQL setup Observium

Now we will need to edit the working config file we copied from the default, updating it with our database password:

sudo nano config.php

You should be updating the “db_user” to observium and your “db_password” to the password configured above when setting up MySQL with the line “IDENTIFIED BY ‘observium_db_password'”

You will see in my attached example I simply used “ubuntu” for my Observium database password. This is also the time and place to update the default SNMP community name. In my attached example I am using the SNMP community name of “infosoda”.

config.php Observium

I used “nano” to edit the file – you will need to use a “control+o” to save and then a “control+x” to exit.

Now update the database with the following php script:

sudo php includes/update/update.php

As long as your updated database password in the config.php file matches your setup password, yo should see the terminal session scroll while updating the database schema.

We need to create the directory “rrd” to store RRD files. We then follow it up by modifying the permissions:

mkdir rrd
sudo chown www-data:www-data rrd

Assuming this is the only site running on Apache on your Raspberry Pi 2, we should edit the Apache config:

sudo nano /etc/apache2/sites-available/000-default.conf

Edit the file (see my attachment – please omit me working around the default comments in the config file):

<VirtualHost *:80>
       ServerAdmin webmaster@localhost
       DocumentRoot /opt/observium/html
       <Directory />
               Options FollowSymLinks
               AllowOverride None
       </Directory>
       <Directory /opt/observium/html/>Options Indexes FollowSymLinks MultiViews
              AllowOverride All
              Require all granted
       </Directory>
       ErrorLog ${APACHE_LOG_DIR}/error.log 
       LogLevel warn 
       CustomLog ${APACHE_LOG_DIR}/access.log combined 
       ServerSignature On 
</VirtualHost>

Apache2 config Observium

We then need to run the mcrypt module:

sudo php5enmod mcrypt

Enable the module rewrite:

sudo a2enmod rewrite

Restart Apache:

sudo service apache2 restart

We now get to add a user in the format ‘user_name’ ‘password’ ‘level’, where a level 10 denotes an administrator:

sudo ./adduser.php admin observium 10

We will then perform an initial discovery:

sudo ./discovery.php -h all

Followed by an initial poll:

sudo ./poller.php -h all

We finally need to set up a CRON job to maintain the discovery and polling:

sudo nano /etc/cron.d/observium

Edit the newly created job to reflect the following:

33  */6   * * *   root    /opt/observium/discovery.php -h all >> /dev/null 2>&1
*/5 *     * * *   root    /opt/observium/discovery.php -h new >> /dev/null 2>&1
*/5 *     * * *   root    /opt/observium/poller-wrapper.py 2 >> /dev/null 2>&1

Please note, this cron job utilizes a username.

Editing /etc/cron.d/observium

To set the correct timezone for your graphs, you will need to edit your php.ini file and set the time on your Raspberry Pi.

The Pi can be set in Ubuntu with the following command in the terminal, which will launch the interface that users usually utilize when they set up their servers:

sudo dpkg-reconfigure tzdata

Edit the php.ini file with your editor:

sudo nano /etc/php5/cli/php.ini

Editting php.ini

 You will need to setup SNMP on all of your hosts and devices, which is beyond the scope of my post, but here is how we add our Raspberry Pi 2 within Ubuntu:

sudo apt-get update
sudo apt-get install snmpd

Move the original snmpd.conf file:

sudo mv /etc/snmp/snmpd.conf /etc/snmp/snmpd.conf.original

Now re-create the snmpd.conf file:

sudo nano /etc/snmp/snmpd.conf

There are only a few variables that are necessary in your new, blank config:

rocommunity         batman
syslocation         Bat Cave
syscontact          Bruce@wayneenterprises.com

Usually you would enter some useful information to help you locate the device on your network.

Relaunch the snmpd service:

sudo service snmpd restart

Now you can monitor your own Observium install…

Simply add it using “localhost” for the hostname and the appropriate SNMP community name. Observium requires DNS names to resolve, and you will want to correctly setup DNS in your environment.

A sample screenshot:

Raspberry Pi in Observium
Observium screenshot

 

 


Ubuntu on the $59 WinBook TW700 Windows 8.1 Tablet – Step 2

PLEASE NOTE: This is an attempt to explore the feasibility of running Ubuntu on a Bay Trail tablet. It will not be uncommon to experience kernel panics and unexpected behavior at this point in time with Linux and Intel’s Bay Trail hardware. The tablet can run a little hot during the initial parts of the installation, so if you hit a barrier, turn it off, take a break, and let it cool down. Please proceed at your own risk, and make sure you have your Windows recovery drive!

In the previous post, http://infosoda.com/ubuntu-tw700-1/ we performed a basic install of Ubuntu 14.10 on the WinBook TW700. In this post, we will update the kernel, enable the built in wireless, and enable the touch screen (goodix support for this screen is built into the new kernel). We will also repair GRUB, so we are not dependent upon the bootia32.efi bootloader on the installation USB when booting. As I mentioned in my previous post, I have borrowed content and direction from John Wells with his post linked at: http://www.jfwhome.com/2014/03/07/perfect-ubuntu-or-other-linux-on-the-asus-transformer-book-t100/ , making changes and corrections as needed for us to proceed on this WinBook.

I prefer to work smart, and prefer to work on the tablet via an ssh session. This will also make it easier to cut and paste the terminal commands in this article. If you do not have a computer with ssh or putty, you can skip this step. Join your tablet to your wireless (using a linux compatible wifi dongle). Open your terminal (the keyboard shortcut is control+alt+t) and type in:

sudo apt-get update
sudo-apt get install openssh-server
ifconfig

Now from your workstation you can ssh into the tablet using the IP address the command provided, with the following format:

ssh username@10.10.10.xx (or whatever your tablet’s IP is)

Now continuing from a terminal session:

sudo apt-get update && sudo apt-get install git bison libopts25 libselinux1-dev autogen m4 help2man libopts25-dev flex libfont-freetype-perl automake autotools-dev libfreetype6-dev texinfo lib32z1 lib32ncurses5 lib32bz2-1.0 autoconf build-essential gnome-common systemd libgudev-1.0-dev

This will install the packages required to build our drivers and GRUB efi file. Now we will update the kernel. In this example, I am downloading the generic 3.19.0 kernel for Ubuntu (which will detect the touchscreen!).

cd /tmp/
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v3.19-vivid/linux-headers-3.19.0-031900-generic_3.19.0-031900.201502091451_amd64.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v3.19-vivid/linux-headers-3.19.0-031900_3.19.0-031900.201502091451_all.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v3.19-vivid/linux-image-3.19.0-031900-generic_3.19.0-031900.201502091451_amd64.deb
sudo dpkg -i linux-headers-3.19.0-*.deb linux-image-3.19.0-*.deb
sudo reboot

Once we reboot, we still need to use GRUB on our installation USB drive. Once you see GRUB, hit the ‘c’ key to enter the command line

linux (hd1,gpt2)/boot/vmlinuz

Then hit “tab” to autocomplete. You should now see a new entry – the packaged kernel (vmlinuz) with the upgraded version. Use this new version. PLEASE note, we will addend “nomodeset” with an additional parameter – “reboot=pci,force”.

Using the kernel from above, you should then have the following in your GRUB commands:

linux (hd1,gpt2)/boot/vmlinuz-3.19.0-031900-generic root=/dev/mmcblk0p2 nomodeset reboot=pci,force
initrd (hd1,gpt2)/boot/initrd.img-3.19.0-031900-generic
boot

The new kernel should recognize your touch interface, and we will address this is more detail at the end of the article. In the meantime, to update your wireless, open your terminal and type:

cd /tmp/
git clone https://github.com/hadess/rtl8723bs.git
cd rtl8723bs/
make
sudo make install
sudo depmod -a
sudo reboot

The wireless will be detected after the reboot. Unfortunately, the wireless at this point is not very reliable. I would recommend to keep utilizing the wireless on your USB dongle, especially through the remainder of this guide! Remember to use the command line at the GRUB menu (we are still using the USB’s GRUB) to point at the correct vmlinuz and initrd paths when re-booting.

 Now we will repair GRUB, and forego pressing “c” at the GRUB menu to load our Ubuntu installation. This process will take a few minutes to compile on this little tablet, so please be patient. Open the terminal and “get” the GRUB source:

cd /tmp/
git clone git://git.savannah.gnu.org/grub.git
cd grub/
./autogen.sh
sudo ./configure --with-platform=efi --target=i386 --program-prefix=""
sudo make
cd grub-core/
sudo ../grub-install -d . --efi-directory /boot/efi/ --target=i386
cd /boot/efi/EFI
sudo cp grub/grubia32.efi ubuntu/grubx64.efi

After replacing the installed 64 bit EFI boot loader with our compiled 32 bit version, we will now update GRUB with your preferred editor:

sudo nano /etc/default/grub

Change the GRUB_CMDLINE_LINUX_DEFAULT line with the parameter “nomodeset reboot=pci,force”

Editing the grub file
Editing the grub file

This is a great opportunity to customize grub to your preferences – you can alter timers, disable the display of the UUID, et cetera.

Save the new setting with Control+O, exit via CONTROL+X.

Now update GRUB at the command line:

sudo update-grub
sudo grub-install /dev/mmcblk0

sudo reboot

The last command will shut down the tablet; you may now remove the installation USB.

Unfortunately, the reboot process is possessed with various errors – you will want to have a USB keyboard connected, and may prefer to boot in recovery mode (advanced options -> Ubuntu 3.19 recovery mode).

I would recommend playing with the Florence virtual keyboard; you can access the built in Ubuntu “onboard” keyboard also.

To install florence:

sudo apt-get -f install
sudo apt-get install florence

For more info on Florence, please take a look at the following link: http://xmodulo.com/onscreen-virtual-keyboard-linux.html

That site can assist in setting up the defaults, auto-launch, etc.

 There are still multiple issues to be addressed, including the audio and bluetooth. I will attempt to create a third post if I am able to dedicate some time to address these issues. I would also like to re-address the wifi instability, and this fix may be directly related to the bluetooth fix (they both use the Realtek rtl8723bs). Most of these issues are works in progress, and I will keep an eye on GitHub and other sources for the development of any Linux drivers that my assist in the usability of this tablet.


Portable FOG Server

Professionally, I am a “Network Engineer” for an IT Services provider, which leads me to be a jack of all trades, and a master of none. One of the tasks that our group occasionally runs across is the deployment of desktops and laptops. Most of our clients are not huge (thus lacking an IT Department), but we are occasionally asked to deploy a large number of workstations. This can be a long and repetitious job, or this can be a quick experience, where the work load is just a foggy memory. Let me explain…

The FOG Project http://www.fogproject.org/ is an open source cloning solution, that allows you to PXE boot computers, and downloaded images from the FOG server. One could build a VM, but I carry a laptop with SSD storage, with disk space at a premium. I perused through my collection of disavowed equipment and came across an underpowered “thin client” that was heading to the recycle bin: an ASUS EB1030.

The ASUS has an atom processor, and was shipped with 1GB of RAM and a 32GB SSD. Cracking the case open, I was able to upgrade the memory to 4GB and throw in an old 640GB laptop hard drive. Now I had the storage I needed. My plan for the little box is to allow it to serve out IP’s via DHCP, and connect it to a simple switch (Trendnet green 8 port Gigabit switch), for my own private imaging network. All of this would easily fit in a shoebox.

I installed the 32bit version of Ubuntu Server 14.04LTS on the ASUS EB1030, updated it, and set a static IP address. For the FOG installation, open your terminal:

cd /opt/

wget the latest version (1.2.0 at posting):

sudo wget http://downloads.sourceforge.net/freeghost/fog_1.2.0.tar.gz
sudo tar -zxvf fog_1.2.0.tar.gz
cd fog_1.2.0/bin/
sudo ./installfog.sh

Set up your FOG Server to your preferences – I elected to install the DHCP server so I could set up my own little imaging network.

The installer is actually very clear and self explanatory.

Once you log into the FOG web interface, you need to create your initial image. I elected to clone an initial Windows 7 Professional 32 bit install, with updates, but prior to a Sysprep. This would provide me with my base 32bit image.

FOG Image Management

I will then repeat the process for a 64bit Windows 7 image, and so on. Using these base images, we could then build images based on manufacturers with the appropriate drivers, or build separate images for different clients. This will allow us to install applications specific to clients and reduce our workload even further.

In my initial test, it appeared I could push out an 11GB image within a 15 minute window.

FOG image download

I would recommend further reading on the use of an answer file (Unattend.xml) for sysprep:

http://theitbros.com/sysprep-a-windows-7-machine-%E2%80%93-start-to-finish/

and further reading on a Windows client setup at the FOG Project:

http://www.fogproject.org/wiki/index.php/Client_Setup#Install_Windows

The whole kit and caboodle, ready to image the world:

Portable FOG setup


Ubuntu on the $59 WinBook TW700 Windows 8.1 Tablet – Step 1: Installing Ubuntu

I recently stopped by Houston’s new MicroCenter (they recently moved into a new store), and walked out of the store with their WinBook TW700 tablet for about $40. This tablet is built around Intel’s Bay Trail Atom architecture, sporting a 1.33GHz quad core Atom processor, Windows 8.1, and a free (1) year subscription to Office 365. This little tablet only has a 7″ screen, 1GB of RAM, and 16GB of internal storage, but the Micro-SD slot and a full sized USB 2.0 port sealed the deal for me.

With the memory and storage specs, I needed to figure out how to get Linux on this little tablet as fast as possible. Windows reserves 7.19 GB for a recovery partition, and anyone with experience with Windows can figure out how far 8.74GB of useable space will go after a few updates. Also, with only a 7″ screen, Microsoft’s crossover interface in Windows 8.1 is a little difficult to use. I naturally gravitated towards Ubuntu, hoping to take advantage of Unity and perhaps one of their touch oriented images.

First, you will need a couple of common items – a USB hub, a USB keyboard and mouse, a linux compatible wifi USB dongle, and a couple of appropriately sized USB drives (8GB or more).

Use the first USB drive to create a recovery disk – unfortunately, we are unable to delete the recovery partition after creating the USB drive, a missed opportunity to almost double the storage space! See the following Microsoft link for instructions: http://windows.microsoft.com/en-us/windows-8/create-usb-recovery-drive

After creating the recovery USB, we need to create an Ubuntu installer on the second USB drive. I recommend using Rufus, a Windows based bootable USB utility. Download the latest 64 bit Ubuntu Desktop image (32bit Ubuntu image does not support EFI booting), and install it on the USB, using “GPT Partition Scheme for UEFI Computer” and keeping the remaining defaults.

Ubuntu USB with Rufus

 

Here comes the caveat – the WinBook uses a 32bit EFI bootloader, but the 64bit Ubuntu image will install a 64bit bootloader. I referred to John Wells’ guide at the following link to steer me in the right direction: http://www.jfwhome.com/2014/03/07/perfect-ubuntu-or-other-linux-on-the-asus-transformer-book-t100/ Either grab a copy of his bootia32.efi file (or compile your own) and drop it into the EFI/BOOT folder on your USB drive.

bootia32.efi

 

At this point, we are ready to install Ubuntu on the tablet. Eject the recovery USB, and connect your USB hub to the T700, with the wifi dongle, keyboard/mouse, and bootable USB. Then on your powered on tablet, choose PC Settings->Update and Recovery->Recovery->Restart Now. In the Recovery Window, choose Troubleshoot->Advanced options->UEFI Firmware Settings->Restart. This will populate a traditional “BIOS” menu. Make sure Safe Boot is disabled on the security tab, change the boot order so the bootable USB drive is listed first, and exit, saving changes.

If all goes well, you should be prompted with the GRUB menu. Select “Install Ubuntu” and press “e” to edit the GRUB settings.

I recommend replacing “quiet splash” with “nomodeset”, which is a deviation from John Wells’ blog. This will show the verbose booting (removing quiet) and “nomodeset” instructs the kernel to not load video drivers until X is loaded. Press F10 at this point to boot the Ubuntu installer.

Install Ubuntu as normal – but at the “Installation Type” window, choose “Something else”. Remove all partitions, and create the following:

  • A 100MB primary partition, used as an “EFI boot partition” (100MB is minimum)
  • An EXT4 partition, subtracting your swap space. I simply used “/” as my mount point
  • A swap partition (optional, but I chose 1000MB due to limited RAM)

Take a note of your device partitions for a later step, I had the following:

  • /dev/mmcblk0p1 – efi partition
  • /dev/mmcblk0p2 – ext4 (Ubuntu) partition
  • /dev/mmcblk0p3 – swap partition

Finish the installation, but we still need to boot using the bootable USB upon the initial reboot.

At the reboot, we will face the GRUB menu from the bootable USB. Choose “c” for a command prompt. At the “grub>” prompt, type “ls” and note the visible partitions. The bootable USB should be listed as “hd0”, with the (3) partitions we created listed as (hd1,gpt1), (hd1,gpt2), and (hd1,gpt3). Using the partition notes above, issue the following commands:

linux (hd1,gpt2)/boot/vmlinuz-3.xx.x-xx-generic root=/dev/mmcblk0p2 nomodeset
initrd (hd1,gpt2)/boot/initrd.img-3.xx.x-xx-generic
boot

PLEASE NOTE which kernel package you are using, and more than one may be available. I want you to be aware of this for every command line boot we perform with the bootable USB. Also both commands must have matching version numbers in the above commands! You may need to try different kernel versions also to boot. I was only able to boot consistently with kernel 3.16.0-23-generic.

Your tablet should boot to the login you set up during the installation. Go ahead and log in, and enjoy the first fruits of your labor. In the next blog, we are going to fix GRUB, and compile our missing drivers.

Until then, you must keep our initial bootable installer USB plugged into and use the GRUB command line to boot the tablet.

Proceed to step 2 of Ubuntu on the Winbook TW700:

http://infosoda.com/ubuntu-tw700-2/