ARM Installation Guide

From ParabolaWiki
(Redirected from Parabola ARM installation)
Jump to: navigation, search
Warning: These new instructions are experimental and have not been tested yet. If these instuctions worked for you, do remove this warning and/or ask a parabola contributor to remove this warning.
Note: Single-board computers (SBC) typically run some variant of the GNU/Linux system, but that doesn't mean that you have total software freedom on these boards. Many of them do not work without running a nonfree startup program, such as the Raspberry Pi, and others based on the Broadcom VideoCore, Samsung Exynos, and Qualcomm Snapdragon System-on-a-Chip (SoC). Additionally, wireless networking and graphics hardware for SBCs are typically problematic for software freedom, just as with desktop and laptop hardware; and Parabola offers no support for such devices. See the FSF article for more info.

The Installation Guide for ARM computers is intended to assist experienced GNU/Linux users in installing Parabola tarball image. This page assumes a high-level of experience with GNU/Linux systems and utilities, especially the command line. Note that dealing with ARM computers is more complicated than common x86 computers because you will need to lean some some hardware specific knowledge.

Before beginning, we recommend you view the Arch Linux FAQ, and employ the man command to read the man page of any command they are not familiar with. The Parabola wiki, as well as the Arch Linux wiki, should be the primary source of information and your first resource during trouble-shooting.

1 Some hardware and booting background

It's best to see some concepts and definitions right from the start as they are reused in this installation guide.

1.1 System on a chip

In most of the ARM computers, the CPU and many peripherals are inside the same chip. This chip is called 'System On A chip' (often abreviated as SOC). Beside the CPU, it often also contains:

  • A GPU
  • A display controller
  • One or more USB host controllers
  • An USB OTG/Device controller
  • A SD card controller
  • A serial port controller
  • Many other periperals

1.2 Bootrom and booting

Most of such System on a chip have ARM code in a ROM (hardwired inside the chip) that is executed at startup. This is called a bootrom.

The bootrom is responsible for doing some hardware initialization and fetching the bootloader from a storage device. Often it is also possible to load a bootloader from USB or a serial port.

The bootloader then do some more (device specific) hardware initialization and loads the operating system.

In practice, on most hardware, after initializing some hardware, the bootrom will try to locate the bootloader from an external storage device. The external storage device has to be supported by the bootrom. For instance in the bootrom of Allwinner System on a chip, the bootrom doesn't support booting from SATA storage devices, but supports booting from uSD/SD cards, eMMC, SPI flash chips, etc.

The kind of storage devices the bootrom tries to find a bootloader on, and the order in which it tries them can often be configured by hardware and/or software.

2 ARM devices status

2.1 Freedom status

  • Most mass Storage devices like HDDs, SSDs, microSD, eMMC, USB keys have internal nonfree firmwares to function.
  • At least Some keyboards have firmwares, maybe some mices too.
  • Some displays also have internal firmwares while some other don't.
  • Beside the firmwares mentioned above, which are often invisible and in the peripheral themselves, many ARM computers can be used with 100% free software. This however doesn't mean that every hardware component is fully supported by free software. For instance on some ARM computers the 3D acceleration is working, while it doesn't work on some other, so It's better to plan ahead and choose your hardware accordingly.
  • See the Article on the single-board-computers at the FSF for more details on the topic. Beware that the article on the single-board-computers at the FSF also covers devices that do not have an ARM CPU, and that are not supported by Parabola because of that.
  • Parabola doesn't support ARM devices that don't even boot without nonfree software. This has several advantages:
    • If an ARM device is officially supported by Parabola, we can be sure that it can boot with free software.
    • Companies can't claim that a device is supported by Parabola if it requires nonfree software to boot. So this limits voluntary or involuntary misleading statements by companies.
    • As the boot interface between the bootloader and the distribution evolves, we can update every components of it (this installation manual, the bootloader, the distribution configuration) to work well together.
  • Some ARM devices have integrated nonfree bootloaders. While they could technically run Parabola, they are not supported for the reasons stated above.

2.2 64bit ARM

While there are no aarch64 (ARM 64bit) version of Parabola yet, it's still possible to use Parabola on some devices that have 64bit ARM CPU.

To do that you will need to use the linux-libre-64 kernel with the armv7h version of Parabola.

