GLM - 17/5/2022 - 12:10
Classifica dei relatori GLM 2014 (per numero di lezioni svolte)
- [9] Samuele Cacchiarelli
- [6] Andrea Bianchini
- [6] Gianluca Gabrielli
- [1] Matteo Ciccioli
- [1] Fabio Pagnotta
- [1] Alessandro Zampa
- [1] Emanuele
- [1] Roberto Marozzi
- [1] Giampiero Rubini
Vuoi diventare relatore GLM? presenta anche tu una lezione su un argomento che più ti piace relativo a Linux o al mondo dell'OpenSource
Archivio news
Venerdì 23 Aprile 2004
Gestione dei pacchetti sorgenti
Una delle possibilità che offre linux riguardo la gestione dei
propri pacchetti di installazione, è quella di poter scegliere
se installare i propri programmi utilizzando pacchetti precompilati
nei formati visti le scorse settimane o direttamente compilando
i relativi sorgenti.
Alcune distribuzioni quali la Gentoo si basano fortemente sull'
utilizzo di pacchetti sorgenti ed hanno sviluppato un sistema
di gestione degli stessi molto efficace ed efficiente; altre
quali la Suse e la Debian in particolare, pur non basandosi
specificatamente sull'utilizzo dei sorgenti come metodo di
installazione, hanno comunque implementato un metodo per
automatizzare la compilazione e l'installazione degli stessi.
Continuando l'argomento della scorsa settimana, in questa serata
abbiamo mostrato il funzionamento e la logica del sistema
di gestione dei pacchetti sorgenti.
Di seguito ne riportiamo una sintesi.
I pacchetti sorgenti Linux di regola vengono distribuiti nei seguenti formati.
- tar.gz
- tar.bz2
- tar.Z
ovvero in archivi tar compressi utilizzando algoritmi di
compressione propri dei programmi quali gzip, bzip2
e compress.
Potremmo definire la compilazione come quel processo
che permette la trasformazione del codice sorgente
in codice macchina eseguibile.
La maggioranza dei pacchetti linux sono scritti nel
linguaggio C, per la compilazione del quale sono necessari
quanto meno i seguenti programmi:
- gcc
- make
Il primo è il compilatore della GNU per il linguaggio C, il secondo invece è un "gestore di processi di compilazione", il cui ruolo è quello di ordinare e controllare i processi di compilazione quando la compilazione di un programma interessa più file sorgenti correlati tra loro.
La compilazione di un singolo file sorgente (C) è una operazione che non comporta alcuna difficoltà. Il comando da utilizzare è:
gcc -o Eseguibile.out Sorgente.c
dove Eseguibile.out è il nome che vogliamo dare all'eseguibile, e Sorgente.c è il file sorgente che vogliamo compilare.
Da tale comando, salvo errori di compilazione, otterremo
direttamente il file eseguibile. Ciononostante il processo di
compilazione in se, viene suddiviso dal compilatore
in due fasi principali.
In una prima fase il compilatore trasforma il Sorgente.c
nel file oggetto Sorgente.o, che possiamo
definirlo come l'equivalente in codice macchina del codice
sorgente; in una seconda fase invece il compilatore tramite il
linker, collega il file appena creato al codice delle
funzioni di libreria richiamate nel sorgente, rendendolo
così eseguibile.
Possiamo chiedere al compilatore di effettuare esplicitamente
queste due fasi con i seguenti comandi:
gcc -c Sorgente.c
con il quale verrà creato semplicemente il file oggetto Sorgente.o
gcc -o Eseguibile.out Sorgente.o
con il quale verrà effettuato il linking alle librerie, creando il file eseguibile Eseguibile.out
Difficilmente un programma è composto da un singolo file sorgente. Usualmente infatti il programmatore suddivide il codice del programma in più file sorgenti. Questo sia per rendere il codice modulare in maniera da gestire al meglio eventuali modifiche allo stesso, sia perchè in questo modo è possibile suddividere il processo di compilazione nelle due fasi viste e quindi velocizzare la ricompilazione del programma in caso di piccole modifiche.
In presenza di un programma composto da più file infatti è spesso consigliabile suddividere il processo di compilazione nelle due fasi viste sopra. I comandi da utilizzare sono:
gcc -c Sorgente1.c Sorgente2.c Sorgente3.c
questo creerà i rispettivi file oggetto e
gcc -o Eseguibile.out Sorgente1.o Sorgente2.o Sorgente3.o
creerà l'eseguibile linkando i file oggetto alle librerie
In caso di modifica ad uno dei file sorgenti di cui è composto il programma, non sarà necessario ricompilare tutto il programma, bensì sarà sufficiente ricompilare il relativo file oggetto e quindi linkare il nuovo file oggetto e i vecchi alle librerie per creare nuovamente l'eseguibile.
Altre volte il programma potrebbe non solo essere stato suddiviso dal programmatore il più file sorgenti, ma anche in più eseguibili, la cui compilazione può necessitare di uno specifico ordine sequenziale.
Il comando make, come abbiamo accennato
risulta molto utile per gestire la compilazione in casi come
questi.
Esso infatti, grazie ad un file di "indice"
chiamato Makefile e creato
appositamente per quel programma, è capace di gestire tanto la
compilazione quando la ricompilazione dello stesso, sapendo
individuare sia la sequenza con cui vanno compilati i sorgenti sia
quali di essi necessitino di una ricompilazione in caso
di modifiche ai sorgenti.
Dato il suo ruolo di gestore nel processo di compilazione
il comando make è quello che viene normalmente utilizzato nella
compilazione di un pacchetto Linux.
Generalmente la compilazione di un pacchetto Linux
si effettuata osservando i seguenti passi:
- Estrazione dei file sorgenti contenuti
nel pacchetto compresso, in una directory di lavoro.
$ tar xvzf PacchettoZXY.tar.gz - Posizionamento della shell all'interno della directory di lavoro e lettura dei file README e INSTALL in essa contenuti.
- Esecuzione (salvo diversa indicazione presente
nei file README o INSTALL) del comando
./configure presente nella
directory di lavoro.
$ ./configure
./configure eventualmente seguito da specifiche opzioni, serve per creare il Makefile necessario alla compilazione ed installazione del programma. - Esecuzione del comando make che procederà alla
compilazione del programma.
$ make - Esecuzione del comando make install che installerà il
programma. A differenza degli altri comandi quest'ultimo dovrà
essere eseguito con i privilegi di root.
$ su
# make install
Ulteriori argomenti trattati nella serata sono stati:
- Utilizzo del comando checkinstall
- Compilazione dei pacchetti SRPM
- Gestione dei pacchetti sorgenti attraverso APT di DEBIAN
- Gestione dei pacchetti sorgenti attraverso YAST di SuSE
- Gestione dei pacchetti sorgenti attraverso emerge di Gentoo
Relatore della serata:
Samuele Cacchiarelli