Linux Kernel, configuration, compiling - Dipartimento di Ingegneria ...

Sistemi Operativi 

Corso di Laurea Triennale 

in Ingegneria Informatica 

Esercitazione 11 

• Make 

• SVN 

• Kernel Linux (vs micro-kernel) 

• Configurazione e compilazione 

Linux Kernel 

daniel.cesarini@for.unipi.it 

1

MAKE

make 

make hello 

Si creano programmi a partire dal 

codice sorgente. 

Make esegue i passi necessari 

(compilazione, eventualmente altro) sui 

file sorgenti 

make hello → cc -o hello hello.c 

Kernel Linux, Configurazione e compilazione 3

Makefile 1/2 

Per definire il comportamento di make 

si scrivono dei file (chiamati makefile). 

Nei makefile si definiscono delle regole 

Se non sono definite esplicitamente, 

make cerca di utilizzare regole di 

default 

Nota: i makefile hanno come nome 

standard makefile e Makefile 


Makefile 2/2 

Nei makefile si indicano le 

interdipendenze dei file sorgenti e i 

comandi necessari per compilarli 

Make esamina l'età dei 

file, e ricrea i file 

dipendenti da file 

modificati 

successivamente alla 

loro creazione. 


Regole di Make 

I makefile sono una serie di regole e 

macro, per creare gli obiettivi 

La sintassi base delle regole è 

obiettivo { obiettivo } : [ dipendenza ] 

[; comando] { comando } 

L'obiettivo deve iniziare dalla prima colonna. 

Ogni comando successivo deve essere 

rientrato con una tabulazione 

program: program.o 

cc -o program program.o -lmylib 


Macro 

Alcune Macro di default: 

CC gcc 

MAKE make 

CFLAGS -0 

LDFLAGS [vuoto] 

Tali macro possono essere ridefinite, con 

variabili di ambiente, o usando l'opzione -e 

[variabile] da passare a make 


Regole di default di make 

Regole a un solo suffisso 

.c → $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< 

.sh → cp $< $@ ; chmod a+x $@ 

Regole a due suffissi 

.c.a → $(CC) $(CFLAGS) -c $< $(AR) \ 

$(ARFLAGS) $@ $*.o ; rm -f $*.o 

.c.o → $(CC) $(CFLAGS) -c $< 

 

 

$@ è l'obiettivo della specifica regola. 

$< indica il nome del file che ha determinato la scelta 

della regola 


Obiettivi ricorrenti 

Obiettivi “ricorrenti” dei makefile: 

clean: 

rm -f *.o 

all: $(TARGETS) 

clobber: 

rm -f $(TARGETS) 

install: 

