Category: Hardware (Page 2 of 5)

The new computer with its Ryzen CPU created some issues for me. To start with… I had not considered the possibility that a Ryzen CPU would not have an embedded GPU and so I did not order a graphics card. Bad idea!
I ended up ripping a GPU from one of my other computers (the only PCI-express card I could find) and plugging that into the new computer. That gave me a working video instead of a monitor that kept falling asleep.

Next came Slackware. When I booted the Slackware 14.2 installer, it did not give me a network connection. The Slackware Live Edition (based on slackware-current) worked properly on the other hand. But the graphics card I plugged into the computer did not work too well with the nouveau driver – whenever I started Chromium, it was inevitable that the computer would lock up after some time. Initially I blamed this on the computer hardware and feared that I bought a dead duck, but once I stopped running Chromium in the graphical desktop of Slackware Live, the system would remain operational. Since it is not going to be used as a desktop system and I will access it only remotely, that buggy nouveau driver is not a big issue and I could still install the binary Nvidia blob if needed.

So, the question became: I want to run a stable Slackware release on my new build server, but how am I going to install it? I was facing two major issues:

1. The installer of Slackware 14.2 does not support NVMe boot devices (the new type of SSD hard drives with a M.2 PCI-express interface)
2. The Slackware 14.2 installer lacks network capability on this new hardware, so I would have to perform a local install

I could spend a USB stick, putting the Slackware 14.2 DVD ISO on it, but then I still would have to patch the installer and I would not have a network connection after reboot. Considering the fact that slackware-current’s kernel works much better and NVMe support was added to the -current installer recently, I decided on a different approach.

I used a slackware-current based liveslak to setup the computer with Slackware 14.2 and then added a 4.9 kernel using the configfile for this kernel as found in slackware-current.

Steps taken:

• Obtain a recent ISO of the Slackware Live Edition which is based on slackware-current (for instance, the 2.7 GB bleeding edge version or else the 700 MB XFCE based edition)
• Write the ISO to a USB stick and boot liveslak. Now you have a proper graphical environment where you can query Google/DuckDuckGo and download anything you need.
• We can not use the “setup2hd” of liveslak because that will install slackware-current and I want 14.2. So, download the smallest installer we can get:  slackware64-current-mini-install.iso which contains just the kernel and the installer (no packages) and is slightly more than 100 MB in size:
  # wget http://bear.alienbase.nl/mirrors/slackware/slackware64-current-iso/slackware64-current-mini-install.iso
• Download my “extract_initramfs.sh” script which makes it easier to extract the initrd.gz file containing the installer:
  # wget http://www.slackware.com/~alien/tools/extract_initramfs.sh
• Partition the SSD drive. The M.2 interface results in a character device /dev/nvme0 and a namespace block device /dev/nvme0n1. The first partition on this device will be called /dev/nvme0n1p1. The installer in Slackware 14.2 can not handle this new namespacing format. The one in -current can.
  This is a UEFI computer, and I want Slackware to use this. That requires a FAT partition which will be used as the EFI system partition. Slackware will mount this partition at /boot/efi. I created a 100 MB partition of type EF00 (EFI system) and formatted this with:
  # mkdosfs -F32 -s 2 -n “EFI” /dev/nvme0n1p1
  The remainder of the disk is partitioned with swap (yes even with 64 GB of RAM it is still a good idea to add some swap space), and additional partitions are created for /, /boot, /var, /tmp and /home .
• Extract the installer from this mini ISO into a new directory “/root/initrd64-current“:
  # mount -o loop slackware64-current-mini-install.iso /mnt/tmp
  # sh extract_initramfs.sh /mnt/tmp/isolinux/initrd.img /root/initrd64-current
• Get the installer running in the terminal while we are still in a liveslak graphical Desktop Environment:
  # mount -o bind /dev /root/initrd64-current/dev
  # mount -o bind /proc /root/initrd64-current/proc
  # mount -o bind /sys /root/initrd64-current/sys
  # chroot /root/initrd64-current
• Inside this chroot-ed installer environment, run the ‘setup‘ command and proceed as usual with the installation of Slackware64 14.2 from a network server. The liveslak has already taken care of the network connectivity. I have NFS and HTTP servers at home, providing package trees but I pick NFS because that is much faster. I pointed the installer to a Slackware64-14.2 package source and did a full install (first time ever that I installed the Emacs package, go figure).
• At the end of the installation, do note yet exit! Instead, run “chroot /mnt” to enter the freshly installed system. Configure slackpkg with a suitable mirror, then run:
  # slackpkg upgrade-all
  This will install all the latest patches including the latest kernel.
• Finally, blacklist the kernel-generic and kernel-modules so that slackpkg will never replace our kernel accidentally.
• Create an initrd (the /usr/share/mkinitrd/mkinitrd_command_generator.sh script will help you finding the correct parameters) and copy the generic kernel and this initrd to the EFI partition. This is the elilo.conf file I ended up with:

  # cat /boot/efi/EFI/Slackware/elilo.conf
  chooser=simple
  delay=50
  timeout=50
  default=slackware142
  image=vmlinuz
      label=huge142
      read-only
      append="root=/dev/nvme0n1p7 vga=normal ro"
  image=vmlinuz-generic-4.4.75
      label=slackware142
      initrd=initrd_4.4.75.gz
      read-only
      append="root=/dev/nvme0n1p7 vga=normal ro"