A special kernel is needed because 32bit ARM kernels dont't work as-is because:

  • The device tree for 64bit devices are not present in the 32bit kernel packages
  • Many drivers and hardware support for 64bit ARM hardware are probably be missing in the 32bit kernel configurations, so they are probably missing in the 32bit kernel packages as well.

To install linux-libre-64 you need to enable the following repository in /etc/pacman.conf:

Include = /etc/pacman.d/mirrorlist

Then you need to install linux-libre-64. That can be done with the following command

pacman -Sy linux-libre-64

However there are still some limitations:

  • This can only work for devices with CPU that support 32bit mode. Some arm64 CPUs don't support that mode.
  • We also need to package bootloaders for aarch64 devices.

At the time of writing, this is not done yet, and the aarch64 support was tested on a single board computer that had an integrated u-boot bootloader.

Once the kernel was installed, the following configuration file in /boot/extlinux/extlinux.conf was used to boot the hardware:

timeout 1
default linux-libre-64
label linux-libre-64
	kernel /boot/vmlinuz-linux-libre-64
	append loglevel=8 systemd.show_status=false rw root=/dev/mmcblk0p1
	fdtdir /boot/dtbs/linux-libre-64
	initrd /boot/initramfs-linux-libre-64.img

2.3 Linux

You should take into account the state of the software support in upstream projects before getting ARM devices. The project that has the biggest impact on hardware support is Linux, as it is required to make your hardware work:

Devices vendor typically ship an old version of the Linux kernel that is modified by them to support their hardware. The Free and Open source software communities are working actively to add support for many ARM devices in Linux.

