Slackware on the Asus Eee PC 701

To do an automatic installation of a user-controlled set of packages, we can use the tagfile method. For packages to be included, set their tag to ADD and for everything else, set it to SKP. Make sure not to have any REC or OPT tags otherwise the installer will prompt to choose whether to include the package. With only ADD and SKP tags, the package installation step will be non-interactive.

The Slackware installer has two methods of using tagfiles:

The tagpath method would be used if you are installing from an ISO image (DVD) where you cannot modify the installation media. If using the USB installer (as we do with the Eee PC) then either method can be will work. When we choose to source packages from a USB stick at the "SOURCE MEDIA SELECTION" step of the installation process, the USB stick will be mounted at /usb-stick so is accessible via the tagpath method.

To work with tagfiles, I ended up writing a bunch of scripts to make life easier.

These tagfile scripts can be found on sourcehut at https://git.sr.ht/~gslewis/stfm.

What is a minimal working Slackware installation? A perennial question, discussed occasionally on LinuxQuestions.org such as here and here. Also of interest is nobodino’s slackware-mini package list which starts from the bare minimum of 24 packages to get a bootable system and progressively adds packages to add features.

For the Eee PC, as a starting point, I took the LXC Slackware template (/usr/share/lxc/templates/lxc-slackware) which creates a slackpkg template for a minimal set of 82 packages (search for "minimal-lxc.template"). As the comment in the template suggests, this is itself based on Vincent Batts' very_minimal_current.list of packages for Slackware 13.37.

As the LXC template is intended to set up Slackware in a container environment, it does not include the kernel-generic package or other packages related to booting on bare metal.

While the Eee PC is pre-UEFI and, in theory, should be able to use lilo as the bootloader, in previous attempts I was unable to use it when the root partition was formatted as btrfs or f2fs. The plan is to use btrfs with compression enabled to get more use out of our 4GB SSD. Therefore we use grub which has now become the standard Slackware bootloader anyway.

The additional packages are:

This gives us a total of 88 packages and an install size of 766MB, producing a useable console-based system with wired networking. I probably don’t need to include the zstd package (used for btrfs compression) because libzstd is included in the base libraries provided via the aaa_libaries package, but it is only 1.8MB so it doesn’t hurt.

For my initial quality of life, I also added the following packages:

This brings the total to 99 packages and increases the install size to 876MB, the bulk of the increase due to vim and its dependency ruby.

Another consideration is the glibc-i18n package (250MB installed) which provides all the locale files and internationalisation resources. By default, Slackware sets LANG=en_US.UTF-8 in /etc/profile.d/lang.sh which requires the glibc-i18n package to be effective. Without it, things like perl (used by inxi) will complain with "Setting locale failed". There are two options: install the the glibc-i18n package, or set LANG=C. Down the track, another option might be to trim unused locales from the glibc-i18n package.

If the glibc-i18n package is included as is, that brings the install to 100 packages and a size of 1.1GB.

The final list of packages used is here — minimal.template

Step 1 - Create the USB installer

Create an all-in-one USB installer that contains the 32-bit Slackware packages to be installed. This is done using the usb-and-pxe-installers/usbimg2disk.sh script from the Slackware repository. For 32-bit Slackware, this takes up about 5GB on the USB drive.

The script must be run as root. The -f option (format) means the USB drive will be wiped. Change /dev/sdX to the device corresponding to your plugged-in USB drive. You get a couple of chances to confirm the target device is correct before proceeding. As the entire Slackware package set is being copied, creating the USB installer will take a while.

Step 2 - Create a tagfile set

We need to copy the Slackware package series tagfiles, modify them to only include our minimal set of packages, and make them accessible to the USB installer.

I explored a variety of methods for copying the tagfiles in a separate article — Making a copy of the Slackware tagfiles. Using the get_tagfiles.sh script, it is simply a matter of:

Change the --from option to point to your preferred repository or a local mirror.

We end up with a tagfile set directory structure like the following.

The tagfiles will have the default tag values for each package (ADD, SKP, REC or OPT).

Step 3 - Apply the minimal template to the tagfile set

Use the template_to_tagfile.sh script to apply the minimal.template to the slackware.eeepc tagfile set. This will configure the tagfile set so that only those packages listed in the template have the ADD tag and all other packages have the SKP tag.

Once the tagfile set is configured, we can check the installation size using the calc_install_size.sh script and its accompanying pkg_size_list.awk script. This requires a local copy of the 32-bit Slackware’s PACKAGES.TXT file.

In my case, this reported I was installing 100 out of 1712 packages for a total install size of 1.10GB.

Step 4 - Copy the configured tagfile set to USB installer

The simplest method is to copy the slackware.eeepc directory to the root of the mounted USB drive so that the tagpath prompt mode can be used and the tagpath value will be /usb-stick/slackware.eeepc. This assumes the USB drive has been chosen as the source media so that it is mounted by the installer at /usb-stick.

The alternative is the custom prompt mode that requires copying the modified tagfiles into the slackware-current/slackware/ directory on the USB installer. This can be done using the copy_custom.sh script. If the USB installer has been mounted at /run/media/gsl/SLACK32 then to install the modified tagfiles as tagfile.eeepc in the slackware/ packages directory, use the following:

Booting

