Slackware

LA DISTRIBUZIONE LINUX PER CHI VUOLE IMPARARE

Linux Day - 28 ottobre 2013 - Scuola Normale Superiore - Pisa

Matteo Bernardini
(nome di battaglia: ponce)

usa Linux da piu' di quindici anni

esperienza lavorativa in diverse ditte ed enti pubblici italiani

dal 2008 molto attivo su Slackware
(virtualizzazione, ambienti grafici leggeri, desktop remoti)

dal 2012 parte del gruppo di amministratori di SlackBuilds.org

Un po' di storia

Qual'e' la filosofia

Come e' fatta

Anatomia dei pacchetti

Software di terze parti e SlackBuilds.org

Il futuro

Come contribuire
-
un grazie per gli spunti nel realizzare questa presentazione va a
Eric Hameleers e Vincent Batts (devopsreactions per le gif)

Slackware, la piu' anziana distribuzione

GNU/Linux attivamente sviluppata.

(riferimento GNU/Linux Distribution Timeline )

fork di Softlanding Linux System (SLS) realizzato da Patrick Volkerding
per la Moorehead Minnesota State University

il nome deriva dalla Chiesa del Subgenius

Un po' di storia delle release

1.0 - 16 luglio 1993

1.1.2 - 5 febbraio 1994 (installer basato su dialog)

3.3 - 11 luglio 1997 (ancora disponibile sui mirror)

4.0.0 - 17 luglio 1999 (prima release con KDE)

7.1 - 22 giugno 2000 (prima release con GNOME)

10.2 - 13 settembre 2005 (GNOME abbandonato)

11.0 - 1 ottobre 2006 (ultima release kernel 2.4)

12.1 - 2 maggio 2008 (installazione rete - http/ftp)

13.0 - 28 agosto 2009 (KDE4, versione a 64bit)

14.0 - 26 settembre 2012 (udev, allineamento ARM)

Slackware e' la distribuzione linux piu' simile agli UNIX tradizionali. Si e' evoluta nel corso degli anni introducendo le novita' necessarie ma cercando di non distaccarsi dalla sua struttura originale, una semplice raccolta di componenti ben organizzata.

Non ha una data di rilascio fissa, come invece hanno altre distribuzioni, le nuove versioni escono "quando sono pronte".
Il software incluso viene sempre testato e non viene necessariamente messa la versione uscita poche ore prima.

Non esiste uno strumento centralizzato per la configurazione del sistema: ogni componente e' configurato nel modo indicato dagli sviluppatori originali.

I file di configurazione sono file di testo leggibili, gli strumenti specifici della distribuzione sono principalmente script shell con commenti esaustivi: questo rende estremamente facile la personalizzazione.

Anche i pacchetti sono generati da script shell: questi non fanno altro che ripercorrere la procedura usuale di installazione dei pacchetti cosi' come prevista a monte; non vengono fatte aggiunte o modifiche se non strettamente necessarie e se vengono applicate patch vengono proposte anche agli sviluppatori originali.

Viene seguita la filosofia KISS (Keep It Simple, Stupid) e "se non e' rotto, non aggiustarlo".

Le varie componenti del sistema operativo non vengono personalizzate per creare un esperienza utente semplificata: unica eccezione sono alcuni script shell/dialog/ncurses (al massimo strumenti semi-grafici utilizzabili anche in console) creati per facilitare l'installazione e la configurazione iniziale del sistema.

In Slackware non ci sono GUI (Graphical User Interfaces) che risolvano magicamente ogni problema legato all'uso della stessa o che propongano soluzioni non richieste, e' una distribuzione per l'amministratore di sistema UNIX esperto e anche per chi vuole imparare: chiunque puo' crescere leggendo la documentazione ufficiale o le pagine man dei vari componenti.

Recentemente e' nato un wiki (multilingua) che raccoglie la documentazione specifica legata all'utilizzo della distribuzione:

docs.slackware.com

E' comunque disponibile gia' da diversi anni anche il corposo wiki degli utenti della comunita' italiana slacky.eu:

wikislacky

Il modello di sviluppo di Slackware e' chiuso: non c'e' un repository di codice pubblico o un bug-tracker.

Questo non vuol dire che Slackware sia sviluppata da una sola persona.

