Índice

Reuni neste texto uma experiência recente com a instalação do Slackware64 em um notebook com um SSD 120GB e com Unified Extensible Firmware Interface (UEFI), uma camada entre o Sistema Operacional e o firmware da máquina, que vem ganhando espaco do antigo BIOS.

O note em questão é um Dell Inspiron Modelo P33G que no modo legacy suporta boot apenas pelos dispositivos:

  • USB Storague Device
  • CD/DVD/CD-RW Drive
  • Removable Drive

Ou seja, ele não dá boot através de um sistema instalado em um disco conectado ao barramento SATA, o seu HD! Até então nem mesmo imaginava que tal “coisa” existia e, como alguns, pensava que sempre pudesse me esquivar do tal UEFI.

Para a instalação do Slackware nesta máquina, não existe nenhum grande obstáculo, basta desabilitar o UEFI, habilitar o modo Legacy e fazer a instalação pelo DVD de instalação do Slackware. O problema surge após a instalação, pois não é possível iniciá-lo, a menos que utilize um pendrive ou um CD/DVD de inicialização e passar alguns parâmetros para poder iniciar no sistema instalado.

Na primeira vez que instalei o Slackware nesta máquina, burlei o UEFI através de um instalação do Ubuntu, mas isto foi quando possuía um HD de 1TB no notebook. Com a instalação do SSD de 120GB não estava disposto a repetir esta manobra.

Assim como em outras distribuições, o Slackware também tem se movido para dar suporte ao UEFI, o que estará disponível na próxima versão, 14.1 ou 15? No momento o boot via UEFI somente pode ser feito através da versão Current do Slackware32/64.

Sumário

1. Criando a Mídia de Instalação

Para criar uma mídia de instalação, será necessário um segundo micro com o sistema instalado para os procedimentos a seguir. Inicialmente baixe uma cópia dos pacotes da versão Current do Slackware64. Geralmente mantenho uma cópia do Slackware64-current em minha máquina, mas caso não possuam uma execute os procedimentos a seguir:

  • baixar o Slackware64 para uma pasta (slackware64): 
    mkdir slackware64
[prompt]rsync -Pavv --delete \
ftp.slackware.com::slackware/slackware64-current/EFI slackware64/
...
[prompt]rsync -Pavv --delete \
ftp.slackware.com::slackware/slackware64-current/slackware64 slackware64/
...

    isto pode levar algum tempo, o que depende de sua conexão;

  • copiar os pacotes para um pendrive fat32 (supondo o pendrive em /dev/sdb1): 
    mount /dev/sdb1 /mnt