[operazioni per l'installazione nel sistema dei 

file necessari per l'esecuzione del programma] 

In TARGETS si mettono tutti gli oggetti da creare col make. 

(es. TARGETS = first_exec second_exec third_exec) 


Esempio di makefile 

#Questo è un makefile 

CC=gcc 

CFLAGS=-Wall -Werr 

main: main.o 

cc -o main main.o -lpthread 

clean: 

rm -f main main.o 


Esercizi

Esercizi 1 

(copiate /opt/share/SO_esercitazione_4_codice.tar.gz 

nella vostra home e scompattatelo) 

Leggere i makefile contenuti nella cartella del codice 

Scrivere un file sorgente in c (.c) e un file header (.h) 

incluso dal file .c. Compilare il file.c con gcc. Scrivere 

poi un makefile per la compilazione del file .c, 

specificando le dipendenze. Provare a modificare il 

file .h (ponendoci ad esempio una costante, che viene 

stampata a video dal programma). Modificando il 

file.h cosa succede durante la compilazione con 

make? E cosa succede se non è indicato nel makefile 

la dipendenza del file.c dal file.h? 


Riferimenti

Riferimenti 

GNU Make: A Program for Directing 

Recompilation by Richard M. Stallman 

and Roland McGrath 

http://www.x.org/ - Official site of the 

Xorg foundation 

http://www.linfo.org/x.html – 

introduction to X 

http://tools.ietf.org/html/rfc1198 – RFC 


SVN

SVN - Introduzione 

SVN (SubVersioN) è uno strumento di 

“source control” o “revision control”. 

Tener traccia di modifiche a codice 

sorgente. 

Permette agli utenti di essere sincronizzati 

sui cambiamenti al codice. 


Repository 1/2 

SVN salva tutti i dati tenuti sotto 

controllo in un apposito repository. 

Per usare SVN: 

creare il repository 

mkdir svnroot 

svnadmin create svnroot/nome_progetto 

Il contenuto della cartella non va 

modificato manualmente. 


Repository 2/2 

Dare i permessi di scrittura sulla cartella 

agli utenti che debbono usare quel 

repository. 

Esempio: 

creare un apposito gruppo, svnusers 

assegnare il repository a quel gruppo, 

renderlo scrivibile dal gruppo e aggiungere 

gli utenti al gruppo svnusers 


Eseguire il checkout 

svn co [protocol://][user@][server][/repo] 

checkout di un intero repository SVN. 

Localmente crea una cartella che 

contiene una copia dei file scaricati dal 

repository. 


Comandi svn 1 

svn diff → differenze tra il file 

modificato e l'ultima versione scaricata 

svn ci → commit delle modifiche 

eseguite localmente 

svn up → esegue l'update dei file dal 

repository verso la copia locale 

svn help → aiuto!!! 

Si possono invocare sia sull'intera cartella che su 

singoli file o sottocartelle 


Comandi svn 2 

svn add nomefile → aggiunge un file 

svn mkdir dirname → crea una nuova 

cartella 

svn delete name → elimina il file o 

directory 

svn move sorg dest → sposta “sorg” in 

“dest” 

Attenzione: ciò che è sotto il controllo di 

SVN va alterato solo con i comandi appositi 


Esercizi SVN 

Creare in /home/studenti/svn/repo un repository con 

svnadmin 

Fare il checkout da /home/studenti/svn/repo in 

/home/studenti/localsvn del repository (svn co 

file:///PERCORSO 

Provare a caricare nel repository qualche file 

sorgente (eventualmente quelli creati per make, o gli 

script del precedente punto). Eseguire delle 

modifiche ai file ed eseguire il commit sul repo. 

mkdir /home/studenti/svn 

svnadmin create /home/studenti/svn/repo 

svn co file:///home/studenti/svn/repo localsvn 

cd localsvn … aggiungete qualche file (cp e svn add) 


Esercizi

Riferimenti SVN 

Controllo di Versione con Subversion: 

http:// svnbook.red-bean.com/ 

(disponibile online e pubblicato da 

O'Really) 


Kernel

Sommario - Kernel 

Kernel monolitico vs modulare vs 

microkernel 

Kernel Linux: configurazione e 

compilazione 

... 


Kernel 

(Differenti approcci)

Kernel monolitico 

Un unico file oggetto 

Un unico spazio di indirizzamento nel 

kernel 

tutti i processi a livello di sistema 

(quando sono nel kernel) 

condividono lo spazio di 

indirizzamento 

CPU, mem, IPC, Driver, Permessi, … nel 

kernel 


Micro-Kernel 

Nucleo “micro” 

Ridotto all'essenziale per garantire 

l'astrazione di macchina 

Scheduler (CPU virtuali) 

Memory management (memoria virtuale) 

IPC - Inter Process Communication 

es. L4 (Jochen Liedtke), GNU/Hurd, ... 


Monolithic vs Micro-Kernel 

microkernel: 

PRO 

- isolamento componenti 

- resistenza ai guasti 

- sicurezza 

CONTRO 

- tutto passa dall'IPC: 

- prestazioni, 

- difficoltà progettuale 


Kernel modulare 

I kernel monolitici possono essere 

“modularizzati” 

Tale operazioni non incide sullo spazio di 

indirizzamento del kernel 

Si dice kernel modulare un kernel che 

permette il caricamento dinamico (a 

runtime) di moduli oggetto 


Kernel Linux 

configurazione / compilazione

Kernel Linux (2.6.x) – Numeri 

mole: 

320 Mb di sorgenti per 

4’500’000 LOC 

costo dello sviluppo: 

4’500 anni/uomo, 

612’000’000 $ totale 

fonte: 

www.dwheeler.com/essays/linux-kernel-cost.html 


Ottenere il kernel 

http://www.kernel.org 

tarball da 30 Mb contenenti 

sorgenti C (portabili su almeno 16 

architetture ad oggi) 

Assembly (architecture specific) 

interamente rilasciato sotto licenza GPL 

(firmware a parte) 

compilabile utilizzando utility GNU 

(GCC, Make, Binutils) 

SCM utilizzato dalla comunità: git 


Linux Kernel 

È un kernel monolitico (i.e. non 

microkernel), ma modulare 

L’installazione consiste di: 

parte monolitica (vmlinuz) 

moduli (initrd) 


Linux – parte “monolitica” 

 

Non risiede necessariamente sul filesystem, ma deve 

essere nota al boot loader (e.g. lilo, grub, yaboot, 

loadlin, . . . ) 

il boot loader è l’applicazione che si preoccupa di 

“installare” il kernel in modo che la procedura di 

bootstrap della macchina (tipicamente implementata 

nel BIOS) sia in grado di accedervi 

è fortemente dipendente dall’architettura 

esempi: lilo e grub su i386, yaboot su powerpc 

 

 

Quando risiede sul filesystem tipicamente è un unico file: 

/boot/vmlinu{x,z}- 

(e.g. /boot/vmlinux-2.6.32) 

Viene caricata in memoria al boot e mai scaricata 


Linux – moduli del kernel 

 

 

 

Parti di kernel, caricati/scaricati su richiesta, manualmente 

dall’utente o da demoni preposti (kerneld, ora kmod 

subsystem) 

Devono essere accessibili a runtime, quindi sono nel 

filesystem 

un albero di file oggetto (.o, ora .ko) 

radicato in /lib/modules// 

(e.g. /lib/modules/2.6.32/) 

Flessibilità dei moduli 

name aliasing ed opzioni 

(/etc/modules.conf, /etc/modprobe.d/) 

dipendenze inter-modulo 

(/lib/modules/.../modules.dep) 

moduli caricati al boot (/etc/modules) 


Gestione moduli 

Comandi inerenti i moduli: 

Caricamento su richiesta 

insmod (full path, non gestisce alias e dipendenze) 

modprobe (nome modulo, gestisce alias e 

dipendenze) 

Rimozione: rmmod, modprobe -r (gestisce 

dipendenze) 

Lista dei moduli caricati: lsmod (implementato via 

/proc/modules) 

Calcolo delle dipendenze: depmod 

Informazioni (parametri, licenza, . . . ): modinfo 

Pacchetto Debian module-init-tools 


Configurazione e 

compilazione

Configurazione

Configurazione, compilazione, 

installazione kernel 

Gestite dal Makefile distribuito assieme al kernel 

Target del Makefile: config, xconfig, menuconfig, 

oldconfig, gconfig (solo 2.6.x) 

Ogni (o quasi) componente del kernel può essere: 

compilata ed inclusa nella parte monolitica 

compilata come modulo 

non compilata 

Vengono gestite dipendenze inter-componente 


Configurazione 

Risiede nel file .config all’interno dell’albero dei 

sorgenti 

La configurazione del kernel installato è tipicamente 

in /boot/config-X.X.X (X.X.X versione kernel installato) 

Per partire da quella base copiarlo nella cartella in cui 

sono i sorgenti 


Compilazione

Compilazione 

 

 

Target del Makefile di interesse: 

pulizia: clean, mrproper 

compilazione parte monolitica: bzImage 

compilazione moduli: modules 

Risultati della compilazione 

arch//boot/bzImage 

più i file (.o/.ko) per i moduli 

Installazione: 

 

 

 

su disco: fortemente dipendente dal bootloader, spesso 

target install del Makefile 

su floppy: dd if=..../bzImage of=/dev/fd0 

moduli: target modules_install del Makefile 


Initrd (1/2) 

INITial Ram Disk 

Nel caso che parti del kernel necessarie al boot 

siano necessarie al boot (e.g. supporto scsi, 

filesystem, RAID) è possibile utilizzare un “initrd” 

Ogni initrd è una immagine (compressa, 

tipicamente in formato cpio + gzip) di un 

filesystem minimale contenente: 

moduli necessari al boot del sistema 

tool per il boot del filesystem reale (post 

caricamento dei moduli) 


Initrd (2/2) 

 

 

 

 

Procedura (semplificata) di boot con initrd: 

loading del kernel e del ramdisk (boot loader) 

mounting del ramdisk come root filesystem (kernel) 

esecuzione di un programma predefinito (e.g. 

/init, /linuxrc) (kernel) 

loading di moduli necessari (/init) 

mounting del filesystem reale (/init) 

pivot_root (/init) 

procedura usuale di boot 

La configurazione di initrd è bootloader-dependent 

Comandi: mkinitrd, yaird, mkinitramfs(-kpkg), 

update-initramfs 


Kernel Linux 

- 

the Debian way of life

Kernel – the Debian way 1/2 

Debian (come ogni distribuzione) fornisce pacchetti 

contenenti il kernel e i moduli. 

 

 

Vantaggi: supporto alla sicurezza, stabile e testato 

Svantaggi: non all’ultimo grido, pochissime patch extra 

Può risultare utile utilizzare un kernel più recente per avere 

migliore supporto hardware o software (NIC ethernet 10’000, 

funzionalità stack di rete, virtualizzazione, . . . ) 

 

 

 

Debian fornisce una utility make-kpkg (pacchetto 

kernel-package) per creare pacchetti del kernel 

customizzati 

Vantaggi: facile installare anche su un intero cluster, 

integrato con il package manager, integrato con patch 

presenti nell’archivio Debian 

Svantaggi: niente supporto da parte del security team di 

Debian 


Kernel – the Debian way 2/2 

Per ottenere un pacchetto del kernel custom 

 

 

 

 

Scaricare la tarpalla desiderata (o pacchetto 

linux-source-2.6.26) 

Configurare il kernel (make oldconfig) 

Compilazione: 

make-kpkg --initrd kernel_image kernel_headers 

Opzioni: 

CONCURRENCY_LEVEL per specificare il numero di cpu da 

usare 

--append-to-version (alla versione del kernel) 

--revision (del pacchetto debian) 

--added-patches (vedi apt-cache search linux-patch) 

--added-modules (vedi module-assistant) 


Moduli non ufficiali — the 

Debian way 1/2 

Molti driver non vengono integrati nel kernel di 

www.kernel.org per motivi di obsolescenza oppure di 

immaturità 

 

 

 

 

 

Debian fornisce una utility per creare pacchetti per tali 

moduli chiamata module-assistant (aka m-a, ) 

Pacchetti con suffisso -source o -src nell’archivio (e.s. 

linux-wlan-ng-source) contengono i sorgenti di tali 

driver che devono poi essere compilati con m-a 

Vantaggi: generazione di pacchetti Debian 

Svantaggi: niente supporto dal security team 

Modalità interattiva: m-a 


Moduli non ufficiali — the 

Debian way 2/2 

Listing dei driver disponibili: m-a list 

Preparazione del sistema alla compilazione 

(installazione degli header del kernel): m-a 

prepare 

Build: m-a build linux-wlan-ng 

(build) e installazione: m-a a-i linux-wlan-ng 

Update del DB di driver noti: m-a update 

Interfaccia testuale (utile per bugreport): m-a -t 

Kernel per cui compilare (default è quello in 

esecuzione): m-a -l 2.6.26-1-amd64 


Cosa c'è nel kernel?

Guardiamo un po' nel kernel 

 

Invochiamo il comando make menuconfig 

Ci si presenta un menu in ncurses (interfaccia testuale 

interattiva, basata sulle librerie ncurses) 

 

 

Possiamo trovare corrispondenze tra voci del menu e 

codice? 

Guardate un po' nei sottosistemi del kernel (dal menu, e 

poi direttamente nella gerarchia delle cartelle) 


Esercizi

Esercizi 

 

Scaricare da http://kernel.org l’ultima versione stabile del 

kernel Linux 

Configurarla 

Compilarla con make-kpkg 

Installare il deb risultante e tentare un boot (non 

rimuovere il kernel precedente, in caso qualcosa vada 

storto è bene avere almeno un kernel funzionante) 

 

Utilizzare m-a per compilare un modulo non ufficiale a 

vostra scelta (es. linux-wlan-ng) 


Riferimenti (e fonti del codice, 

e delle slide) 

Linux Kernel Development (Robert Love) 

www.kernel.org – per il codice 

www.debian.org e www.debianizzati.org per 

la compilazione “a-là Debian” 

www.msr-inria.inria.fr/~gares/STSL10 - Enrico 

Tassi - (buona parte di queste slide sono state 

copiate direttamente in questa presentazione, 

perché si è ritenuto che il materiale originale 

fosse una valida base per la lezione)

Linux Kernel, configuration, compiling - Dipartimento di Ingegneria ...

Create successful ePaper yourself

Delete template?

Save as template?