C'e' un gruppo di utenti (per qualche nome potete consultare docs.slackware.com) che la usa quotidianamente e che testa software nuovo o aggiornato, facendo poi le relative proposte a Patrick Volkerding che, suo malgrado, e' considerato il BDFL (Benevolent Dictator for Life): solo quello che lui decide di includere viene a far parte della distribuzione e ha sempre l'ultima parola.

La collaborazione di queste persone e di tutto il resto della comunita' (grazie a tutti!) e' servita e servira' a Slackware per evolversi.

Cosa succede quando avvio Slackware?

bootloader -> lilo - sistema di avvio -> misto bsd e sysvinit

si avvia di default in runlevel 3 (modalita' testuale multiutente)

Ma e' vecchia! Sembra il DOS!

E' cosi' perche' l'utente possa scegliere :-)

All'avvio del sistema, l'utente/amministratore puo' decidere come usarlo: in modalita' linea di comando o con un'interfaccia grafica.

Sono presenti, oltre agli strumenti grafici, tutta una serie di programmi che ne permettono l'uso completo da linea di comando: un lettore di news, un client di posta, un browser, vari client di rete, editor, lettori multimediali ecc.

Slackware, nella sua installazione completa, e' adatta sia per chi ha bisogno di un desktop per gli usi piu' comuni (tra cui magari anche sviluppare), che per chi ha bisogno di un server.

Per avviare l'interfaccia grafica basta digitare

startx

Per avere l'avvio grafico predefinito basta settare a "4" la linea contenente "initdefault" dentro il file /etc/inittab

script di avvio ( /etc/rc.d/rc.*)

rc.S - inizializzazione del sistema

rc.M - avvio per sessione multiutente

(rc.K - avvio per sessione utente singolo)

rc.4 - avvio per sessione multiutente grafica (X.org)

rc.inet1 - inizializzazione rete (vedere /etc/rc.d/rc.inet1.conf)

rc.inet2 - servizi di rete (nfs, samba, firewall, inetd, sshd, ecc.)