• Now that the Slackware 14.2 installation is complete we have to ensure that we add a working kernel to it. I want to use the kernel as found in slackware-current because I know the 4.9.x series is good (liveslak proved that) and because slackware-current contains a kernel config that I can just re-use. Download the kernel source, and the kernel packaging scripts so that we can compile a kernel and its modules manually but still can wrap the results in package format and install those. Warning – when you try this at home, the actual kernel version may have moved beyond the “4.9.44” which I use in the example below. Just substitute the actual version instead:
  # CWD=$(pwd)
  # lftp -c “open http://slackware.osuosl.org/slackware64-current/source; mirror k”
  # cd k/
  # tar -C /usr/src -xf linux-4.9.44.tar.xz
  # cp config-x86_64/config-generic-4.9.44.x64 /usr/src/linux-4.9.44/.config
  Now we can compile that kernel (yes I compile kernels as root):
  # cd /usr/src/linux-4.9.44
  # make oldconfig
  # make -j 15 all
  # make install
  Now that the kernel is installed as /boot/bzimage and the modules as /lib/modules/4.9.44 we use the Slackware packaging scripts to create two packages:
  # cd $CWD/k/packaging-x86_64/kernel-generic
  # ./kernel-generic.SlackBuild
  # cd $CWD/k/packaging-x86_64/kernel-modules
  # ./kernel-modules.SlackBuild
  The two packages in /tmp can then be installed using “installpkg”. Do not use “upgradepkg” with your kernels – you will want to keep at least one previous kernel. The kernel-modules package will essentialy overwrite what’s in /lib/modules/4.9.44 but now with a package, we can control it through the package manager if needed. The kernel-generic package will have installed the new kernel as /boot/vmlinuz-generic-4.9.44. Copy that kernel to the EFI partition, and create a new initrd in the same location to match the kernel:
  # cp /boot/vmlinuz-generic-4.9.44 /boot/efi/EFI/Slackware/
  #  $(/usr/share/mkinitrd/mkinitrd_command_generator.sh -k 4.9.44 -r -a “-o /boot/efi/EFI/Slackware/initrd_4.9.44.gz”)
  Add a section for the new kernel to elilo.conf. You can just copy the existing section for “label=slackware142” and change the version numbers. Make sure that the “default” keyword has this new label as its value. We want the new kernel to boot by default.
• Exit the installed system’s chroot:
  # exit
• Then exit the installer’s chroot:
  # exit
• We are almost done. Unfortunately the eliloconfig of Slackware 14.2 did not add a Slackware entry to the computer’s EFI boot menu. So now that we are back in liveslak we need to fix this omission using the eliloconfig of slackware-current which is part of our liveslak:
  # eliloconfig /setup2hd /dev/nvme0n1p7
  This assumes the installed system is mounted under /setup2hd and the root partition is /dev/nvme0n1p7 . Change the parameters to match your situation. This time you will see that the Slackware entry is being created.
• Reboot the system.
• Have fun!

If I have omitted anything or steps are unclear, let me know. Now that I have Slackware on it, I can start thinking of how to add a virtualization solution. Either use my old scripts that wrap qemu and are very convenient and versatile, or go for qemu with libvirt and manage my virtual machines with virt-manager. The possibilities are endless. But first I need to get on with virtualizing my current server’s OS… its LAN services must stay operational but then in a VM on the new hardware.

OK, so I got frustrated too many times when waiting for packages that were compiling. My current build machine with its AMD ‘Athlon II X4 640’ CPU and 8 GB of RAM, is now 5 years old and obviously no longer quite fit for the tasks I need it to perform. Compiling Chromium for 64bit Slackware in a virtual machine took more than 24 hours last week (yes, for a single package). Basically, that convinced me to empty my stash of donated funds (thanks to all of you Slackware supporters) and order the most powerful midi tower I could buy for that money. What else is that money for, after all. Well, beer perhaps 🙂
Because the computer’s location will be the attic of my own house, its components (Seasonic PSU, Scythe CPU cooler, and the ‘be quiet Silent Base’ case itself) are chosen to minimize noise – it’s actually going to be sitting next to a bedroom wall.
The CPU I chose with the help of a friend, and after some consultation of my hardware store, is an AMD Ryzen 1700 at 3,0 GHz, along with 64GB of Corsair RAM (DDR4 at 3,0 GHz) but I am going to slightly overclock both. I added a 500GB Samsung 960 EVO SSD (NVMe) as well as a 4 TB Western Digital Red SATA disk.

With that machine I will be able to parallellize my build efforts and that means, I can give you more updates and still spend more time with my family. The whole hardware order costs slightly more than 1700 Euros which sounds like a lot (Robby pointed me to Ebay discard servers for a couple of 100 dollar) … while rackmount servers are cheap, you can not put them in your home because of the noise.
But it’s going to be worth it. And I will still have money left in my donations account to keep paying the rent for the ‘bear‘ server for at least another year. And then it’s rock bottom.

I will give more information when I actually get the hardware, install Slackware on it and create a virtual machine environment. I am not yet sure if I will keep using my own custom scripts to create ‘on-demand’ virtual machines or that I will switch to using virt-manager.
And I can finally also consider another “TODO” project that has been on the horizon for a long time: using Jenkins CI for ‘continuous build’ of my own (and Slackware’s) packages.
I will try to document as much of it as I can. I am sure that more people consider using virtualization to fence off processes, or create predictable (Slackware) OS environments using VM snapshots, or produce predictable builds. It’ll probably take months to get that point though… I am not in a hurry.

Again, thanks for all the donations during the past years that enabled me to do this purchase. You will hopefully benefit from it. Return on investment so-to-speak.

Eric