Power on the Eee PC with the USB installer attached and press <ESC> at the BIOS screen to get the boot device selection menu. Choose our USB device (not the SiliconMotion HDD) and the Slackware installer will run using syslinux.

The Eee PC CPU is in the old Pentium-M (Celeron-M) class that does not support PAE (Physical Address Extension). If you proceed at the boot: prompt without entering any parameters, the installer will fail with "WARNING: PAE disabled". As explained on the boot: prompt screen, the work-around for this is to pass the forcepae parameter.

Partitioning

Once the installer has finished booting and we are logged in as root, partition the /dev/sda SSD using a MBR partition table. The next question is do we create a swap partition? As Slackware-current (15.1) now uses zram for swap, we can probably get away without it but I want to try out hibernate (suspend to disk) so, using cfdisk /dev/sda, I allocate 512MB to a swap partition (/dev/sda1) and the rest (3.2GB) to the root partition (/dev/sda2).

Setup - swap & root partition

We can now run the setup process. The only "trick" is we want to install our packages to the btrfs-formatted root partition with compression enabled.

The first pass through setup involved:

If we run mount, it shows the btrfs-formatted root partition mounted at /mnt.

Now unmount and remount /dev/sda2 with compression enabled.

Now if we re-run mount, it is reported as:

Start the setup process again. We have to repeat the ADDSWAP step and continue to the TARGET step where we selected /dev/sda2 as the root partition again but this time at the "FORMAT PARTITION" screen, choose "No" so we keep our prepared and mounted partition. Note that the /etc/fstab entry that the installer writes for the root partition does not include our compression option so after setup is complete, we need to remember to fix this.

Setup - Source media & packages

The next step is the "SOURCE MEDIA SELECTION" screen where we choose Option 2 "Install from a Slackware USB stick". Once the installer locates and mounts the USB drive, if we change to the second console (<Alt-F2>) we can confirm the USB drive is now mounted at /usb-stick and our tagfiles are, as expected, at /usb-stick/slackware.eeepc.

The next step is the "PACKAGE SERIES SELECTION" screen. As we are installing using tagfiles, we can just leave all package series selected here but it doesn’t hurt to explicitly exclude those package series we aren’t using. The installer still spends time checking the package series tagfile for packages with the ADD tag which can slow things down for the series with lots of packages like kde.

We can double-check which tagfiles in our slackware.eeepc tagfile set contain the ADD tag. Make sure to include the package series containing these tagfiles.

Setup - Install using tagfiles

The next step is the "SELECT PROMPTING MODE" screen. Normally, I would just choose terse and install everything based on the selected package series. In this case, we want to use our tagfiles so choose either custom or tagpath.

If we have copied our tagfiles to a separate directory on the USB stick, use the tagpath mode and enter the path to our tagfile set:

If we have copied our tagfiles into the slackware-current package directories with a custom suffix, choose the custom mode and enter the suffix including the leading period, for example, ".eeepc". Note that, despite the instructions on the "custom" screen, using a suffix longer than three characters works fine.

Setup - The rest

As we haven’t included the syslinux package, the installer fails to offer the option to create the USB boot stick. That’s OK.

Configure the network. We haven’t installed the NetworkManager package so configure using either a static IP or DHCP.

Choose which services to enable on start-up. There aren’t many to choose from. Select the clock and timezone.

Choose the default ex/vi editor. We have only installed elvis and vim so don’t choose nvi.

Set a root password, or not, according to your preference.

System configuration is now complete so we can exit the installer. We still have some post-installation stuff to do so choose the "Shell" option instead of "Reboot" or "Power Off".

Interestingly, with btrfs compression enabled on the root partition, df only reports the root partition as using 550MB instead of the projected 1.1GB. What the actual used and free space is on a btrfs filesystem, I don’t really know. We can get more information using btrfs filesystem usage / later.

Setup - Finishing up

To finish up before rebooting, chroot into the /mnt directory which is still the root of the newly-installed system.

We need to ensure the root partition continues to be mounted with compression enabled so edit /etc/fstab and add compress=zstd:3 to the /dev/sda2 options.

The latest Slackware installer sets up the kernel for you with grub as the bootloader. If we look in /boot there exists an initrd corresponding to the installed kernel and checking /etc/grub/grub.cfg shows entries for the kernel images in /boot.

The Eee PC is a pre-UEFI device so needs the grub bootloader in the MBR of /dev/sda. I am not 100% sure if the Slackware installer does this. I have already installed Slackware on the Eee PC a few times so the bootloader was already in place. If in doubt, you can run grub-install anyway.

I also like to clean up the grub.cfg by disabling unnecessary menu entries.

We could also enable hibernate at this stage, before calling update-grub, by setting the resume kernel parameter. I cover this below in the post-install section.

I should also note that, while the forcepae kernel parameter was needed to boot the installer, it is not needed for the installed kernel.

At this point, it is safe to exit the chroot environment, remove the USB stick and reboot the Eee PC.

Et voilà!

I have installed a few extra packages (via slackpkg) such as neofetch (obviously), bsd-games (for fortune and others), nethack, lm_sensors, ntp and its dependency, libevent.

To view man pages requires man-db (2.7M), libseccomp (410K) and groff (10M).

Because I am living in the console, for a better experience I installed kbd (4.1M) and ran setconsolefont to use the "Lat2-Terminus16" font. If I want a font larger than 8x16, I can install the terminus-fonts package (4M) as well.