rc.sysvinit - compat. System V (/etc/init.d/* e /etc/rcN.d/*)

rc.local - per l'avvio di servizi locali

un esempio di /etc/rc.d/rc.local

#!/bin/sh
#
# /etc/rc.d/rc.local:  Local system initialization script.
#
# Put any local startup commands in here.  Also, if you have
# anything that needs to be run at shutdown time you can
# make an /etc/rc.d/rc.local_shutdown script and put those
# commands in there.

# Start libvirt
if [ -x /etc/rc.d/rc.libvirt ]; then
  /etc/rc.d/rc.libvirt start
fi

# Syncronize the clock
/usr/sbin/ntpdate pool.ntp.org &

# Try to fix realtime issues
echo 2048 >/sys/class/rtc/rtc0/max_user_freq
echo 2048 >/proc/sys/dev/hpet/max-user-freq

Per la gestione di pacchetti ci sono i pkgtools:

installpkg

removepkg
explodepkg
upgradepkg
makepkg
pkgtool (frontend dialog)

Non esiste, per scelta, un sistema di risoluzione delle dipendenze, la distribuzione viene offerta come un blocco unico: la logica e' che lo spazio non e' un problema.
Se si vuole realizzare un'installazione minimale (non supportata) e' bene avere esperienza nella risoluzione manuale delle dipendenze, per sapere quali pacchetti includere e quali no (una buona base di partenza e' la lista fornita da Vincent Batts).

Per gestire i pacchetti esiste anche un altro strumento,

slackpkg

Permette di aggiornare i pacchetti (e i loro file di configurazione), installarne di nuovi, ricavare informazioni, fare ricerche, generare dei template di installazione ed applicarli.

Ci sono anche strumenti di terze parti (come ad esempio slapt-get, che offre la possibilita' di risolvere le dipendenze) e dei repository gestiti direttamente da utenti o da intere comunita'.

Ma e' piu' sicuro (e molto piu' educativo) gestire questi aspetti in proprio senza troppi automatismi.

se si gestiscono male i pacchetti puo' succedere questo

Come sono fatti i pacchetti?

I pacchetti non sono altro che degli archivi tar compressi (in passato tramite gzip e da qualche release tramite xz) contenenti l'albero dei file (senza il prefisso "/").

Gli strumenti di gestione dei pacchetti supportano la variabile d'ambiente $ROOT, che se definita permette di installare l'albero dei file a partire dalla cartella specificata.

Unico contenuto speciale dei pacchetti e' una cartella "install" contenente la descrizione del pacchetto ed un eventuale script da eseguire post-installazione, doinst.sh.

Vediamo un esempio di pacchetto nel dettaglio

ebook-tools-0.2.1-x86_64-1

install/
install/slack-desc
install/doinst.sh
usr/
usr/bin/
usr/bin/einfo
usr/lib64/
usr/lib64/libepub.so.0.2.1
usr/include/
usr/include/epub_version.h
usr/include/epub_shared.h
usr/include/epub.h
usr/doc/
usr/doc/ebook-tools-0.2.1/
usr/doc/ebook-tools-0.2.1/LICENSE
usr/doc/ebook-tools-0.2.1/README
usr/doc/ebook-tools-0.2.1/INSTALL
usr/doc/ebook-tools-0.2.1/TODO

I pacchetti non sono divisi in *-bin, *-dev, *-lib o *-doc ma ogni file necessario che viene distribuito dagli sviluppatori originali e' messo dentro un unico pacchetto.

slack-desc

ebook-tools: ebook-tools (access and convert various ebook file formats)
ebook-tools:
ebook-tools: Tools for accessing and converting various ebook file formats. 
ebook-tools:
ebook-tools: Home page: http://sourceforge.net/projects/ebook-tools/
ebook-tools:
ebook-tools:
ebook-tools:
ebook-tools:
ebook-tools:
ebook-tools:

doinst.sh

( cd usr/lib64 ; rm -rf libepub.so )
( cd usr/lib64 ; ln -sf libepub.so.0 libepub.so )
( cd usr/lib64 ; rm -rf libepub.so.0 )
( cd usr/lib64 ; ln -sf libepub.so.0.2.1 libepub.so.0 )

Le informazioni nello slack-desc e nel doinst.sh, una volta installato il pacchetto, sono reperibili in /var/log/packages/* and /var/log/scripts/*

Questa organizzazione permette di manipolare i pacchetti anche con strumenti non specifici della distro, come cat, ls, tar, grep, ecc.

questo e' lo script shell che crea il pacchetto (reperibile qui)

#!/bin/sh

# Copyright 2010  Eric Hameleers, Eindhoven, NL
# Copyright 2010  Patrick J. Volkerding, Sebeka, MN, USA
# All rights reserved.
#
# Redistribution and use of this script, with or without modification, is
# permitted provided that the following conditions are met:
#
# 1. Redistributions of this script must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#
#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
#  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
#  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
#  EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


PKGNAM=ebook-tools
VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z* | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
BUILD=${BUILD:-1}

NUMJOBS=${NUMJOBS:-" -j7 "}

(continua)

# Automatically determine the architecture we're building on:
MARCH=$( uname -m )
if [ -z "$ARCH" ]; then
  case "$MARCH" in
    i?86)    export ARCH=i486 ;;
    armv7hl) export ARCH=$MARCH ;;
    arm*)    export ARCH=arm ;;
    # Unless $ARCH is already set, use uname -m for all other archs:
    *)       export ARCH=$MARCH ;;
  esac
fi

if [ "$ARCH" = "i486" ]; then
  SLKCFLAGS="-O2 -march=i486 -mtune=i686"
  LIBDIRSUFFIX=""
elif [ "$ARCH" = "s390" ]; then
  SLKCFLAGS="-O2"
  LIBDIRSUFFIX=""
elif [ "$ARCH" = "x86_64" ]; then
  SLKCFLAGS="-O2 -fPIC"
  LIBDIRSUFFIX="64"
elif [ "$ARCH" = "armv7hl" ]; then
  SLKCFLAGS="-O2 -march=armv7-a -mfpu=vfpv3-d16"
  LIBDIRSUFFIX=""
else
  SLKCFLAGS="-O2"
  LIBDIRSUFFIX=""
fi

(continua)

CWD=$(pwd)
TMP=${TMP:-/tmp}
PKG=$TMP/package-${PKGNAM}
rm -rf $PKG
mkdir -p $TMP $PKG

cd $TMP
rm -rf ${PKGNAM}-${VERSION}
tar xvf $CWD/${PKGNAM}-$VERSION.tar.?z* || exit 1
cd ${PKGNAM}-$VERSION || exit 1

# Fix some hard-coded pathnames for 64-bit:
cat $CWD/ebook-tools.paths.diff | patch -p1 --verbose || exit 1

# Make sure ownerships and permissions are sane:
chown -R root:root .
find . \
 \( -perm 777 -o -perm 775 -o -perm 711 -o -perm 555 -o -perm 511 \) \
 -exec chmod 755 {} \; -o \
 \( -perm 666 -o -perm 664 -o -perm 600 -o -perm 444 -o -perm 440 -o -perm 400 \) \
 -exec chmod 644 {} \;

# Build and install:
mkdir -p build
cd build
  cmake \
    -DCMAKE_C_FLAGS:STRING="$SLKCFLAGS" \
    -DCMAKE_CXX_FLAGS:STRING="$SLKCFLAGS" \
    -DCMAKE_INSTALL_PREFIX=/usr \

(continua)

    -DLIB_INSTALL_DIR=/usr/lib${LIBDIRSUFFIX} \
    -DMAN_INSTALL_DIR=/usr/man \
    -DSYSCONF_INSTALL_DIR=/etc \
    -DINCLUDE_INSTALL_DIR=/usr/include \
    -DLIB_SUFFIX=${LIBDIRSUFFIX} \
    ..
   make $NUMJOBS || make || exit 1
   make install DESTDIR=$PKG || exit 1
cd -

# Remove lit2epub binary because it doesn't work without clit (which has
# distribution restrictions so we do not include it)
rm -f $PKG/usr/bin/lit2epub 

# Strip binaries:
find $PKG | xargs file | grep -e "executable" -e "shared object" \
  | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null

# Add a documentation directory:
mkdir -p $PKG/usr/doc/${PKGNAM}-$VERSION
cp -a \
  INSTALL LICENSE README TODO \
  $PKG/usr/doc/${PKGNAM}-$VERSION

mkdir -p $PKG/install
cat $CWD/slack-desc > $PKG/install/slack-desc

cd $PKG
/sbin/makepkg -l y -c n $TMP/${PKGNAM}-$VERSION-$ARCH-$BUILD.txz

SlackBuilds.org

Sito di riferimento per aggiungere software di terze parti in Slackware: raccoglie script shell per generare pacchetti.

Sono disponibili template per creare pacchetti da diversi tipi di sorgenti.

Seguendo le direttive, nuovi script possono essere sottoposti all'approvazione degli amministratori tramite un form web.

Gli script, sono processati e inseriti nel repository tramite git: lo sviluppo e' pubblico

http://slackbuilds.org/cgit/slackbuilds/

sbopkg

Strumento semi-automatico per la creazione di pacchetti che utilizza il repository SBo: fa il download degli script di build e dei relativi sorgenti, creando i pacchetti.

Possono essere sfruttate anche delle code di compilazione.
Lo scrivente lo utilizza con un file di coda che compila in modo automatico 384 pacchetti utilizzati sulle proprie installazioni.

Sono configurabili diversi repository di script per creare pacchetti: quello predefinito per compilare pacchetti sulla versione -current di Slackware (la versione di sviluppo aggiornata continuamente) e' gestito dallo scrivente ed e' un fork del repository ufficiale di SBo.

http://cgit.ponce.cc/slackbuilds/

Possibili evoluzioni future?

supporto per architetture ulteriori

limiti dovuti alla necessita' di mantenere Slackware semplice

systemd?

come faccio a contribuire?

- utilizzando Slackware: piu' siamo e meglio e': frequentate il forum della comunita' italiana, Slacky.eu.
- partecipando al forum ufficiale in inglese, proponendo correzioni ad eventuali errori e/o innovazioni, con procedure documentate o patch (ipotesi o spiegazioni sommarie non sono sufficienti); se trovate un errore verificate che sia presente su un'installazione pulita.
Inoltre, se un programma non funziona, la maggior parte delle volte e' il caso di segnalarlo agli sviluppatori originali.

una tipica sessione di bug fixing

- se non gia' esistenti, realizzate degli script SlackBuild per generare i pacchetti che usate e metterli a disposizione degli altri tramite il nostro sito, SlackBuilds.org.

Per far questo e' necessaria almeno un minimo di pratica con la programmazione della bash.

Fate molta attenzione alle regole per la sottomissione degli script e attenetevi il piu' possibile agli standard definiti nei template: eviterete del lavoro alla persona che ve lo dovra' approvare o che vi venga addirittura rifiutato.

E' consigliato anche prendere dimestichezza con git, che sta diventando il metodo di controllo versione piu' affermato nel mondo.