If the device you want to get is not supported upstream (and that you don't intend to add such support yourself) you should rather look for another device. If your device requires a kernel version that is way older than the one used in your GNU/Linux distribution, it is almost unusable: it will be almost impossible to use because several software will not run with older kernels. For instance you won't be able to boot your device with systemd if your kernel is too old. If the vendor kernel is not too old yet, it will become too old years later as it will not be (indefinitely) updated by the device vendor.

2.4 Bootloaders

Bootloaders are less a concern, as you might be able to workaround the lack of support of modern filesystems and partitions. However finding why your device does not boot can be painful, so it's strongly advised to get devices which are support in upstream Free and Open source bootloader projects.

3 Know your hardware

ARM devices can be very different, and this has implications on the way you will install Parabola.

More specifically you will need to know:

  • From which storage device your device can boot. Most supported devices can boot from a microSD. Knowing the order in which it tries to boot on the storage devices can also be useful as it can help you understand what is going on if your device is not booting. Knowing the partitioning/filesystem boot requirements can also be handy in that case, if they are not mentioned in this installation guide. In that case it would be nice to add them in this guide.
  • How to get some feedback on what is going on:
    • Not all devices can be connected to a display, and when they can, the display is not necessarily available early at boot.
    • Some devices have an easily accessible serial port that can act as a display + keyboard replacement.
  • The state of the software support for your device:
    • What parts of the hardware works and what doesn't in Linux
    • The limitations of the bootloader (version) you are using

Here are some links to such information:

In addition we have some pages on the Parabola wiki for the devices we support:

Product Vendor Parabola wiki page
BeagleBone Black Texas Instruments, others? Computer/BeagleBone Black
Lime2 Olimex Computer/Olimex_Lime2
Lime2 (eMMC version) Olimex Computer/Olimex_Lime2_eMMC

In addition, the Computer page also list other ARM computers that need a bit more work in Parabola and/or this installation guide to be officially supported. Note that some of them they might already contains enough information to be installed by more experienced people but lack information on the status and so on.

Make sure to check the page for your device in the Computer page as devices pages contains device specific information that is sometimes required to successfully install Parabola on ARM on them.

4 Bootloaders and their limitations

4.1 u-boot

u-boot supports the ext2, ext4, and ext4 filesystem, however, at the time of writing, the versions used in Parabola doesn't support all 'extensions' of the ext4 filesystem.

If you use unsupported extensions you would usually be able to list the filesystem content with ext4ls or similar commands, but you usually won't be able to read some files. When this is the case u-boot will output some errors at boot and booting will fail.

To make sure it doesn't happen, you can format the ext4 filesystem your kernel and initramfs resides on like that:

mkfs.ext4 -F -O ^metadata_csum,^64bit /dev/CARD1

In the commands above and below, replace /dev/CARD1 by the path of the SD-card, which could be /dev/mmcblk0 if you use a 'native' SD reader, or /dev/sdb1 for instance if you have an 'usb mass storage' SD reader.

To see which extensions you have, you can use the following command:

tune2fs -l /dev/CARD1

TODO: Check the commands below to remove unnecessary fsck

Ext4 filesystems can also be converted to remove metadata_csum like that:

fsck.ext4 -C 0 -f /dev/CARD1
tune2fs -O ^metadata_csum /dev/CARD1
fsck.ext4 -C 0 -f /dev/CARD1

And for removing 64bit:

fsck.ext4 -C 0 -f /dev/CARD1
resize2fs -s /dev/CARD1
fsck.ext4 -C 0 -f /dev/CARD1

5 Releases tarballs

Download and verify the Parabola ARM Release tarball

  • The release tarballs are signed and it is highly recommend to verify their signature before use. On Parabola GNU/Linux-libre, this can be done by using pacman-key -v <tarball-file>.sig. On other systems: gpg --verify <tarball-file>.sig. You may have to import the key from a keyserver with gpg --recv-keys <0x key ID>.
  • Checksums are also provided in the accompanying SHA512SUMS and WHIRLPOOLSUMS files. They can be verified with: sha512sum -c SHA512SUMS and whirlpool-hash -c WHIRLPOOLSUMS.

6 Partition disks

See partitioning for details.

Remember to create any stacked block devices like LVM, LUKS, or RAID.

If you ARM computer will use a bootloader provided by Parabola (for instance the uboot4extlinux), you will need to use an MBR and not GPT.

With MBR, most partitioning tools like fdisk, sfdisk and gparted leave an empty space of 1MiB before your first partition by default.

The bootloader Parabola provides are installed in this 1MiB (if for some reasons that's not the case that's a bug).

As bootloaders grow over time and that Parabola developers are humans and sometimes make mistakes, you may want to increase that 1MiB a bit more to avoid issues. Though Parabola developers typically test the bootloaders they produce on real hardware to detect and fix issues like that before they could damage users filesystems.

If you use such stacked block devices, remember to generate an initramfs and configure the bootloader to use it.

Also make sure to check your device wiki page in Computer as some device (like the Asus Chromebook C201) have special requirements for partitioning.

7 Format the partitions

See File systems for details.

You will most likely need to use a filesystem supported by your bootloader. Do not use any features it does not support for the files in /boot. (ext4 has worked well in our tests)

Some System on a chip may also require the bootloader to reside on a specific partition. (For this case, the above 1mb empty space may not work)

8 Mount the partitions

We now must mount the root partition on /mnt. You should also create directories for and mount any other partitions (/mnt/boot, /mnt/home, ...) and mount your swap partition if you want them to be detected by genfstab.

9 Enable executing arm code on x86

If you are installing from an x86 computer, you will need to enable running non-x86 binaries transparently. This can be done by telling the Linux kernel to use automatically qemu to do that.

If the computer you use to do the installation already runs Parabola, you can do it with:

# pacman -S qemu-user-static-binfmt
# systemctl start systemd-binfmt.service

You will then need to copy qemu-arm-static to the target rootfs. If the target rootfs is mounted in /mnt, you will then need to do that:

# mkdir -p /mnt/usr/bin/
# cp /usr/bin/qemu-arm-static /mnt/usr/bin/

The Building_armv7h_packages_on_a_x86_system page also have more background information on that.

Once this is done, you will be able to use as chroot, arch-chroot, and pacstrap transparently.

10 rootfs installation

You can either install the rootfs:

  • from the released tarball
  • directly with pacstrap

10.1 From the released tarball

After mounting the filesystem in /mnt, extract Parabola in the rootfs partition:

$ sudo tar xpf <tarball-file> -C /mnt/ --numeric-owner

Here --numeric-owner is used to make sure that everything is still fine if user and group ids differs between the tarball and the computer you're using to run the tar command above. This also enables you to run that command from another GNU/Linux distribution than Parabola (like Trisquel for instance).

10.2 With pacstrap

First we need to install arch-install-scripts to be able to use the pacstrap command

pacman -S --needed arch-install-scripts

Before installing, you may want to edit /etc/pacman.d/mirrorlist such that your preferred mirror is first. This copy of the mirrorlist will be installed on your new system by pacstrap as well, so it's worth getting it right.

To install OpenRC as the init-system instead of systemd, the [nonsystemd] repo must be enabled before proceding. This is accomplished by deleting the '#' character from its entry lines in /etc/pacman.conf.

#Include = /etc/pacman.d/mirrorlist
Warning: When installing OpenRC, some of the installation steps will differ, such as setting the hostname and keymap, and enabling services. Refer to the OpenRC page for the specifics.

You then need to import, trust and install the archlinuxarm keyring because when possible, Parabola leverages free packages that originally came from Arch ARM.

# pacman -S --needed archlinuxarm-keyring

You then need to copy qemu-arm-static inside the target root directory:

# mkdir -p /mnt/usr/bin
# cp /usr/bin/qemu-arm-static /mnt/usr/bin

This will enable programs like pacstrap, arch-chroot, or chroot to execute ARM code transparently

You can then install the base system using pacstrap:

# pacstrap -C /usr/share/pacman/defaults/pacman.conf.armv7h /mnt/ base                                     // for SystemD
# pacstrap -C /usr/share/pacman/defaults/pacman.conf.armv7h /mnt/ base libelogind udev-init-scripts        // for OpenRC

You can install additional packages passing base and the names of these packages as arguments after the root directory of the new installation (all packages from the base group are installed if no package is specified). If you have a btrfs root, you probably want to install also btrfs-progs.


If you face GPG errors when running # pacstrap /mnt, you can try to fix them with:

# pacman -Sfy archlinux-keyring

Generate an fstab with the following command (if you prefer to use UUIDs or labels, add the -U or -L option, respectively):

# genfstab -p /mnt >> /mnt/etc/fstab

Next we chroot into our newly installed system:

# arch-chroot /mnt

11 Configure the system

  • Write your hostname to /etc/hostname
  • Symlink /etc/localtime to /usr/share/zoneinfo/Zone/SubZone. Replace Zone and Subzone to your liking. For example:
# ln -s /usr/share/zoneinfo/Europe/Athens /etc/localtime
  • Set locale preferences in /etc/locale.conf
  • Add console keymap and font preferences in /etc/vconsole.conf
  • Uncomment the selected locale in /etc/locale.gen and generate it with locale-gen
  • Configure /etc/mkinitcpio.conf as needed (see mkinitcpio) and create an initial RAM disk with:
# mkinitcpio -p linux-libre

Add your user to the relevant group such as:

# gpasswd -a YourActualUserName video
Note: You can visit Beginners' Guide#Chroot and configure the base system to learn about further configuration options.

12 Change or set the root password

The current release tarball has a password set, so if you use it, you will need to change the root password, else you won't be able to log into the installation. This step will probably be un-necessary in future tarball releases.

If you don't use the release tarball, you might also want to set a root password.

Setting or changing the root password be done by running the passwd command inside the chroot.

13 Installing the bootloader

13.1 Bootloader provided by parabola

Parabola provides bootloaders for many devices. If parabola has one for your ARM computer, you can simply chroot and install it:

# arch-chroot /mnt
# pacman -S uboot4extlinux-a20-olinuxino-lime2
resolving dependencies...
looking for conflicting packages...

Packages (1) uboot4extlinux-a20-olinuxino-lime2-2017.01-1.1

Total Download Size:   0.20 MiB
Total Installed Size:  0.53 MiB

:: Proceed with installation? [Y/n] 

However merely installing the package isn't sufficient to make the device boot from that bootloader.

This is the same than with x86 computers: on x86 computers, after installing the GRUB package, you also need to install GRUB itself, so that the BIOS or UEFI could find GRUB and run it.

Here all the ARM computers supported by Parabola have an ARM system on a chip with a bootrom (the bootrom is is read-only ARM code inside the silicon). At power on, that bootrom will be executed and will try to fetch the bootloader from various locations on various storage device (microSD, eMMC, etc) and execute it. See the Bootrom and booting section for more details.

So like with x86 computers, we need to install the bootloader to specific locations on the storage device for it to be found and executed.

This is why at the end of the package installation, you will be asked if you want to do that. It will look like that:

A new U-Boot version needs to be flashed onto /dev/mmcblk0.
Do you want to do this now? [y|N]

If you are installing on an x86 system, your sd card should be available at /dev/sdb. Find the exact location using command lsblk

When that happens, double check that /dev/sdb corresponds to the storage device you're installing Parabola on and not your x86 laptop hard disk or SSD you are installing from.

This is where the 1MB space comes into play. Your bootloader will be stored in those 1MBs. Write the bin file using the dd command over your complete card.

dd if=/boot/u-boot/images/u-boot-sunxi-with-spl.bin of=/dev/sdb bs=1024 seek=8

The installation of u-boot bin file will give a prompt like the one shown below:

526+1 records in
526+1 records out
539287 bytes (539 kB, 527 KiB) copied, 0.165519 s, 3.3 MB/s
==> WARNING: Remember to set up your kernels in /boot/extlinux/extlinux.conf

Now, you need to edit /boot/extlinux/extlinux.conf to make it boot. For most cases, default extlinux.conf files works well if your kernel lies at 1st partition. If your root filesystem lies at different partition, edit the undefined with the corresponding partition. sdbr partition as seen on Parabola x86 will be replaced by mmcblk0pr on arm board. eg. sdb2 -> mmcblk0p2.

Several bootloaders are available in Parabola.

13.1.1 U-Boot4Extlinux

All the u-boot4extlinux packages implement the distroboot protocol.

The distroboot protocol is meant to be able to boot multiple distributions with the exact same u-boot binary and also enable distributions to support a large number of ARM computer without having to make specific changes to boot each of them.

That standard also supports syslinux configuration files among other ways to boot.

This is really nice as that configuration file format is also used by Extlinux and Syslinux on x86 computers.

While Extlinux and Syslinux are well known and used than GRUB on x86 computers, they are still used as the bootloader in live CDs and many other applications, so there is pretty good information on their configuration file format.

They also allow for interactive multi-boot and multiple kernels.

To successfully boot the extlinux.conf needs to be in /extlinux/extlinux.conf or /boot/extlinux/extlinux.conf in the first partition or a partition that has the bootable flag set.

If needed, the bootable flag can be set with sfdisk. Below is an example to set the bootable flag to the second partition:

# sfdisk /dev/CARD -A 2

Here /dev/CARD needs to be replaced by the path of the SD-card, which could be /dev/mmcblk0 if you use a 'native' SD reader, or /dev/sdb1 for instance if you have an 'usb mass storage' SD reader.

In addition that partition needs to be readable by u-boot. So if u-boot doesn't support BTRFS for instance it would be better to create a /boot partition so that extlinux.conf could be installed in it.

For more details see the distro boot protocol documentation in u-boot source code.

13.1.2 U-Boot
Warning: Standalone uboot packages only work for a single kernel: linux-libre. If you use other or multiples kernels you should look for one of #U-Boot4Extlinux or #U-Boot4GRUB instead.

Installing the appropriate U-Boot package will copy the bootloader to your storage device's boot sector. Manual intervention shouldn't be necessary.

Once installed, you will need to run the following command to configure it:

# cd /boot && ./mkscr
13.1.3 U-Boot4GRUB

uboot4grub packages are under development yet for U-Boot with GRUB support. At the moment, we have some packages for testing and debugging from [libre-testing].

Note: If you wish to use this repo add the following lines to /etc/pacman.conf:
Include = /etc/pacman.d/mirrorlist
13.1.4 GRUB

grub claims some support for ARMv7 machines with EFI support (GRUB#UEFI_systems). Parabola hackers are investigating using this.

Note: By default grub is built for systems which have RAM at address 0x08000000. However SBC boards which we are targeting have RAM starting from different values (eg. BeagleBone and BeagleBone Black are 0x82000000) so we need to adjust GRUB_KERNEL_ARM_UBOOT_LINK_ADDR to make sure it matches U-Boot load_addr. Therefore, we are creating grub packages with specific suffix for it (eg. grub-am335x_bone for BeagleBone and BeagleBone Black)

13.1.5 Which bootloader package to use for which device?

Here's a list of devices with their corresponding bootloaders packages:

Computer(s) (vendor, product) Bootloader(s) packages Bootrom constraints
  • Banana Pi
  • BeagleBoard
  • BeagleBoard-xM
  • BeagleBone
  • BeagleBone Black
  • TBS TBS2910
  • PandaBoard
  • PandaBoard ES

There are many more devices supported, a quick search in Parabola's packages shows many more bootloaders

13.1.6 Bootloader configurations

Our kernel images use custom names (eg. /boot/vmlinuz-linux-libre-grsec) to allow for various kernels to coexist via a multi-boot bootloader like GRUB or Extlinux. You really need to verify that your bootloader is configured to look for the right kernel name.

Note: We don't have uImage packages available in Parabola since we are adapting our kernels for GRUB and Extlinux compatibility. However, if you won't use them, we suggest you use our script to create a new one based on the kernel that you want.

Also remember to configure the bootloader to use an initramfs if you use any stacked block devices like LVM, LUKS, or RAID.

For instance for extlinux, it can be done by adding an initrd line, which would meake an entry look like that:

label Parabola GNU/Linux-libre, linux-libre kernel
	kernel /boot/vmlinuz-linux-libre
	initrd /boot/initramfs-linux-libre.img
	append console=ttyS0,115200n8 quiet rw root=/dev/mapper/vg-rootfs
	fdtdir /boot/dtbs/linux-libre/

13.2 Bootloader not provided by parabola

13.2.1 Barebox
13.2.2 Already present on the device

Some of the devices pages in Computer like the page for the Asus Chromebook C201 have information on how to boot Parabola on the bootloader that is already present on the device.

14 Unmount and reboot

If you are still in the chroot environment type exit or press Ctrl+D in order to exit. Earlier we mounted the partitions under /mnt. In this step we will unmount them:

# umount /mnt/{boot,home,}

Now you can boot the ARM computer and then login with the root account.

15 Configure pacman

Edit /etc/pacman.conf and configure pacman's options, also enabling the repositories you need.

See Pacman and Official Repositories for details.

Also consider using Pacman2pacman, a peer to peer package system, in order to reduce load on Parabola servers.

16 Update the system

At this point you should update your system.

See Upgrading packages for instructions.

17 Add a user

Finally, add a normal user as described in User management.

18 Service management

Parabola GNU/Linux-libre uses a:systemd as init, which is a system and service manager for Linux. For maintaining your Parabola GNU/Linux-libre installation, it is a good idea to learn the basics about it. Interaction with systemd is done through the systemctl command. Read a:systemd#Basic systemctl usage for more information.

19 Conclusion

Your new Parabola GNU/Linux-libre base system is now a functional GNU/Linux environment.

You can now continue here.

20 Adding support for an ARM computer in Parabola

To add support for a new ARM computer in Parabola:

  • That computer needs to be able to boot with free software
  • The installation instructions need to explain how to install Parabola on it
  • The bootloader should be packaged if it needs to be provided by Parabola

In addition if we want to continue supporting that device for a long time:

  • It should work with upstream Linux without any additional patches
  • For the bootloader if Parabola provides it it would also be a good idea for it to work without any patches
  • Parabola developers and users need to be able to get that device too somehow, in order to be able to test any changes on it.

21 See also

22 Troubleshooting

22.1 Mkinitcpio

22.1.1 WARNING: No modules were added to the image. This is probably not what you want.

If when creating the initramfs image with mkinitcpio, you get the message

==> WARNING: No modules were added to the image. This is probably not what you want.

Just ignore, you should be able to boot anyways.

22.1.2 ERROR: kernel version extraction from image not supported for `armv7' architecture

If when running mkinitcpio you get the message

ERROR: kernel version extraction from image not supported for `armv7' architecture

Or similar (like armv7h, armv7l, etc) edit /bin/mkinitcpio and where it says $arch leave it as

if [[ $arch != @(i?86|x86_64|armv7?) ]]; then
    error "kernel version extraction from image not supported for \`%s' architecture" "$arch"
22.1.3 ERROR: invalid kernel specified: '/boot/vmlinuz-linux-libre'

In this case edit /etc/mkinitcpio.d/linux-libre-xxx.preset and where it says ALL_kver="/boot/vmlinuz-linux-libre-xxx" change /boot/vmlinuz-linux-libre-xxx with the kernel release, which should be the output of uname -r, if you are using that kernel. You can see them with

$ ls /lib/modules
Note: The xxx stands for the kernel special name.

22.2 Iceweasel


If some websites give you this error on Iceweasel (an probably on Icecat) with a message like:

Your connection is not secure

The website tried to negotiate an inadequate level of security. uses security technology that is outdated and vulnerable to attack. An attacker could easily reveal information which you thought to be safe.   The website administrator will need to fix the server first before you can visit the site.


Then open a new tab and write about:config, then search spd and disable network.http.spdy.enabled

23 Acknowledgement

This wiki article is based on the Installation Guide which is itself based on the ArchWiki, with non-FSDG bits that may have been removed from it.