[prompt]rm -rf /mnt/*    # limpa o pendrive
[prompt]cd slackware64/
[prompt]cp -rvf . /mnt/
...
[prompt]umount /mnt
  • caso esteja utilizando uma distribuição Slackware com o sbopkg instalado, compile o pacote efibootmgr com os comandos a seguir: 
    sbopkg -r
...
[prompt]sbopkg -b efibootmgr
...

    Este pacote serve para registrar uma entrada no UEFI para a inicialização do sistema. O pacote será criado em /tmp. Copie-o para o pendrive:

    cp /tmp/efibootmgr-0.6.0-x86_64-1_SBo.tgz /mnt/extra
[prompt]umount /mnt

Após isto o pendrive está pronto para a instalação do Slackware com UEFI.

Fiz o script mkslackusb, para fazer o download, baixar ou compilar o pacote efibootmgr e copiar tudo para um pendrive. O bash script é apresentado abaixo, use-o com cuidado pois pendrives ou discos conectados à porta USB, podem ter seu conteúdo completamente apagado.

Se a partição em sd?1 do seu pendrive não for fat32 (vfat), o script será interrompido. Neste caso basta trocar o pendrive e executá-lo novamente. Isto pode salvar a vida de alguns desprevenidos.

O script também pode ser executado em qualquer outra distribuição GNU/Linux. Neste caso o pacote efibootmgr, o qual não é distribuído pelo Slackware, será baixado de um espelho meu através do link efibootmgr-0.6.0-x86_64-1_SBo.tgz.

Caso execute o script em um Slackware com o sbopkg, este pacote será compilado. O pacote efibootmgr será copiado para a pasta /extra do pendrive, para ser instalado durante e após a instalação.

Segue abaixo o código do script para conferência/alterações:

#!/bin/bash
#
# Download Slackware-current files and make a USB UEFI boot disk
# by Rudson R. Alves
#
 
FILES="EFI extra slackware64"  
# extra is optional

if [ -z "$ARCH" ]; then
  $ARCH=`uname -m`
fi

if $ARCH == "x86_64"; then
  ARCH="64"
else
  ARCH=""
fi

URSYNC="rsync.osuosl.org::slackware/slackware${ARCH}-current/"
SLACK_DIR="slackware${ARCH}"
MNT=/mnt

# check pendrive vfat partition in /dev/sdb1,sdc1 and sdd1 
function pendrive_check() {
  USBDISK=`dmesg | grep '^ sd[bcd]: sd[bcd]1' | sort | uniq | tail -1 | awk '{print $2}'`
  echo "$USBDISK"
}

echo -e "\e[37;1mCheck USB device...\e[m"
USBDISK=`pendrive_check`
if [ ! -z "$USBDISK" ]; then
  if [ -e "/dev/$USBDISK" ]; then
    echo -e "\n\e[31;1;5mRemove all USB Disk/Pendrive/Flash Drive/USB ..."
    echo -e "before continue...\e[m\n"
    exit 0
  fi
fi

echo -e "\e[37;1mDownload packages...\e[m"
mkdir slackware64 2>/dev/null
cd slackware64
for d in $FILES; do
  echo -e "\e[37;1mDownload $d...\e[m"
  rsync -Pavv --delete $URSYNC/$d .
done
 
echo -e "\n\n\e[37;1;5mInsert a USB Flash Drive..."
echo -e "WARNING: All files in the USB Flash Drive will be deleted\e[m\n"

while true; do
  USBDISK=`pendrive_check`
  if [ -z $USBDISK ]; then 
    sleep 1
    continue
  fi
  USBDEV=/dev/$USBDISK
  if [ -e $USBDEV ]; then break; fi
  sleep 1
done

mount $USBDEV $MNT
FS=`grep "$USBDISK" /etc/mtab | awk '{ print $3 }'`
if [ "$FS" != "vfat" ]; then
  umount $MNT
  echo -e "\e[31;1mInsert a fat32 pendrive and run again the script...\e[m"
  exit 0
fi

rm -rf $MNT/* 2>/dev/null
cp -rvf . $MNT/
cd ..

if which sbopkg; then
  if [ ! -e /tmp/efibootmgr-0.6.0-x86_64-1_SBo.tgz ]; then
    echo -e "\n\e[37;1mBuild efibootmgr...\e[m"
    sbopkg -b efibootmgr
  fi
  mkdir $MNT/extra 2>/dev/null
  cp /tmp/efibootmgr-* $MNT/extra/
elif [ "$ARCH" == "64" ];then
  wget -P /tmp/  http://localhost/linux/uefi/efibootmgr-0.6.0-x86_64-1_SBo.tgz
fi

echo -e "\nWait while you finish recording files..."
umount $MNT

echo -e "\n\n\e[37;1mSlackware$ARCH USB UEFI disk is read!"
echo -e "Remove the USB disk.\e[m"

Ao terminar de criar o pendrive, vá para o micro em que irá instalar o Slackware e configure o boot com UEFI, mas sem o Secure Boot:

dell_uefi-01

Coloque o pendrive com o boot UEFI no computador e reinicie o sistema.

2. Iniciando a Instalação do Sistema

Ao iniciar o sistema a pasta /EFI do pendrive deve ser lida pelo UEFI e uma tela semelhante à figura abaixo deve aparecer.

dell_uefi-02

Pressione ENTER e aguarde o sistema iniciar. Caso deseje fazer um teste em um máquina virtual antes, tenha paciência neste momento pois a carga do kernel pode ser um pouco demorado.

2.1. Preparando o Disco SSD para a Instalação

Com a inicialização do sistema, a primeira tarefa será preparar as partições no disco SSD, para a instalação do sistema.

Como na maioria dos notebook, neste não há espaço para a colocação de um segundo disco magnético, o que seria o mais adequando dado às limitações de escrita dos SSDs. Com isto será necessário alocar todas as partições do sistema no SSD, inclusive a partição de swap, indispensável se você pretende usar a habilidade de hibernação do notebook.

Os demais diretórios de alta escrita, como /tmp, /var/tmp, … podem ser montados em memória, uma vez que 6G de RAM é mais que suficiente para executar um desktop GNU/Linux.

Atencão: esta instalação pressupõem um disco limpo, sem qualquer outro sistema instalado. Alguns comandos apresentados a seguir podem ser destrutivos caso deseje manter algum sistema pré-instalado para fazer dual boot. Neste caso é essencial conhecer o que está fazendo para não perder, permanentemente, outros sistemas instalados.

2.1.1. Umas poucas Palavras sobre Particionamento e Alinhamento

As mídias SSDs são rápidas, se comparadas aos discos magnéticos convencionais, no entanto são muito mais caras e ainda possuem severas limitações quanto ao número de ciclos de reescrita (o que geralmente varia entre 10.000 e 3.000 ciclos, dependendo da tecnologia empregada nas memórias flash). O Calos Morimoto possui um texto muito instrutivo explicando as tecnologias das memórias flash empregadas nos discos SSDs comercializados, recomendo a leitura do seu artigo Entendendo os SSDs.

Em essência, se deve ponderar muito as escritas em discos SSD, para maximizar a longevidade das memórias flash. Os blocos de memória em um SSDs não possuem endereço fixo, como ocorem em disco hígidos magnéticos, e portanto não há problema nehum em particionar o disco, uma vez que isto não irá condicionar um bloco de memória flash a uma dada partição nas rescritas subsequentes.

Até onde entendi, os blocos são alocados dinamicamente, priorizando a reescrita e não a sua localização física nos chips flash. Com isto, um bloco de memória em um ciclo de reescrita “n”, somente será reescrito após todos os outros blocos remanejáveis do SSD terem sido reescritos neste ciclo mesmo ciclo. Esta foi o solução encontrada pela indústria para contornar a limitação dos ciclos de reescrita nos discos SSDs.

Enquanto os discos rígidos convencionais são subdivididos em setores de 512 bytes de tamanho, os SSDs são subdivididos em blocos de 4096 bytes (8 x 512 bytes). As motivações desta estrutura são histórias, vindo do crescente aumento do tamanho dos disco rígidos modernos além da crescente necessidade de alta confiabilidade nas mídias modernas. Recomendo a leitura do texto “Linux on 4KB-sector disks: Practical advice” de Roderick W. Smith, para uma abordagem mais profunda.

Por conta deste pequeno detalhe é necessário tomar alguma atenção sobre o alinhamento das partições, para que estas não iniciem ou terminem em meio a um setor de 4096 bytes. Felizmente os programas modernos de particionamento são mais cuidadosos sobre estes requisitos, alinhando as partições em blocos de MBytes (256 x 4096 bytes) ou outros múltiplos inteiros de 4096 bytes.

Observe que no caso dos SSDs o alinhamento é necessário, não apenas por questão de desempenho, mas também para se evitar sobrescrita desnecessárias aos blocos de memórias que forem alocados entre o início e o final de uma partição.

2.1.2. As Partições para o Sistema

O disco empregado é um Force GT Sata 3 de 120GB. Embora seja um disco pequeno é mais que suficiente para um note de trabalho. Separei o disco de 1TB que veio com o note para armazenamento externo.

Para o sistema irei criar quatro partições, com os propósitos:

  • EFI system partition – uma partição fat32 com 100MB para a instalação boot UEFI. Um boot com o elilo ocupa em média 30MB, mas aconselho deixar alguma folga, principalmente para a instalação de boots futuros;
  • Linux root – partição para instalação do sistema, 20GB. Suficiente para a instalação do Slackware com muitos aplicativos;
  • Linux swap – 8GB de swap. Se tiver um disco rígido magnético fixo em sua máquina, considere remover esta partição do SSD. Em um notebook com 4GB ou mais de memória, é muito pouco provável que chegue a carregar esta área de swap, no entanto, ela é necessária caso venha a usar o recurso de hibernação do notebook;
  • Linux home – o restante do disco, para armazenar os arquivos dos usuários.

Geralmente utilizo o fdisk, ou o cfdisk, para fazer os particionamentos em minhas instalações, mas para utilizar o UEFI é necessário usar uma tabela de particionamento GUID (GPT), que é o padrão do Extensible Firmware Interface (EFI) (atualmente evoluído para UEFI).

Com isto será necessário usar outras ferramentas, mas ainda disponíveis na mídia de instalação do Slackware:

  • parted – o mesmo particionador utilizado pelo gparted no instalador do Ubuntu, além de várias outras distribuições;
  • gdisk – um aplicativo semelhante ao fdisk para tabelas de partição GPT.

O gdisk é a opção mais óbvia, dado sua semelhança com o fdisk e sua simplicidade. Mas, para registro, apresento o particionamento com o parted na seção seguinte. O parted é muito flexível mas também mais complexo.

2.1.3. Particionando o SSD com o gdisk

Tive alguns problemas com a seleção do tipo de partição escrito no disco com o parted, o que me levou a reeditar a tabela de partição com o gdisk ao final. Por isto achei mais conveniente apresentar o particionamento pelo gdisk primeiro.

A versão 0.8 em diante do gdisk faz o alinhamento adequado das partições, já trabalhando com múltiplos de 4kB (1MB = 32*8*4kB) de forma transparente, sem a necessidade de maiores detalhes.

Para criar as partições, abra o particionador gdisk e crie uma nova tabela de partição GPT, com o comando “o”:

gdisk /dev/sda
GPT fdisk (gdisk) version 0.8.5

Partition table scan:
  MBR: MBR only
  BSD: not present
  APM: not present
  GPT: not present


***************************************************************
Found invalid GPT and valid MBR; converting MBR to GPT format.
THIS OPERATION IS POTENTIALLY DESTRUCTIVE! Exit by typing 'q' if
you don't want to convert your MBR partitions to GPT format!
***************************************************************

Command (? for help): o
This option deletes all partitions and creates a new protective MBR.
Proceed? (Y/N): y

Em seguida crie as partições com as informações da tabela abaixo:

[TABLE=53]

O quadro abaixo apresenta todos os passo empregados para a criação das partições propostas com o gdisk:

gdisk /dev/sda

... continuando ...

Command (? for help): n
Partition number (1-128, default 1) : [ENTER]
First sector (..., default = 2048) or ...: [ENTER]
Last sector (...) or ...: +100M
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): ef00
Changed type of partition to 'EFI System'

Command (? for help): n
Partition number (2-128, default 2) : [ENTER]
First sector (...) or ...: [ENTER]
Last sector (...) or ...: +20G
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): [ENTER]
Changed type of partition to 'Linux filesystem'

Command (? for help): n
Partition number (3-128, default 3) : [ENTER]
First sector (...) or ...: [ENTER]
Last sector (...) or ...: +8G
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): 8200
Changed type of partition to 'Linux swap'

Command (? for help): n
Partition number (2-128, default 2) : [ENTER]
First sector (...) or ...: [ENTER]
Last sector (...) or ...: [ENTER]
Current type is 'Linux filesystem'
Hex code or GUID (L to show codes, Enter = 8300): [ENTER]
Changed type of partition to 'Linux filesystem'

Command (? for help): p
Disk /dev/sda: ...
...

Number  Start (sector)   End (sector)  Size      Code  Name
   1            2048         206847   100.0 MiB  EF00  EFI System
   2          206848       42149887   20.0 GiB   8300  Linux filesystem
   1        42149888       58927103   8.0 GiB    8200  Linux swap
   1        58927104      251658206   91.9 GiB   8300  Linux filesystem

Command (? for help): w

Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING
PARTITIONS!!

Do you want to proceed? (Y/N): y

Observe que a primeira partição deve começar no setor 2048 que corresponde a 1MiB = 2048×512. Não entendi bem esta necessidade, mas parece ser um consenso que o primeiro mega byte dede ser preservado para se ter o alinhamento dos blocos desejados. Este é o argumento empregado, mas confesso que não estou muito convencido embora acredito que seja alguma outra necessidade do sistema.

Com isto as partições estão prontas para a instalação. A menos que deseje refazer as partições com o parted, pule a próxima seção e siga para a seção 2.2. Instalação.

2.1.4. Particionando o SSD com o parted

Inicie o parted com a opção “-a optimal”, para alinhar as partições à topologia do disco. 

parted -a optimal /dev/sda
...

No prompt do parted, crie uma nova tabela de particionamento GPT com o comando a seguir:

mklabel gpt
...

Em seguida crie a partição “EFI system partition”:

(parted) mkpart
Partition name []? "EFI system partition"
File system type [ext2]? fat32
Start? 1
End? 101
(parted)

Um inconveniente do parted é que se deve prestar muita atenção no início e fim das partições, pois irá necessitar destes números ao construir as próximas partições. Esta primeira partição deve iniciar em 1 (1MB), para garantir o alinhamento à estrutura do SSD.

Em seguida mude a flag desta partição para bootável:

(parted) set 1 boot on
(parted) print
Model: ATA Corsair Force GT (scsi)
Disk /dev/sda: 120GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size      File system   Name                  Flags
 1      1024kB  101MB   99.6MB    fat32         EFI system partition  boot

O comando print mostra as partições criadas até o momento. O fat32, eventualmente não aparecerá, até que faça a formatação da partição.

A seguir faça a partição de 20GB para o “Linux root”:

(parted) mkpart
Partition name []? "Linux root"
File system type [ext2]? jfs
Start? 101
End? 20101
(parted)

Como a partição anterior terminou em 101MB, esta partição deve iniciar em 101MB e terminar em 101MB+20000MB, ou seja 20101MB. Para a partição de swap de 8GB, faça como segue:

(parted) mkpart
Partition name []? "Linux swap"
File system type [ext2]? linux-swap(v1)
Start? 20101
End? 28101
(parted)

Como antes, a partição deve começar no final da partição anterior (20101M) e terminar 8000M à frente (28101M). E por fim a partição “Linux home” com o que restou do disco.

(parted) mkpart
Partition name []? "Linux home"
File system type [ext2]? jfs
Start? 28101
End? -1
(parted)

Como antes, esta última partição iniciou no final da partição anterior (28101M) e terminou no final do disco (-1). Um print agora deve mostrar algo como:

(parted) print
Model: ATA Corsair Force GT (scsi)
Disk /dev/sda: 120GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size      File system   Name                  Flags
 1      1024kB  101MB   99.6MB    fat32         EFI system partition  boot
 2      101MB   20.1GB  20.0MB                  Linux root
 3      20.1GB  28.1GB  8000MB                  Linux swap
 4      28.1GB  120GB   91.9MB                  Linux home

(parted)

Ao terminar, tecle “quit” para sair do parted. Agora o disco está pronto para instalar e com as partições devidamente alinhadas.

OBS: tive algum problema com o parted e o sistema acabou tendo problemas em reconhecer as partições. Antes de prosseguir use o gdisk para corrigir os tipos das partições com os comandos a seguir:

gdisk /dev/sda
GPT fdisk (gdisk) version 0.8.5

Partition table scan:
  MBR: protective
  BSD: not present
  APM: not present
  GPT: present

Found a valid GPT with protective MBR; using GPT.

Command (? for help): t
Partition number (1-4): 1
Hex code or GUID (L to show codes, Enter = 8300): 0700
Changed type of partition to 'Microsoft basic data'

Command (? for help): t
Partition number (1-4): 2
Hex code or GUID (L to show codes, Enter = 8300): 8300
Changed type of partition to 'Linux filesystem'

Command (? for help): t
Partition number (1-4): 3
Hex code or GUID (L to show codes, Enter = 8300): 8200
Changed type of partition to 'Linux swap'

Command (? for help): t
Partition number (1-4): 4
Hex code or GUID (L to show codes, Enter = 8300): 8300
Changed type of partition to 'Linux filesystem'

Command (? for help): w
...

2.2. Instalação

Para iniciar a instalação do Slackware use o comando setup. Se o teclado estiver configurado adequadamente, inicie a instalação adicionando o Swap:

dell_uefi-03.

Preste muita atenção na seleção das partições para a instalação do sistema e do /home. Até o momento o programa de instalação do Slackware não está reconhecendo as partições em uma tebela GPT apropriadamente, apresentando as partições /dev/sda1 e /dev/sda3 na lista de partições para a instalação do sistema com se fossem partições Linux system.

Selecione as partições corretas para a instalação: /dev/sda2 para a instalação do sistema; e a partição /dev/sda4 para a montagem do /home.

Ao terminar, ignore as demais partições e mande continuar a instalação.

dell_uefi-05

Antes de selecionar a mídia de instalação, pressione Alt+F2 para abrir o segundo terminal e montar o pendrive. Tecle ENTER para habilitar o terminal e digite o comando abaixo para montar o pendrive:

mkdir /disk
[prompt]mount /dev/sdb1 /disk
[prompt]ln -s /disk/slackware64 /slack

Se por algum motivo o pendrive não for encontrado em /dev/sdb1, verifique em /dev/sdc1 ou mesmo nas mensagens do dmesg. Após a montagem retorne ao terminal 1 (Alt+F1) e selecione a opção 6 (“Install from a pre-mounted directory”), do menu:

dell_uefi-06

Responda a pergunta seguinte com o link que foi criado para o /disk/slackware64, “/slack”, sem as aspas.

dell_uefi-09

Em seguida continue com a instalação até alcançar a página de instalação do lilo.

Não instale o lilo!. O lilo tenta instalar uma entrada na MBR do disco, o que na UEFI não é desejada. Geralmente isto apenas gera um erro, pois a MBR está protegida contra gravações no momento em que criou a tabela GPT. Pule a instalação do lilo e continue as configurações até terminar a instalação.

dell_uefi-08

Ao terminar a instalação, não reinicie a máquina ainda, pois o sistema está sem boot.

2.3. Preparar o boot com o UEFI

O bootloader a ser instalado será o elilo, uma versão do lilo própria para o UEFI. Ao sair do setup, observe que as partições sda2 e sda4 devem estar montados em /mnt e /mnt/home, respectivamente.

Para preparar a inicialização através do EFI System, é necessário preparar a partição de boot, em /dev/sda1. Esta partição deve ser formatada em fat32 e, por conveniência, pode ser montada em uma pasta como /boot/efi, no momento /mnt/boot/efi. Execute os comandos a seguir:

Atenção: o comando mkdosfs, a seguir, irá formatar a partição /dev/sda1 (uefi), perdendo todo o seu conteúdo. Caso esteja instalando um sistema em dual boot reveja a necessidade de executar este comando.

mkdosfs -F32 /dev/sda1
mkdosfs 3.0.16 (01 Mar 2013)
[prompt]mkdir /mnt/boot/efi
[prompt]mount /dev/sda1 /mnt/boot/efi

Em seguida copie o conteúdo de /disk/EFI para /mnt/boot/efi,

cp -rvf /disk/EFI /mnt/boot/efi/
...

Cuidado com as barras (/) no comando de copia acima para não fazer uma cópia inapropriada. Em seguida renomeie o diretório BOOT para Slackware, em /mnt/boot/efi/EFI:

cd /mnt/boot/efi/EFI
[prompt]mv BOOT Slackware
[prompt]cd Slackware

Copie o kernel huge mais novo de /mnt/boot/, para o diretório /mnt/boot/efi/EFI/Slackware/:

ls /mnt/boot/vmlinuz*
/mnt/boot/vmlinuz@  /mnt/boot/vmlinux-generic-3.8.13  /mnt/boot/vmlinux-huge-3.8.13
[prompt]cp /mnt/boot/vmlinux-huge-3.8.13 /mnt/boot/efi/EFI/Slackware/

em seguida edite o elilo.conf e deixe-o com conteúdo semelhante ao abaixo:

chooser=simple
message=message.txt
delay=30
timeout=30
#
image=vmlinuz-huge-3.8.13
      label=Slackware
      root=/dev/sda2

O fundamental aqui é apontar a imagem para o novo kernel e a variável root para a partição onde a raiz do sistema será montada. Se deseja, edite o arquivo message.txt para personalizar a mensagem inicial do sistema.

Para terminar, registre uma entrada deste boot na UEFI do notebook. Para isto será necessário o pacote efibootmgr, que foi colocado na pasta /extra do pendrive. Instale o pacote e carregue o módulo efivars com os comandos a seguir:

installpkg /disk/extra/efibootmgr-0.6.0-x86-1_SBo.tgz
...
[prompt]modprobe efivars
[prmopt]ls /sys/firmware/efi/vars/
...

A instalação será feita apenas na memória, uma vez que o sistema instalado ainda não está operando. O módulo efivars dá acesso às informações e variáveis do UEFI. O comando ls, em seguida, é apenas para verificar a estas variáveis. Este ls deve retornar vários diretórios e arquivos, o que indica que está tudo certo até o momento.

Se o diretório /sys/firmware/efi não existir é provável que o sistema tenha iniciado no modo BIOS e não UEFI. Neste caso terá que habilitar o UEFI no setup do sistema para reiniciar no modo UEFI. Se necessitar de alguma orientação, leia a seção “3.1. Iniciando no modo UEFI”, num texto que escrevi a algum tempo atrás.

Se tudo estiver ok, proceda com o registro do boot na UEFI, com o aplicativo efibootmgr:

mv bootx64.efi slack64.efi
[prompt]efibootmgr -c -L "Slackware" -l "\\EFI\\Slackware\\slack64.efi"
...
Boot0006* Slackware

O comando mv foi apenas para mover o bootx64.efi para algo mais sugestivo como slack64.efi.

A flag -c diz ao efibootmgr para criar um novo bootnumber e adicionar uma nova entrada à lista de boot do UEFI, com o nome Slackware (flag -L). A flag -l aponta para o diretório onde está alocado o loader (slack64.efi), à partir do ponto de montagem.

Isto termina a instalação, mas ainda faltam alguns ajustes para adequadamente o uso do seu SSD. Aconselho que faça as mudanças descritas na seção 3, antes de reiniciar o sistema.

2.3.1. Algumas poucas notas sobre efibootmgr

Para visualizar os bootloaders instalados em seu UEFI boot list, use apenas o comando efibootmgr:

efibootmgr
BootCurrent: 0006
Timeout: 0 seconds
BootOrder: 0000,0001,0002,0003,0004,0005,0006,0007,0008,0009
Boot0000  Setup
Boot0001  Boot Menu
Boot0002* Removable Drive
Boot0003  Network
Boot0004* USB Storage Device
Boot0005* CD/DVD/CD-RW Drive
Boot0006* Slackware01
Boot0007* Slackware02
Boot0008  Diagnostics
Boot0009  Change boot mode setting

Isto irá apresentar toda a lista de bootloaders instalados no sistema. Para remover um bootnumber use a sintaxe abaixo:

efibootmgr -b 7 -B
BootCurrent: 0006
Timeout: 0 seconds
BootOrder: 0000,0001,0002,0003,0004,0005,0006,0008,0009
Boot0000  Setup
Boot0001  Boot Menu
Boot0002* Removable Drive
Boot0003  Network
Boot0004* USB Storage Device
Boot0005* CD/DVD/CD-RW Drive
Boot0006* Slackware01
Boot0008  Diagnostics
Boot0009  Change boot mode setting

Onde o 7 entre as flags -b e -B é o bootnumber, em hexadecimal. Para mais informações verifique o manual do comando efibootmgr, em especial os exemplos ao final do manual.

3. Maximizando a Performance e Durabilidade do SSD

Alguns dos ajustes apresentados a seguir são fundamentais para melhorar a performance e durabilidade do seu SSD, enquanto outros são de uso geral para melhorar a performance em qualquer sistema, desde que reúna requisitos de memória semelhante aos citados aqui.

As mudanças a seguir pressupõe que o sistema ainda não tenha sido reiniciado e que suas partições continuem montadas em /mnt, /mnt/home e /mnt/boot/efi. Caso tenha reiniciado o notebook com o sistema instalado em sda2, remova o /mnt das linhas seguintes.

3.1. Ajustando as Montagens

A primeira alteração não somente garante melhora na performance do seu SSD, mas também na sua vida útil, por reduzir escritas desnecessárias. Edite o /mnt/etc/fstab e adicione as opções noatime, nodiratime, discard, errors=remount-ro à montagem da raiz do sistema e as três primeiras para o /home.

As opções noatime e nodiratime fazem com que as alterações nos arquivos e diretórios não sejam escritas no disco imediatamente. Ao invés disto, as alterações são armazenadas e organizadas em um buffer para depois serem descarregadas no disco. A opção errors define a ação do sistema quando for encontrado algum erro no sistema de arquivos durante a montagem. O padrão é montar como read-only a raiz do sistema.

O discard controla se o sistema de arquivos deverá emitir um comando descartar/TRIM para o dispositivo de bloco, quando os blocos são liberados. Isso é fundamental para dispositivos SSD.

Com 4GB ou mais é aconselhável montar em memória RAM os diretórios:

  • /tmp – arquivos temporários
  • /var/spool – spool de impressão;
  • /var/tmp – arquivos temporários;
  • /var/log – logs do sistema.

além de outros candidatos que forem convenientes. Obviamente, isto possui um custo. Montar o /var/spool em RAM fará com que a cada reinicialização do sistema, a fila de impressão seja perdida e no caso do /var/log, os logs do sistema serão perdidos. O mesmo acontece com os arquivos em /tmp e /var/tmp, no entanto estes causam menos impacto sobre o sistema.

O quadro abaixo mostra como ficou o /mnt/etc/fstab (ou /etc/fstab caso tenha reiniciado com o sistema instalado) para esta máquina:

/dev/sda3  swap         swap    defaults                                       0   0
/dev/sda2  /            jfs     noatime,nodiratime,discard,errors=remount-ro   0   1
/dev/sda4  /home        jfs     defaults,noatime,nodiratime,discard            1   2
/dev/sda1  /boot/efi    vfat    noauto,fmask=133,dmask=022                     1   0
devpts     /dev/pts     devpts  gid=5,mode=620                                 0   0
proc       /proc        proc    defaults                                       0   0
tmpfs      /dev/shm     tmpfs   defaults                                       0   0
tmpfs      /tmp         tmpfs   defaults,noatime,mode=1777                     0   0
tmpfs      /var/spool   tmpfs   defaults,noatime,mode=1777                     0   0
tmpfs      /var/tmp     tmpfs   defaults,noatime,mode=1777                     0   0
tmpfs      /var/log     tmpfs   defaults,noatime,mode=0775                     0   0

O diretório /var/log possui alguns arquivos que não podem ser perdidos no processo de reinicialização. Estes arquivos são usados pelo pkgtools para gerenciar os pacotes instalados no sistema e, a menos que esteja disposto a abrir mão de atualizar seu sistema, estes não devem ser descartados.

Uma solução é mover estes sub-diretórios para uma outra pasta, com /var/pkgtools:

mkdir /mnt/var/pkgtools
[prompt]for d in packages removed_packages \
removed_scripts scripts setup; do
  mv /mnt/var/log/$d /mnt/var/pkgtools/
done

Para que o gerenciador de pacotes do Slackware continue funcionando, é necessário que a cada inicialização do sistema sejam criados os links dos diretórios em /var/pkgtools/ para o /var/log/. Para isto adicione as linhas abaixo ao /etc/rc.d/rc.local:

if [ ! -e /var/log/packages ]; then
  for d in /var/pkgtools/*; do
    ln -s $d ${d/pkgtools/log}
  done
fi

Agora o pkgtools está protegido das reinicializações do sistema.

3.2. Otimizando o uso do Swap

Para os padrões atuais de memória RAM, o esperado é que o swap seja utilizado somente em raras ocasiões em sistemas GNU/Linux. No entanto, caso o swap seja necessário, o kernel Linux possui um scheduler especialmente projetado para organizar as filas de I/O para maximizar o desempenho do swap.

Por padrão o kernel do Linux usa o modo CFQ (Completely Fair Queuing), que é projetado com as latências rotacionais do disco rígido, em mente. Portanto ele funciona muito bem em discos rígidos mas são pouco eficientes em mídias SSDs.

No entanto o kernel possui outros modos de operação para o scheduler, como o NOOP e deadline. Ambos são modos básicos que garantem retorno rápido de pedidos de I/O. O NOOP basicamente desabilita totalmente o scheduler. Já o deadline garante alguma prioridade nas solicitações de leitura, sobre a gravação, que é útil se você quiser garantir uma resposta rápida sobre pesado requerimento de escrita em swap.

Ambos são recomendados para o uso em swap em SSDs, embora para uma recomendação geral, acho mais confortável colocar o scheduler em deadline. Se não for usar jamais o swap, com certeza o NOOP é o modo recomendado. Adicione a linha a seguir ao /mnt/etc/rc.d/rc.local para mudar o modo de operação do scheduler:

echo deadline > /sys/block/sda/queue/scheduler

Adicione também a linha seguinte para fazer com que o sistema use o swap na SSD apenas quando a memória física estiver completamente cheia:

echo 0 > /proc/sys/vm/swappiness

Com 6G de RAM, as ações acima tem sido satisfatórias. Um cat nestes dois arquivos do sistema permitem ver as opções selecionadas:

cat /sys/block/sda/queue/scheduler
noop [deadline] cfq
[prompt]cat /proc/sys/vm/swappiness
0

Este é um bom momento para reiniciar o sistema.

4. Mais alguns Ajustes

Neste ponto o sistema já está bastante funcional, com tempo de inicialização (até iniciar o prompt gráfico) da ordem de 12s. Mas existe uma série de ajustes, alguns nem tão pequenos, que ainda podem melhorar um pouco o sistema.

4.1. Alterando o rc.M

A primeira alteração consiste em fazer pequenas mudança no script /etc/rc.d/rc.M, que podem deixar a inicialização 1 a 2 segundos mais rápida. A algum tempo atrás escrevi um texto sobre tais otimizações (Iniciando o Slackware em 12s ou menos. Nem todas as otimizações ali são recomendadas, mas há algumas em particular as quais não dispenso em uma instalação. Dentre elas a edição do /etc/rc.d/rc.M é sempre bem promissor em um desktop, onde a inicialização do sistema é algo relevante. A ideia é bem simples, basta comentar as linhas relativas a:

  • carga do ldconfig;
  • updating do índex de fontes;
  • updating do banco de dados mime;
  • updating do cache de ícones;
  • updating dos arquivos do GTK+/pango.

removendo seus códigos para um script externo, que será executado somente se um novo pacote for instalado ao sistema. Adicione os arquivos abaixo ao seu /etc/rc.d:

  • rc.M – com as linhas dos updating comentados acima;
  • rc.update – script para executar o update quando um novo pacote é instalado no sistema

Por fim adicione as linhas abaixo ao seu /etc/rc.d/rc.local:

if [ -x /erc/rc.d/rc.update ]; then
  /etc/rc.d/rc.update start
fi

4.2. Compilar o Kernel

O kernel huge, padrão do Slackware geralmente é suficiente para qualquer sistema, sendo poucas as ocasiões em que se deva recompilá-lo. O único ganho efetivo em se recompilar o kernel é no tempo de inicialização do sistema. Um kernel enxuto carrega muito mais rápido que um kernel huge. Primeiro por ser mais curto e depois por ter menos módulos para carregar. Outro ganho interessante em compilar o kernel e conhecer um pouco mais o hardware da máquina, de outra forma é bem provável que o kernel não funcione.

Vou conduzir aqui uma orientação rápida para preparar o kernel, sem entrar em detalhes da configuração. O kernel utilizado será o 3.9.6, que é o último disponível no momento em que escrevo este texto. Caso deseje utilizar um mais novo, olhe no site kernel.org.

4.2.1. Preparando o Sistema

Primeiro baixe o kernel para um diretório da máquina e o descompacte em /usr/src:

wget https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.9.6.tar.bz2
...
[prompt]tar -C /usr/src/ -xvf linux-3.9.6.tar.bz2 
...

Feito isto, faça um link simbólico de /usr/src/linux-3.9.6 para /usr/src/linux

[prompt]cd /usr/src
[prompt]ln -s linux-3.9.6 linux
[prompt]cd linux

Isto não é obrigatório, mas alguns aplicativos com os drivers da NVidia e ATI, o VirtualBox e outros, costumam buscar o kernel em /usr/src/linux.

Feito isto execute o make mrproper na fonte do kernel para remover eventuais arquivos de configuração, backup e outros arquivos gerado em compilações posteriores. Provavelmente não há muito o que remover, mas isto reseta o arquivo de configuração para algo mais básico.

Neste momento já é possível configurar o kernel com um make menuconfig. Como não vou entrar em detalhes sobre a configuração, passo o .config, que usei nesta máquina. Baixe-o, configure o kernel com ele e depois edite o menu se achar necessário:

wget ...../config
[prompt]make oldconfig
...
[prompt]make menuconfig

4.2.2. Compilando e Instalando o kernel

Se tiver com pressa e o note estiver em um local bem ventilado, experimente um -j10. Isto irá ocupar bem os recursos de CPU e deve fazer o trabalho bem rápido. Esta flag diz ao make para executar até 10 jobs (comandos de compilação) simultaneamente. Mesmo tendo apenas duas CPU’s reais (+2 “virtuais”) neste i5, isto é bem eficiente, pois mantém as CPU’s trabalhando em 100% a maior parte do tempo de compilação.

make -j10
...
[prompt]make install
...
[prompt]make modules_install
...
3.9.6-rra0

Ao terminar o novo kernel será instalado em /boot e os módulos em /lib/modules. Primeiro renomeie o novo kernel para um nome menos genérico e em seguida reconfigure o grub:

mv /boot/vmlinuz /boot/vmlinuz-3.9.6-rra0
[prompt]mv /boot/System.map /boot/System.map-3.9.6-rra0

4.3. Grub2 com UEFI para o boot

Para a instalação do Grub2 com UEFI veja o texto Grub2 com UEFI em Slackware64, que escrevi para esta mesma máquina.

4.4. Bluetooth

Se quiser usar o bluetooth não se esqueça de habilitar o /etc/rc.d/rc.bluetooth:

chmod +x /etc/rc.d/rc.bluetooth

4.5. Instalação do Bumblebee (NVidia + Optirun)

Existe um material para a instalação do Bumblebee, suporte NVidia + Optirun em Nvidia Optimus. Isto é um híbrido entre uma GPU nVidia e Intel onde a nVidia é usada para performance e a Intel para economizar energia em uso básico do sistema, o que tem sido muito usado em notebooks.

Fiz um script para automatizar a instalação do suporte NVidia + Optirun e vou apenas apresentar a sequência de comandos para a instalação abaixo. Em um outro momento adiciono mais informações aqui.

Baixar os scripts de instalação:

git clone https://github.com/jgeboski/Bumblebee-SlackBuilds.git bumblebee
...
[prompt]cd bumblebee

Baixe meu script para automatizar a instalação ou leia o README para a instalação:

wget http://localhost/linux/bumblebee/bumblebee.sh
...
[prompt]C32=no . ./bumblebee.sh

Criar um grupo para executar o bumblebee e adicionar os usuários que poderão usá-lo:

groupadd bumblebee
[prompt]usermod -G bumblebee -a

Habilitar o rc.bumblebee:

chmod +x /etc/rc.d/rc.bumblebeed
[prompt]/etc/rc.d/rc.bumblebeed start

e adicionar a inicialização do sistema: adicione as linhas abaixo ao /etc/rc.d/rc.local.

echo -e 'if [ -x /etc/rc.d/rc.bumblebeed ]; then
  /etc/rc.d/rc.bumblebeed start
fi' >> /etc/rc.d/rc.local

adicionar ao desligamento do sistema uma chamada: adicione as linhas abaixo ao /etc/rc.d/rc.local_shutdown.

echo -e 'if [ -x /etc/rc.d/rc.bumblebeed ]; then
  /etc/rc.d/rc.bumblebeed stop
fi' >> /etc/rc.d/rc.local_shutdown

Para mais informações aconselho a leitura do projeto http://bumblebee-project.org/

5. Referências

Estas foram as principais referências pesquisadas para este texto.