Esercitazione Linux

Esercitazione di laboratorio -Sistemi di Elaborazione dell'Informazione

Introduzione a Linux

DIIGA - Università Politecnica delle MarcheA.A. 2009/10

Francesco Spegni

[email protected] su appuntamento

Gianluca [email protected]

Ricevimento su appuntamento

Linux

■ Sistema operativo Open Source

■ Qualità che possiede:

• Stabilità• Portabilità• Sicurezza

Interesse in ambito tecnico-scientifico:

• Università e istituti di ricerca• Aziende che lavorano con sistemi informatici di qualità

Sistema operativo multiutente

■ In questo corso utilizziamo la distribuzione Ubuntu 9.10 64bit

■ Almeno un utente: root

■ Utenti diversi da root hanno di solito minori privilegi: per privilegisi intende la possibilità di eseguire certe azioni su certi oggetti

– L'utente non-root di default (in Ubuntu) si chiama ubuntu

■ Privilegi relativi agli accessi ai file:– Lettura– Scrittura– Esecuzione

Struttura di Linux

■ Kernel : (lett. gheriglio) cuore del sistema operativo, fornisce le funzioni fondamentali (es. scheduler, memoria virtuale) e le syscall

■ Shell: interpreta i comandi; può essere testuale o grafica

■ Programmi di servizio, ad esempio l’ambiente grafico:

• Composto da vari livelli• Tra cui un Window Manager (ad esempio XFree)• Un’interfaccia grafica (ad esempio Gnome)

Distribuzione usata: Ubuntu

■ Basata su Debian

■ Versione LiveCd: sistema operativo presente su CD, caricato in memoria principale al momento del boot

■ Kernel 2.6

■ L’avvio non presuppone l’installazione

■ Cambiare la sequenza di boot dal BIOS (eventualmente)• Accertarsi che venga interrogato il CDROM in fase di avvio

■ Salva su Ramdisk: le modifiche alla configurazione si perdono ad ogni boot

Shell e Console

■ Si lavora principalmente da riga di comando

■ Con ctrl+alt+Fn (Fn = F1 F2 F3 ...) si cambia il terminale corrente

• Shell testuale: ctrl + alt + F2

• Shell grafica: ctrl + alt + F5

■ Di solito si utilizza l’ambiente grafico che permette di aprire una Console (detta anche Terminale) per impartire comandi

Arresto del sistema

■ Usare il comando halt (servono i privilegi di root)

■ Oppure con il comando shutdown –h now

■ Dall’interfaccia grafica si può usare la sequenza classica di operazioni

■ Per riavviare usare il comando reboot

■ Chiudere le console con exit– NOTA: se si è eseguito 'su', occorre uscire sia dalla shell di

root che da quella di utente;

Esercitazione di laboratorio -Sistemi di Elaborazione dell'Informazione

Shell e comandi


Shell (interprete dei comandi)

■ La shell è un’interfaccia (tipicamente testuale) che permette ad un utente d’interagire con il sistema, compiendo le seguenti azioni:

• mostra l'invito, o prompt, all'inserimento dei comandi;• interpreta la riga di comando impartita dall'utente;• esegue delle sostituzioni, in base ai caratteri jolly e alle

variabili di ambiente;• mette a disposizione alcuni comandi interni;• manda in esecuzione i programmi esterni installati nel

sistema;• gestisce la redirezione dell'input e dell'output;• interpreta ed esegue file (chiamati anche script o batch)

contenenti sequenze di comandi

Tipi di Shell

■ Con l'evoluzione dei sistemi UNIX, allo scopo rendere il più comodo e personalizzabile possibile l'ambiente di lavoro, sono stati introdotti diversi tipi di shell:

TIPO DI SHELL PROGRAMMA• Bourne shell • sh• C shell • csh• Korn shell • ksh• Bash • bash

■ Il funzionamento del sistema è fortemente dipendente dalla shell utilizzata. La shell standard del sistema Linux è la Bash.

Sintassi dei Comandi

■ La sintassi dei comandi dipende dal tipo di shell impiegata.

■ In generale, la sintassi tipica ha la seguente forma:

comando opz1..opzn arg1..argn

• opz indica in che modo deve essere compiuta l’azione

• arg è un generico oggetto su cui il comando agisce

■ La shell cerca in opportune directory; se esiste un file eseguibile

chiamato comando lo esegue e gli passa i parametri; alla fine restituisce un prompt all'utente

• Alcuni comandi sono codificati direttamente “dentro” la shell, per cui non vengono cercati nel filesystem

Notazione

■ Le metavariabili, scritte in corsivo, esprimono l'informazione che deve essere inserita al loro posto. Gli altri oggetti sono termini chiave che, se usati, devono essere espressi così come sono.

■ Quello che appare racchiuso tra parentesi quadre rappresenta un termine facoltativo. Es: [uno]

■ La barra verticale (| , chiamata anche 'pipe') indica la possibilità di scelta tra due o più alternative. Es: uno | due | tre

■ I termini tra parentesi graffe rappresentano le alternative di scelta obbligatoria. Es: {uno | due | tre}

■ I puntini (...) indicano la possibilità di aggiungere altri elementi dello stesso tipo di quello che li precede. Es: uno due tre ...

Nozioni sparse (1/2)

■ Linux cerca di seguire la filosofia Unix: “tutto è un file”

■ A differenza di altri sistemi operativi, i file sono strutturati in un unica struttura ad albero (il filesystem):

• //bin

.../etc

.../mnt /mnt/disk_1 /mnt/disk_2

.../home /home/pippo /home/pluto

...

Nozioni sparse (2/2)

■ Ci sono (sequenze di) caratteri che indicano posizioni “speciali” del filesystem:

• ~ : la home directory dell'utente corrente• ~pluto : la home directory dell'utente pluto• . : la directory corrente (utile per i path relativi)• .. : la directory superiore (o padre), nell'albero• / : la directory principale del filesystem (nota come root-

directory – directory radice –, utile per i path assoluti)

■ Vedremo come saranno utili per specificare gli argomenti da passare ai comandi

Comandi utili

■ man

Mostra come usare un comando, la sua sintassi e l’insieme dei parametri accettati

ex: man ls

■ whoami

Visualizza il nome dell’utente che sta utilizzando la shell corrente

■ pwd

Visualizza il percorso completo della directory in cui ci si trova(pwd = print working directory)

ls

■ Elenca i file contenuti in una directory (list directory).

ls [opzioni...] [file...]

■ Esempi• $ ls

Elenca il contenuto della directory corrente.

• $ ls *.docElenca tutti i file che terminano con il suffisso .doc che si trovano nella directory corrente.

• $ ls –help oppure $ls -hMostra una guida sull'utilizzo del comando

Carattery jolly - digressione

■ Riprendiamo l'esempio precedente:• $ ls *.doc

■ La sostituzione dei carattery jolly è eseguita dalla shell (non dal comando!)• Se esistono (solamente!) i file pippo.doc e pluto.doc, allora il

comando sopra equivale al comando:

$ ls pippo.doc pluto.doc

■ Corollario:• Le regole di sostituzione dei caratteri jolly sono uniche per

tutti i programmi Linux

■ Domanda:• Quanti argomenti riceve il comando ls ?

Alcune opzioni di ls

• -l : fornisce un elenco con più dettagli sui files

• -s : fornisce la dimensione in blocchi dei files (size)

• -t : elenca nell'ordine di modifica (prima il file modificato per ultimo) (time)

• -1 : elenca mostrando un nome per ogni riga

• -a : visualizza tutti i file compresi quelli nascosti (all)

• -r : inverte l’ordine di visualizzazione

• -R : elenca in modo ricorsivo ogni sottodirectory

• -i : mostra anche gli inode-number dei files

Esempi

• $ ls /bin

visualizza il contenuto della directory bin. I nomi rappresentano file di qualunque tipo (sottodirectory incluse).

• $ ls -l /bin

Si è ottenuto un elenco più dettagliato che, in particolare, mostra i tipi dei files, i permessi e le appartenenze.

Non vengono comunque visualizzati i files nascosti.

• $ ls -la /bin

Si è ottenuto un elenco dettagliato che mostra anche i files nascosti.

Operare come amministratore

■ Due modi per eseguire comandi con i privilegi di root– $ sudo <nome_comando> [<parametri>]– $ su

[inserire la password di root se serve]# <nome_comando> [<parametri>]

■ Differenze– sudo non apre una nuova sessione di login, ma si

limita ad eseguire il comando specificato e torna in modalità utente

– su apre una nuova sessione di login; dopo aver eseguito il comando specificato rimane in modalità root

Esempi

• $ ls /rootls: cannot open directory /root: Permission denied

viene segnalato un errore perchè occorrono privilegi da amministratore per leggere in contenuto di /root

• $ sudo ls /root[sudo] password for ubuntu:file1 file2 file3

Tramite il comando sudo scopriamo che in /root sono contenuti i file file1 file2 file3

cd

■ Cambia la directory corrente (change directory).

cd [directory]

■ Esempi

• $ cd ..

Cambia la directory corrente, spostandosi nella directory superiore.

• $ cd ciao

Cambia la directory corrente, spostandosi nella directory ciao che discende da quella corrente.

Altri Esempi

• $ cd ~

Cambia la directory corrente, spostandosi nella directory personale (home) dell'utente.

• $ cd ~daniele

Cambia la directory corrente, spostandosi nella directory personale dell'utente daniele.

• $ cd /tmp

Cambia la directory corrente, facendola diventare /tmp.

• $ cd /bin$ pwdCosa stampa?

mkdir

■ Crea una directory (make directory).

mkdir [opzioni...] directory...

■ Esempi

• $ mkdir cloro

Crea la directory cloro, come discendente di quella corrente.

• $ mkdir /sodio/cloro

Crea la directory cloro, come discendente di /sodio.

• $ mkdir ~/cloro

Crea la directory cloro, come discendente di quella dell'utente.

cp (1/2)

■ Copia uno o più file (incluse le directory) in un'unica destinazione (copy file).

cp [opzioni...] origine... destinazione

■ Se vengono specificati solo i nomi di due file normali, il primo viene copiato sul secondo, viene cioè generata una copia che ha il nome indicato come destinazione.

• cp pippo pluto

cp (2/2)

■ Se il secondo nome indicato è una directory, il file viene copiato nella directory con lo stesso nome di origine.

• Es.

$ mkdir ./pluto$ cp pippo pluto$ ls ./pluto

■ Se vengono indicati più file, l'ultimo nome deve essere una directory e verranno generate le copie di tutti i file indicati, all'interno della directory di destinazione.

• Es.

$ mkdir ./pluto2$ cp topolino pippo pluto2$ ls ./pluto2

Opzioni ed esempi

• -f : sovrascrive forzatamente i file di destinazione.

• -p : mantiene le proprietà e i permessi originali.

■ Esempi

• $ cp -r /test/* ~/prova

Copia il contenuto della directory /test in ~/prova copiando anche eventuali sottodirectory poste in /test.

• $ cp -r /test ~/prova

Copia la directory /test in ~/prova, copiando anche eventuali sottodirectories contenute in /test.

rm

■ Rimuove i file indicati come argomento.

rm [opzioni...] nome...

■ Esempi

• $ rm prova

Elimina il file prova.

• $ rm ./-r

Elimina il file -r che inizia il suo nome con un trattino.

• $ rm -r ~/varie

Elimina la directory varie insieme a tutte le sue sottodirectory.

rmdir

■ Rimuove la directory specificata (remove directory). Se si tenta di eliminare una directory non vuota, con rmdir si ottiene un segnale di errore.

rmdir [opzioni...] directory...

■ Esempi

• $ rmdir carbonio

rmdir: carbonio: Directory not empty

• $ rm -r carbonio

Elimina la directory carbonio e tutto ciò che da essa discende.

mv

■ Sposta (rinomina) i file e le directory (move file).

mv [opzioni...] origine... destinazione

■ Se vengono specificati solo i nomi di due elementi (file o directory), il primo viene spostato e rinominato in modo da ottenere quanto indicato come destinazione.

• Eccezione: se il secondo nome è una directory, il primo nome (file o directory) viene spostato dentro il secondo (come il comando cp)

■ Se vengono indicati più elementi (file o directory), l'ultimo attributo deve essere una directory: verranno spostati tutti gli elementi elencati nella directory di destinazione.

■ In Linux per cambiare un nome di un file occorre spostarlo.

Esempi

• $ mv prova1 prova2

Cambia il nome del file (o della directory) prova1 in prova2.Attenzione: se prova2 esiste già ed una directory cosa succede?E se prova2 esiste già ed è un file?

• $ mv * /tmp

Sposta, all'interno di /tmp, tutti i file e le directory che si trovano nella directory corrente.

touch

■ Crea un file o ne modifica la data e l’ora.

touch [opzioni..][time] filename...

■ Aggiorna la data e l'ora dell'ultimo accesso (opzione -a) o dell'ultima modifica (opzione -m) del file specificato.

■ Se l’opzione time non è specificato, usa la data e l'ora corrente.

■ Esempio

• $ touch pippo

$ ls -l pippo

-rw-rw-r-- ... 0 Jan 20 17:38 pippo

ln (1/2)

■ Associa il nuovo nome (detto anche link) al file esistente.

ln name1 name2

■ La creazione di un collegamento è un'operazione simile alla copia, con la differenza che invece di creare un duplicato di un file o una directory, si genera un riferimento agli originali.

■ Due tipi di link• simbolico: se elimino il file originale, il link non “funziona” più• hard-link: se elimino il file originale, il link continua a “funzionare”

ln (2/2)

■ Esempio

$ ln -s uno primo$ ls -l primo

lrwxrwxrwx ... 3 Dec 25 12:47 primo -> uno

which

■ Ci dice in quale punto del file-system si trova un comando■ Il comando which non fa una scansione di tutto il file-system,

analizza solo alcune directory. In futuro vedremo quali

■ $ which ls/bin/ls

■ $ which which/usr/bin/which

■ $ which cd$• Perché?

Esercizio

Una volta aperta una shell:■ Visualizzare qual è la directory corrente■ Creare una nuova directory chiamata prova■ Spostarsi nella directory appena creata■ Creare un file chiamato uno■ Creare una copia del file uno chiamata uno_copia■ Rinominare uno_copia in unouno■ Creare un link a unouno chiamato link■ Visualizzare i file con i dettagli■ Cancellare il file uno■ Risalire di una directory■ Cancellare la directory prova■ Chiudere la shell

Soluzione

1. pwd

2. mkdir prova

3. cd prova

4. touch uno

5. cp uno uno_copia

6. mv uno_copia unouno

7. ln –s unouno link

8. ls –l

9. rm uno

10.cd ..

11.rm –r prova

12.exit

Esercitazione di laboratorio

File Globbing


File Globbing

■ Il globbing (o filename generation) è il metodo attraverso il quale, tramite un modello simbolico, è possibile indicare un gruppo di nomi di file.

■ Si possono utilizzare i simboli seguenti:

• * : rappresenta un gruppo qualsiasi di caratteri, compreso il punto purché il punto non si trovi all'inizio del nome;

• ? : rappresenta un carattere qualsiasi, compreso il punto, purché questo punto non si trovi all'inizio del nome;

• [...] : rappresenta un carattere qualsiasi tra quelli contenuti tra parentesi, o un intervallo di caratteri possibili.

> es. di intervallo: [a-z]> es. di intervalli multipli: [a-z0-9]

Esempi

■ Si supponga che la directory corrente contenga i seguenti files:

• microinterruttore,

• xy123j4,• microscopico,

• xy789j111,• nanomicro,

• xy78j67• supersonico.

Esempi con *

■ $ ls• Elenca tutti i nomi di file e directory della directory corrente.

■ $ ls *• La shell provvede a sostituire l'asterisco con tutto l'elenco di nomi di

file e directory contenuti nella directory corrente. In questo caso, non solo viene elencato il contenuto della directory corrente, ma anche quello di tutte le eventuali sottodirectory.

■ $ ls micro*• microinterruttore, microscopico.

■ $ ls *micro*• microinterruttore microscopico nanomicro

Esempi con ?

■ Se si vuole intervenire su tutti i file lunghi esattamente sette caratteri che contengono la lettera j nella sesta posizione?

• $ ls ?????j?

xy123j4 xy456j5

■ Con l'asterisco non si può limitare il risultato ai file che contengono j nella sesta posizione, né la lunghezza del nome può essere presa in considerazione:

• $ ls *j*• xy123j4 xy456j5 xy789j111 xy78j67

(elenco di tutti i nomi con j)

Esempi con [ ]

■ $ ls xy????[4567]*

xy123j4 xy456j5

■ Si ottiene l'elenco di tutti i files i cui nomi:

• iniziano con xy;• proseguono con quattro caratteri qualunque• quindi contengono un carattere da 4 a 7• terminano in qualunque modo

■ Lo stesso risultato si poteva ottenere dichiarando un intervallo all’interno delle parentesi quadre:

■ $ ls xy????[4-7]*

Sequenze di Escape

■ Il fatto che la shell sostituisca alcuni caratteri impedisce di fatto il loro utilizzo nei nomi di file e directory.

■ Per evitare la loro sostituzione si possono far precedere da una barra obliqua inversa, che funge da carattere di escape (= simbolo di protezione).

■ $ touch sei\*otto

■ Con questa tecnica è possibile includere nel nome di un file anche lo spazio:

■ $ touch ciao\ simone

Verifica del Globbing

■ L'uso di caratteri jolly può essere pericoloso, soprattutto quando si utilizzano in comandi “distruttivi”.

■ Il modo migliore per verificare l'effetto della sostituzione dei caratteri jolly è l'uso del comando echo (o ls)

■ Ad esempio, per sapere quali file e directory vengono coinvolti dal modello micro*, basta il comando seguente:

• $ echo micro*

microinterruttore microscopico

Piccola nota finale

■ Chi gestisce il globbing?• la sostituzione del “globbing” con i nomi effettivi di file e directory, è

svolta dalla shell• Es. riguardiamo l'esempio di prima:

$ echo micro*

microinterruttore microscopico

il comando echo riceve DUE argomenti (alias, microinterruttore e microscopio) e NON uno solo (micro*)

• Da tenere a mente se e quando programmerete con la shell

Esercitazione

Comandi di shell avanzati

Comandi more e less

■ Per leggere un file possiamo utilizzare i comandi more o less:

• more [opzioni] file• less [opzioni] file

■ I due comandi sono simili:

• Il primo stampa a video il file, paginandolo• Il secondo lo apre in sola lettura• per entrambi con l’opzione h (in modalità interattiva) si ottiene una

breve guida

■ Alcuni tasti utili per il less:• per muoversi di una pagina usare i tasti spazio e b• per muoversi di una riga utilizzare i tasti ▲ ▼• per uscire utilizzare il tasto q

Comandi more e less

■ Se si vuole cercare una stringa all’interno del file, dopo averlo aperto, ad esempio, con less:

• /modello effettua una ricerca in avanti• ?modello effettua una ricerca all’indietro

■ Esempio:

• Spostarsi nella directory /proc• Aprire il file devices• Cercare il pattern “sound” con il comando /sound

■ Una ricerca all’indietro funziona allo stesso modo: basta sostituire “?” al posto di “/”

Ridirezione

■ I programmi eseguiti hanno a disposizione dei canali per il flusso dei dati:

• Uno standard input (che di solito è la tastiera)• Uno standard output (lo schermo del terminale)• Uno standard error (lo schermo del terminale)

■ Per la ridirezione dello standard output tramite la shell si usa il simbolo “>“

• programma > nomefile

■ Per la ridirezione dello standard input tramite la shell si usa il simbolo “<”

• programma < nomefile

Canali di comunicazione

Processostdinstdout

stderr

<

>

2>

Esempi

■ Un esempio per l’output:

• ls –al > file1• Questo comando stampa (sul file file1) l’output del comando ls• Infatti, possiamo aprire il file per leggere la lista di file e

sottodirectory della directory corrente

■ Un esempio per l’input:

• less < file1• Questo comando visualizza il file1 che avevamo creato

Esempio di script: ridirezione input[script]

#!/bin/bash

read nome

read cognome

echo Ciao, $nome $cognome

[dati]

Pinco

Pallino

./script < dati

Ciao, Pinco Pallino

Altri simboli

■ Se si usa il simbolo “>>”, l’output viene aggiunto in coda al file

• programma >> nomefile

■ Vediamo un esempio:

• ls >> file1

■ Lo standard error si ridirige utilizzando il simbolo “2>”:

• programma 2> nomefile

■ Vediamo un esempio:

• less file 2>> file1

Comandi in pipeline

■ La pipeline ridirige lo standard output del comando a sinistra del simbolo nello standard input del comando di destra.

■ Il simbolo utilizzato è “|”

■ Un esempio:

• ls –al | less

■ Nell’esempio precedente l’output del comando ls viene utilizzato come input del comando less

Diagramma pipeline

Processo 1(ls –al)

Processo 2(less)stdout stdin

|

Esercizi

■ Esercizio 1:

• Fare un elenco dei file e delle directory contenute in / in un file di nome “contenuto_root” (attenzione: non elencare le sottodirectory delle directory di / !!!)

■ Esercizio 2:

• Stampare il manuale del comando ls in fondo al file “contenuto_root”• Cercare all’interno del file la stringa “COPYRIGHT”

■ Esercizio 3:

• Stampare il manuale di ls a video utilizzando una pipeline e cercare la stringa “COPYRIGHT”

SoluzioniEsercizio 1:

• $ touch contenuto_root• $ ls / > contenuto_root• si può evitare di creare il file di nome “contenuto_root”, la creazione

avviene automaticamente

Esercizio 2:

• $ man ls >> contenuto_root• $ less contenuto_root • lanciare il comando /COPYRIGHT

Esercizio 3:

• $ man ls | less• Lanciare il comando /COPYRIGHT

Esercizi

■ Esercizio 4:

• Rinominare il file “contenuto_root” col nome “file3”• Rimuovere il file creato

soluzioni

■ Esercizio 4:

• mv contenuto_root file3• rm file3

Esercitazione

Processi Linux

Processi e Job in Linux

■ Processo:

• Sequenza di istruzioni contenute in un eseguibile• Può avviare altri processi (detti figli) attraverso una syscall fork• Il processo padre è responsabile dei processi figli (allocazione

risorse, terminazione, messaggio fine esecuzione)

■ Un job viene avviato dalla shell e può richiedere l’esecuzione di più processi

■ Con Linux si ha la possibilità di gestire sia i processi che i job

Stato dei processi

■ Un processo può essere:

• R in esecuzione (running)• S in pausa o dormiente (sleeping)• T sospeso (suspended)• Z defunto (zombie)• X morto• N valore di nice positivo (rallentato)

■ Linux rende disponibile la tabella dei processi nella directory /proc/

■ A questa tabella accedono i programmi per la gestione dei processi

Attributi della tabellasigla descrizione

UID Numero che identifica il proprietario

PID Numero che identifica il processo

PPID PID del processo padre

USER Nome del proprietario del processo

PRI Priorità del processo

NI Valore di nice

SIZE Dimensione dell’immagine in memoria virtuale

RSS Dimensione effettiva in RAM

Attributi della tabellasigla descrizione

SWAP Dimensione della memoria virtuale utilizzata

SHARE Quantità di memoria condivisa utilizzata

WCHAN Evento che il processo attende

STAT Stato del processo

TT Terminale utilizzato

TIME Tempo di utilizzo CPU

CTIME Tempo di CPU sommando il tempo dei figli

COMMAND Comando per avviare il processo

Comandi ps e pstree

■ ps [opzioni] [PID]

■ Tra le opzioni:• l emette un elenco con molti elementi• a visualizza anche i processi di altri utenti• -aux visualizza anche i processi di sistema

■ pstree [opzioni] [PID|utente]

■ Visualizza i processi in una struttura ad albero

■ Con l’opzione –p mostra i PID

Utilizzo del comando top

■ Questo comando visualizza l’utilizzo delle risorse di CPU, attraverso una tabella, cioè dei processi che la impegnano maggiormente

■ top [opzioni]:

• -d secondi intervallo di aggiornamento• -s disabilita i comandi di interattività

Controllo dei job

■ I comandi dalla shell avviano l’esecuzione di job in primo piano (foreground)

■ Si può scegliere di eseguire job in background: basta aggiungere & (e commerciale) alla fine del comando

■ Un esempio è il comando: yes > /dev/null &

■ Col comando jobs possiamo conoscere i job ed il loro stato

■ Per riportare un job in primo piano: fg

Invio di segnali ai processi

■ Si possono inviare dei segnali ai processi, vediamo alcuni di questi:

• SIGINT: interrompe il processo in esecuzione

• SIGKILL: uccide il processo in qualsiasi stato si trovi

• SIGQUIT: conclude l’esecuzione

• SIGTSTP: ferma l’esecuzione

• SIGCONT: riprende l’esecuzione

Invio di segnali ai processi

■ Si possono inviare segnali ai processi: attraverso vari comandi di shell, oppure da tastiera

■ kill è un comando che permette di inviare segnali ai processi:• kill [opzioni] PID• Per avere un elenco dei segnali: kill –l• Per inviare un segnale: kill –s segnale PID

■ Per inviare segnali da tastiera:• Per inviare un SIGINT: ctrl+c• Per inviare un SIGQUIT: ctrl+\• Per inviare un SIGTSTP: ctrl+z• Per inviare un SIGCONT: fg

Esempio

■ Avviamo il job yes > /dev/null &

■ Leggiamo il suo PID con jobs

■ Lo sospendiamo: kill –s 20 %ID

■ Controlliamo lo stato con jobs

■ Lo portiamo in foreground: fg

■ Lo interrompiamo da tastiera ctrl+c


Gli Script


Gli Script

■ Uno script è un programma scritto nel linguaggio di shell, salvato in un file di testo.

■ Lo script di shell è un programma molto semplice, che di solito ha solo lo scopo di automatizzare delle operazioni banali, ma ripetitive.

■ Si possono realizzare script complessi che, al momento della loro esecuzione, necessitano di argomenti (parametri) sotto forma di opzione,

Avvio degli Script

■ Per richiedere che un determinato script venga interpretato ed eseguito da una shell, si può operare nei seguenti modi:

• $ shell < script• $ shell script• $ script

■ La prima riga dello script indica chi deve interpretarlo:

#!<pathname>

■ Esempio: #!/bin/bash

• il simbolo ‘#’ rappresenta l’inizio di un commento

Creazione e modifica di un file

■ Per creare un file utilizzare il comando touch.

touch [nomefile]

■ Esempio

• $ touch miadata

■ Per modificare un file utilizzare il comando vi.

vi [nomefile]

■ Esempio

• $ vi miadata

Esempi

miadata

#!/bin/bash

echo Data di oggi:

date

■ $ sh < miadata

Data di oggi:

gio mag 31 12:16:55 GMT-5 2001

■ $ sh miadata

Data di oggi:

gio mag 31 12:17:05 GMT-5 2001

Esempi

■ $ ./miadata

script1: Permission denied

■ $ chmod +x miadata■ $ ./miadata

Data di oggi:

gio mag 31 12:1:45 GMT-5 2001

Variabili di Shell

■ Si tratta di variabili che possono essere impiegate nella shell. Le loro principali caratteristiche sono:

• nome: stringa di lettere, cifre e underscore, il primo elemento deve necessariamente essere una lettera;

• tipo: solo stringa;

• non devono essere dichiarate;

• assegnamento nella forma: nome=valore;

• per indicare il valore di una variabile: $nome;

• scope: sono variabili locali alla shell corrente;

Variabili predefinite

■ Esiste un insieme di variabili di shell predefinite (per nome e significato) che contengono informazioni di interesse.

■ Il loro valore è assegnato direttamente dalla shell, ma a volte può essere modificato dall’utente con un opportuno comando.

■ Le più utilizzate sono:

• $0 nome dello script corrente;• $1 ... $9 $n è il valore dell'n-esimo argomento dello script;• $# numero dei parametri dello script;• $* lista di tutti gli argomenti dello script;• $$ PID della shell corrente;• $? codice di uscita dell’ultimo comando in foreground;• $! PID dell’ultimo comando in background.

set

■ Alle variabili $1 $2... è possibile assegnare un valore anche mediante il comando set.

set [valore ... ]

■ Esempio:

• $ set uno due tre

$ echo $1 $2 $3

uno due tre

• $ echo $1A

unoA

Passaggio di parametri

■ A uno script possono essere passati parametri come ad un normale comando:

script par1 par2 ... par9

Esempio

leggi

#!/bin/bash

echo Il tuo nome è $1 - Il tuo cognome è $2

■ $ leggi Luigi Bianchi

Il tuo nome è Luigi - Il tuo cognome è Bianchi

read

■ Legge linee dallo standard input della shell e le assegna in successione alle variabili specificate.

read [nomevar ... ]

■ Esempio: script1

#!/bin/bash

echo Please enter your name

read name

echo Your name is $name

• $./script1

Please enter your name

Francesco

Your name is Francesco

Variabili di ambiente

■ Poiché normalmente le variabili sono locali alla shell, occorre un meccanismo che consenta a questa di passare alcune informazioni ai processi da essa creati.

■ Infatti, può essere molto utile passare informazioni sull'ambiente di esecuzione, come ad esempio, il pathname della home directory.

■ Per questo si utilizzano i concetti di ambiente e di variabili di ambiente.

■ L'ambiente della shell è una lista di coppie nome=valore che viene trasmessa ad ogni processo da essa creato.

Modifica dell’ambiente

■ Una shell può:

• inserire delle variabili locali nel proprio ambiente (per "esportarle" nei processi che essa genererà);

• rimuovere delle coppie nome=valore dal proprio ambiente.

■ La lista delle variabili correnti si ottiene con il comando env.

■ Per inserire le variabili nell'ambiente dei processi creati si usa:

export [nomevar ... ]

■ Se nessun argomento è specificato, il comando elenca le variabili esportate dalla shell corrente.

Variabili d’ambiente predefinite

■ Esiste un insieme di variabili di ambiente predefinite che contengono informazioni utili sull'ambiente di esecuzione.

■ Il loro valore è in genere assegnato in un file di start-up (altrimenti, la shell può usare un valore di default).

■ Le variabili di ambiente più usate sono:

• $HOME pathname della home directory

• $PATH lista di directory in cui ricercare un comando

• $USER user-id dell'utente

• $SHELL pathname della shell di login

• $TERM tipo del terminale corrente

Variabili d’ambiente HOME

■ Contiene il pathname della home directory dell'utente. Il suo valore viene assegnato dal processo di login, che lo preleva da /etc/passwd.

■ Esempio

• $ echo $HOME

/home/tacconi

$ HOME=/altra

$ cd ~knoppix

$ pwd

/altra

■ La nuova home directory dell’utente ora è /altra.• Attenzione: la directory /altra deve esistere (mkdir)

Variabili d’ambiente PATH

■ Contiene i percorsi di ricerca per i comandi, cioè l'elenco delle directory nelle quali la shell cerca il comando da eseguire.

■ Esempio

• $ echo $PATH

/bin:/usr/sbin:/usr/bin:/usr/ucb:/etc:/usr/etc:.

$ PATH=.

$ echo $PATH

.

$ ls

ls: not found

■ Il comando ls non viene trovato. La shell, per come è stata istanziata PATH, cerca i comandi solo nella directory corrente.

Espressioni condizionali

■ comando1 && comando2 comando2 viene eseguito solo se comando1 è stato eseguito con successo (cioè se $?=0)

Esempio:• $ touch a

$ rm a && echo rimosso! rimosso

■ comando1 || comando2 comando2 viene eseguito solo se comando1 è stato eseguito senza successo (cioè se $?≠0)

Esempio:• $ rm a 2> out || echo errore!

errore!

Strutture di controllo

■ Come ogni linguaggio di programmazione procedurale, anche quello della shell dispone di strutture per il controllo dell’esecuzione.

■ Le strutture principali sono le seguenti:

ISTRUZIONE SIGNIFICATO• If selezione

• Case selezione multipla

• For iterazione enumerativa

• While, Until iterazione condizionata

■ Tali istruzioni hanno significati e finalità analoghe a quelli dei tradizionali linguaggi di programmazione.

Esempio (if)

#!/bin/sh

#Faccio la mia domanda

echo -n "Quanti anni hai? “

#Recupero la risposta

read ANNI

#Stampo a video il risultato

if [ ${ANNI} -lt 10 ]

then

echo "Sei un bambino"

elif [ ${ANNI} -lt 18 ]

echo "Sei minorenne"

else

echo "Sei maggiorenne"

fi

Esercitazione

Scheduling dei processi

Scheduling dei processi

■ Linux gestisce i processi in code di scheduling a diversa priorità• Real-time• Time sharing

■ Ogni coda utilizza un proprio algoritmo di scheduling• Per il time sharing l’algoritmo è di tipo round-robin basato su crediti• Per il real-time abbiamo due diversi algoritmi: RR e FCFS.

■ Il valore di priorità assegnato ad un processo utente è modificabile tramite il valore di nice

■ L’esecuzione dei processi time sharing è non preemptive, mentre nel caso di processi real-time vengono prelazionati i processi a priorità minore (compresi i time sharing).

Esecuzione dei processi time sharing

■ Lo scheduler sceglie il processo con il numero maggiore di crediti e gli assegna un quanto di tempo

■ Al termine del quanto assegnatogli, il processo riceve un timeout dallo scheduler, il quale assegna la CPU ad un altro processo e decrementa il suo numero di crediti

■ Quando tutti i processi nella ready-queue esauriscono i loro crediti, termina un’epoca e vengono ricalcolati i crediti di tutti i processi

■ Un processo può rilasciare spontaneamente la CPU:

• Al termine dell’esecuzione• Se richiede un I/O

Calcolo dei crediti

■ Ogni epoca ( 210 ms) vengono ricalcolati i crediti di tutti i ≈processi time sharing con la seguente formula:

• creditin+1 = (creditin / 2) + (ts_prioritàn / 4)

■ Il sistema del calcolo dei crediti implementa l’aging per processi I/O bound riassegnando la metà dei crediti residui (posseduti solo da processi nella coda di I/O)

■ Vediamo un esempio dove 1 secondo = 4 quanti = 20 tick

Processo Tempo di Arrivo

Classe discheduling

PrioritàRT

QuantoRT

Nice CPU burst

P1 0 TS 0 --- 0 7

P2 3 TS 0 --- -4 10

P3 9 RT FIFO 1 --- --- 4

P4 12 RT RR 2 5 --- 6

Crediti(P1) = (20 – 0)/4 = 5Crediti(P2) = (20 + 4)/4 = 6

|

0

|

5

|

9

|

12

|

18

|

19

|

25

P1 P2 P3 P4 P3 P2

Prelazione

|

27

P1

Scelta tra P1 (0 cred) e P2 (2 cred)

21: Ricalcolo crediti

Esempio

Comando nice

■ Il comando nice serve ad assegnare un valore di nice al processo al momento dell’esecuzione

■ nice [-n variazione] [comando]

■ Se non viene specificata, la variazione di default è l’aumento di un valore 10

■ Il valore di nice può variare tra -20 e +19

Comando renice

■ Questo comando modifica il valore di nice di un processo in esecuzione

■ renice priorità PID

■ Il processo assumerà un valore di nice pari al valore priorità

■ Anche in questo caso il range va da -20 a +19

■ La priorità dei processi non può variare in maniera indefinita: infatti un valore di nice molto alto non corrisponderà ad un effettivo aumento del valore della priorità

Esempio

■ Lanciare il comando top con un certo valore di nice:

nice –n -2 top

■ Aprire un’altra console e visualizzare i processi con ps –al

■ Cambiare il valore di nice del processo top incrementandolo di qualche unità, ad esempio: renice 3 PID

■ Controllare il nuovo valore di nice del processo


Script per l’avvio di processi


AVVIO DI SERVIZI

■ L’utente può avviare dei servizi di certi programmi attraverso processi, digitando dei comandi, ecc. …

■ E’ possibile farlo in due modi diversi:

tramite interfaccia grafica; tramite degli script.

L’ ideale sarebbe avviare certi servizi (come il web server, per esempio) all’avvio della macchina.

Vedremo di seguito come farlo…

INIT e /etc/inittab

■ Init è il padre di tutti i processi, il suo ruolo principale consiste nel gestire il lancio di tutti i programmi necessari per rendere il sistema attivo creare i processi a partire da uno script in /etc/inittab.

• Questo sistema di avvio si chiama System V: Ubuntu usa un sistema alternativo (chiamato upstart), configurabile con il file /etc/event.d/rc-default ed i comandi runlevel, telin e update-rc.d

■ Nell'inittab vengono definite le directory con gli script di avvio per i diversi runlevel (stati del sistema, in cui possono girare determinati programmi), il runlevel di default, altri script e comandi che vengono eseguiti al boot o in condizioni particolari.

■ Il primo script lanciato da inittab è (su Fedora) /etc/rc.d/rc.sysinit: che esegue varie operazioni tra cui:

Impostazioni di alcuni path generali nella variabile $PATH; Configurazione dell'ambiente di rete; Avvio swap per la memoria virtuale; Check del filesystem root; Mount del filesystem root in modalità scrittura/lettura; Preparazione del sistema per caricamento dei moduli; Check delle dipendenze dei moduli; Check di tutti i filesystem ed eventuali riparazioni; Mount di tutti i filesystem; Pulizia di file di supporto al boot e di processi non più attivi; Attivazione dello swapping; Caricamento Moduli; Attivazione dei servizi del runlevelrunlevel.

Runlevel■ Un runlevel è un’ astrazione software per indicare diversi stati della

macchina in cui possono girare diversi programmi.In genere su Linux sono utilizzati i seguenti livelli:

Runlevel 0 : /etc/rc.d/rc0.d Questo runlevel avvia la sequenza di arresto del sistema (shutdown) Runlevel 1: /etc/rc.d/rc1.d Questo runlevel rappresenta la modalità singolo utente, nessun altro

utente può collegarsi, il servizio di rete è disabilitato. Runlevel 2: /etc/rc.d/rc2.d Rappresenta lo stato multiutente, il servizio rete è attivo ma è

disabilitato il file sharing. Runlevel 3: /etc/rc.d/rc3.d In genere è quello predefinito quando si opera in modalità testuale,

tutti i servizi sono attivi. Runlevel 4: /etc/rc.d/rc4.d Inutilizzato. Può essere dedicato ad usi personali Runlevel 5: /etc/rc.d/rc5.d E' il runlevel predefinito quando si vuole avviare Linux in modalità

grafica Runlevel 6: /etc/rc.d/rc6.d Il runlevel 6 è quello di reboot.

■ Lo script /etc/rc.d/rc gestisce quali processi far partire a seconda del runlevel, andando ad analizzare le singole directory /etc/rc.d/rc#.d.

■ In queste directory esistono una serie di symlink con nomi del tipo S12syslog o K65identd che puntano a degli script con nomi tipo /etc/rc.d/init.d/syslog o /etc/rc.d/init.d/identd.

■ /etc/rc.d/rc a seconda della directory corrispondente al runlevel da caricare fa partire tutti gli script che iniziano con S e fa chiudere tutti quelli che iniziano con K, eseguendoli nell'ordine indicato dal numero presente nei nomi dei file.

■ Gli script che di fatto permettono di gestire l'avvio o lo stop di un servizio sono quindi nella directory /etc/rc.d/init.d/ e possono essere utilizzati direttamente dall'utente per gestire i singoli processi.

■ Per esempio:

/etc/rc.d/init.d/httpd start fa partire il server Web

e

/etc/rc.d/init.d/httpd stop lo fa stoppare.

■ Se abbiamo il file (link a ../init/httpd )

/etc/rc.d/rc3.d/S85httpd

avremo un server web avviato quando la macchina è al run-level3 run-level3

(runlevel di default per un server, che non ha bisogno di Xwindows)

■ Se vogliamo evitare che venga avviato un server web, basterà rinominare il file, sostituendo la K alla S:

mv /etc/rc.d/rc3.d/S85httpd /etc/rc.d/rc3.d/K85httpd

Molte distribuzioni Linux utilizzano path diversi per il loro script di startup,questo può disorientare l'utente e costringerlo a cercare script di startup e file in troppi luoghi diversi.

NON è necessario. Tutto parte da init e init si configura in /etc/inittab.

Leggendo questo file è possibile ricostruire l'intero processo di boot del sistema e vedere dove risiedono tutti gli script di statup.

■ Verificare:

cat /etc/inittab

Per verificare gli script lanciati all'avvio e quale runlevel viene utilizzato didefault

ls -l /etc/rc.d/

Lista dei file delle directory che contengono i vari script lanciati al boot

chkconfig --list

Visualizza per ogni servizio, se viene avviato o no nei diversi runlevel.

Il comando «getopt»

■ Utile per realizzare script da richiamare fornendogli opzioni, eventualmente associate a parametri (o argomenti)

■ getopt ha la sintassi seguente:

getopt stringa_di_opzioni stringa_da_interpretare...

• stringa_di_opzioni: elenco di lettere (non separate da spazi!) che rappresentano, ciascuna, (il nomi di) una opzione ammissibile

• per opzioni che richiedano un argomento, la lettera identificativa va seguita dal carattere ':'

• stringa_da_interpretare: sequenza di caratteri da interpretare e far “matchare” con la stringa_di_opzioni specificata sopra

• Esempio:

$getopt ab:c -a uno -b due -c tre quattro

Esempio getopt■ L'esempio seguente dovrebbe chiarire in che modo si può utilizzare getopt per

scandire gli argomenti della riga di comando:

#!/bin/sh# scansione_1.sh : Si raccoglie la stringa generata da getoptSTRINGA_ARGOMENTI=`getopt ab:c "$@"`# Si trasferisce nei parametri $1, $2,...eval set -- "$STRINGA_ARGOMENTI"while true ; do

case "$1" in-a) echo "Opzione a"

shift;;

-b) echo "Opzione b, argomento $2"shift 2;;

-c) echo "Opzione c"shift;;

--) shiftbreak;;

*) echo "Errore imprevisto"exit 1;;

esacdoneecho “Argomenti rimanenti:”for argomento in “$@” ; do

echo “$argomento”done

Esempio getopt (note sparse)■ QUALCOSA=`espressione`:

esegue l'espressione ed assegna lo standard output alla variabile di nome QUALCOSA

• attenzione agli apici inversi `...` e a non mettere spazi fra QUALCOSA,= e `espressione`

■ Se allo script passiamo degli argomenti, come in:

$ ./scansione_1.sh primo secondo terzo

essi saranno memorizzati nelle variabili $1, $2, ecc...■ shift [n]: sposta la variabile $x in $y, dove y = x – 2 (per x > n)■ set -- [stringa] : se stringa è specificata, la suddivide (basandosi

sugli spazi) per assegnare ciascun termine ad una variabile posizionale $1, $2, ... per il resto dello script

■ eval [comandi] : esegue i comandi specificati di seguito e permetti loro di modificare l'ambiente dello script corrente

Risultati dello script di esempio■ In pratica, si comprende che lo scopo di getopt è solo quello di

fare un po' di ordine tra le opzioni e di distinguere le opzioni dal resto.

■ Supponendo che il nome dello script sia scansione_1.sh, se si utilizza come nell'esempio già visto, si dovrebbe ottenere il risultato seguente:

$ ./scansione_1.sh -a uno -b due -c tre quattro

Opzione a

Opzione b, argomento “due”

Opzione c

Argomenti rimanenti:

uno

tre

quattro

Esercitazione

Pianificazione dei processi

Avvio di comandi in automatico

■ Si può avere la necessità di voler avviare dei processi in maniera automatica:

• Questo può avvenire all’avvio del sistema operativo

• Oppure in un momento stabilito

■ Esempi del primo caso sono i processi che partono quando si accende una macchina

■ Il secondo caso è relativo a processi che si vogliono avviare in un dato momento, anche se non si è fisicamente presenti per avviarli

All’avvio del sistema operativo

■ Il sistema operativo avvia un certo numero di processi al boot: questi processi vengono chiamati servizi

■ Anche gli utenti possono avviare processi al boot, mediante opportuni script

■ Gli script di avvio dei processi utente si trovano nelle directory /etc/init.d (come visto la precedente lezione)

■ Un esempio potrebbe essere un Firewall, che deve partire ad ogni boot, senza che venga lanciato il relativo comando (pensiamo ad un riavvio a causa di un calo improvviso di tensione)

Sintassi per gli script di avvio

■ La sintassi per l’avvio di un servizio da uno script è del tipo:

• nome_servizio {start|stop|restart}

■ Naturalmente start e stop sono, rispettivamente, comandi per avviare e fermare un servizio; restart per riavviarlo

■ Un esempio: /usr/sbin/script1 start

■ Spesso questi script vanno inseriti in directory differenti a seconda del runlevel di esecuzione del sistema

Pianificare l’avvio di un processo

■ Il secondo caso è quello dell’avvio di un processo in un momento stabilito

■ Per fare questo, esiste un daemon che si chiama Cron• un daemon (o demone) è un programma che risiede in background

e viene invocato per fornire un certo servizio (es. server web, server mail, ...)

■ Cron legge il file /etc/crontab per avviare processi• può esistere un file del genere associato ad ogni utente (a volte si

trova in /var/spool/cron/crontabs/<NOME_UTENTE>)

■ L’utente root ha accesso il lettura e scrittura a tutti i file crontab

Comando crontab

■ Per accedere a questi file si utilizza il comando crontab:• crontab [opzioni]

■ Tra le opzioni:• crontab [–u utente] file• Sostituisce il file crontab con il file passatogli come argomento

• crontab –l [-u utente]• Visualizza il file crontab dell’utente

• crontab –e [-u utente]• Crea o modifica il file crontab dell’utente

• crontab –r [-u utente]• Rimuove il file crontab dell’utente

File crontab

■ Solitamente non si modifica il file crontab direttamente; si usano appositi comandi

■ Il comando crontab –e crea ed edita il file crontab relativo all’utente; il file viene di solito aperto con l'editor vi

■ All’inizio del file, si possono assegnare le variabili:

• SHELL se non ci va bene quella di default (/bin/bash)• HOME per cambiare la directory dell’utente• MAILTO per stabilire a chi viene inviato l’output tramite e-mail

■ Di solito si lasciano quelle di default

File crontab

■ La parte relativa ai comandi è fatta di righe del tipo:

• data_orario comando

■ data_orario è composta da cinque campi * * * * *

• Minuti da 0 a 59• Ore da 0 a 23• Giorni_del_mese da 1 a 31• Mese da 1 a 12• Giorni_della_settimana da 0 a 7 (0 e 7 per la domenica)

■ L’asterisco indica qualsiasi valore possibile

File crontab

■ Ad esempio: 13 16 * * * indica le 16:13 di qualsiasi giorno

■ Invece 13 16 5 * * indica le 16:13 di ogni quinto giorno del mese

■ Esempio di comando:

• min ora * * * /bin/ps > /ramdisk/home/knoppix/uno

Esempi

■ Avviare il daemon cron

■ Creare un file di nome uno

■ Inserirci la tabella dei processi

■ La sequenza dei comandi è:

• cron• touch uno• crontab –e

■ Così viene creato e aperto il file crontab dell’utente root

Esempi

■ Per inserirci la tabella dei processi:

• min ore * * * /bin/ps > /ramdisk/home/knoppix/uno

■ In un altro esempio possiamo fargli creare il file di nome f e inserirci la tabella dei processi:

• min ore * * * /bin/touch > /ramdisk/home/knoppix/f

• min ore * * * /bin/ps > /ramdisk/home/knoppix/f

Esercitazione

Gestione della memoria

Gestione della memoria

■ Linux gestisce la memoria tramite paginazione su richiesta

■ La memoria virtuale ha un sistema di paginazione a tre livelli che utilizza un’area del disco detta swap area

■ L’utilizzo della memoria virtuale permette di avere a disposizione uno spazio di memoria molto più grande di quello reale

■ Purtroppo richiede una gestione complessa della memoria fisica e degli altri dispositivi (backing store)

■ All’utente sono visibili i parametri utilizzati dal gestore della memoria

Comandi ps e top

■ Abbiamo già visto questi comandi e i loro parametri relativi ai processi

■ Vediamo i parametri dell’utilizzo di memoria da parte dei processi

■ Il comando ps u:

• mostra le dimensioni della RAM utilizzata effettivamente (RSS)• la percentuale utilizzata su quella totale (%MEM)• la memoria virtuale utilizzata dal processo (VSZ):

vm_lib+vm_exe+vm_data+vm_stack

■ vm_lib è lo spazio di memoria virtuale che occupano le librerie, mentre vm_exe è quello occupato dall’eseguibile

Comandi ps e top

■ Il comando top:

• VIRT è simile a VSZ che abbiamo visto• RES è simile a RSS • SHR indica la quantità di memoria condivisa utilizzata dal processo

■ Un comando per avere dei parametri generali è free:

• free [opzioni]

■ Tra le opzioni:• -m visualizza in megabyte• -s secondi effettua periodicamente un aggiornamento• -t mostra una riga con i totali

Comando free

■ Se lanciamo free –m

• total memoria totale• used memoria usata• free memoria libera• shared memoria condivisa• buffers memoria dedicata al buffering• cached memoria dedicata al caching

■ La riga successiva mostra quanta memoria è occupata dai buffer e cache

■ L’ultima riga si riferisce alla partizione di swap

Comando pmap

■ Il comando pmap restituisce un mapping della memoria utilizzata da un processo

■ La sintassi è pmap [opzioni] PID

■ Se lanciamo il comando pmap –x PID:

• vediamo le dimensioni dei dati utilizzati dal processo (es. le librerie)• lo stack• il processo relativo• il totale

Comando vmstat

■ Il comando vmstat visualizza statistiche relative alla memoria virtuale

■ La sintassi è vmstat [opzioni]

■ Tra le opzioni:

• -a per visualizzare quantità di memoria attiva e inattiva• -m per visualizzare le dimensioni delle pagine

■ Se lanciamo il comando vmstat senza opzioni, ci restituisce tutta una serie di informazioni (raccolte a partire dall'ultimo reboot)

Comando vmstat

■ procs:• r numero di processi in attesa di esecuzione• b numero di processi in sleep ininterrompibili

■ memory:• swpd memoria virtuale usata• free memoria libera• buff memoria usata come buffer• cache memoria usata come cache• inact memoria inattiva• active memoria attiva

■ swap:• si memoria swapped in dal disco• so memoria swapped out sul disco

Comando vmstat

■ io:• bi numero di blocchi ricevuti da un dispositivo a blocchi• bo numero di blocchi inviati ad un dispositivo a blocchi

■ system:• in numero di interrupt al secondo (incluso il clock)• cs numero di context switch al secondo

■ cpu:• us tempo di esecuzione di codice non-kernel• sy tempo di esecuzione di codice kernel• id tempo di esecuzione idle (esecuzione al minimo)• wa tempo di waiting• i tempi sopra sono espressi in percentuale % sul tempo totale

Comando vmstat■ Lanciare il comando vmstat –m (visualizza l’utilizzo delle

cache) in una modalità detta slabinfo

Il risultato del comando sarà del tipo:Cache

Kmem_cache

Ip_fib_hash

…

Num

64

4

…

Total

64

203

…

Size

244

16

…

Pages

4

1

…

Cache: in Linux parte della memoria è organizzata in cache, una cache per ogni tipo di oggetto; ogni “slab”(essi sono piccoli e sempre contigui, usualmente lunghi una pag di memoria) contiene molti oggetti inizializzati.

Num: numero di allocazioni che hanno almeno un oggetto allocato attivo

Total: totale numero di allocazioni nella corrente slab cache

Size: questa è la dimensione di ogni oggetto allocato. C’è un overhead nel mantenere la cache; l’overhead varia con la dimensione dell’oggetto ( più piccolo è l’oggetto più elementi ci sono nella pagina e più overhead serve per la gestione di oggetto usato/non usato. Si può determinare quanti oggetti ci sono in ogni allocazione ( spesso coincide con una pag di memoria) dividendo numero di oggetti allocati per totali allocazioni.

Pages: dimensione di uno slab in pagine

Esercitazione

File system

File system di Linux

■ Caratteristiche del file system di Linux:

• Struttura a grafo generale• Allocazione indicizzata• Allocazione, il più possibile, contigua di blocchi logici contigui

■ Supporta quasi tutti i tipi di file system

■ Quello più diffuso è l’ext2 e il nuovo ext3 derivato direttamente dal primo:

• L’ext3 ha in aggiunta il journaling per mantenere la coerenza dei dati in scrittura, anche in seguito ad un’interruzione improvvisa (ad esempio un calo di tensione)

Allocazione

■ In Linux l’allocazione dei file è di tipo indicizzato:

• Utilizza dei blocchi indice detti i-node• I blocchi indice puntano ai blocchi del file o ad altri i-node

■ Cerca di allocare i blocchi logici contigui in blocchi fisici contigui

■ Sul disco sono presenti un certo numero di superblock che fanno riferimento ai diversi gruppi di blocchi

■ Nei superblock ci sono informazioni sui relativi gruppi di blocchi:

• mappa dei blocchi, mappa degli i-node, informazioni sui blocchi liberi, ecc.

Struttura a grafo

■ La struttura a grafo generale permette di creare dei link da file che si trovano in sottoalberi differenti

■ In Linux esistono due tipi di link:

• Hard link• Symbolic link

■ I primi condividono i blocchi i-node mentre i secondi hanno i loro i-node

■ Entrambi condividono permessi, owner, data di modifica, ecc.

Pathname assoluti e relativi

■ Se vogliamo fare riferimento ad un file che NON si trova nella directory corrente (indicata con “.” ) dobbiamo utilizzare il pathname assoluto: cioè, specificare le directory e sottodirectory

■ Se, invece, ci riferiamo ad un file o directory in quella corrente, possiamo utilizzare il pathname relativo

■ Vediamo un pathname assoluto e uno relativo:

• /ramdisk/home/knoppix/Desktop Assoluto

• Desktop Relativo

■ La directory superiore viene indicata con “..”

symlink e hard link

■ Per la creazione dei link si usa il comando ln:

• ln [opzioni] origine destinazione

• l’opzione più usata è “-s” che serve a creare i symlink

■ Iniziamo col creare un file di nome “uno” e un hard link, a questo file, di nome due:

• touch uno• ln uno due• ls –l

■ Come si vede “due” viene dichiarato come un file a tutti gli effetti

Symlink e hard link

■ Se vogliamo creare un link simbolico:

• ln –s uno tre

■ In questo caso il file “tre” viene dichiarato come link

■ Se rimuoviamo il file “uno” dobbiamo rimuovere anche i link:• se lasciamo gli hard link, possiamo ancora accedere al file• dai symlink non si può più accedere al file (essendo solo un

riferimento)

Permessi su file e directory

■ Con il comando ls –l possiamo visualizzare la lista dei file, delle sottodirectory e dei link, presenti nella directory

■ All’inizio compare una stringa di 10 caratteri del tipo: “-rwxr--r--”

• il primo carattere è un trattino per i file, una “d” per le directory e “l” per un link simbolico

• gli altri sono relativi ai permessi in lettura, scrittura e modifica per gli utenti user, group e others

■ Ad esempio: la stringa precedente ci dice che si tratta di un file, che l’utente attuale ha tutti i permessi e che il gruppo relativo e tutti gli altri hanno accesso in sola lettura

Permessi su file e directory

■ La notazione sui permessi sui file è di facile comprensione: si capisce cosa vuol dire lettura, scrittura ed esecuzione

■ Per quanto riguarda le directory:

• la lettura permette di listare la directory• la scrittura di creare file e sottodirectory• l’esecuzione di attraversare la directory

■ Attraversare la directory vuol dire avere la possibilità di accedere alle sottodirectory (es. con il comando cd)

Cambiare i permessi

■ Per la modifica dei permessi si usa il comando chmod:

• chmod [opzioni] permessi file

■ Non è tanto interessante conoscere le opzioni quanto sapere la sintassi di base

■ I permessi vanno scritti partendo dal tipo di utente che può essere:

• “o” per others, “g” per group, “u” per utente e “a” per tutti quanti• “=” per settare, “+” per aggiungere e “-” per togliere i permessi

■ Un esempio è: chmod a=rwx nome_file

Cambiare i permessi

■ Se omettiamo l’utente, fa riferimento a tutti:

• chmod –r nome_file

• toglie il permesso il lettura a tutti gli utenti (attenzione, TUTTI gli utenti = utente + group + others)

■ Knoppix ha dei problemi a far funzionare bene questo comando

■ Per farlo funzionare conviene usare un’altra notazione:

• -r-xrwx--- in stringa binaria diventa 101111000• tradotto in ottale diventa 570• chmod 570 nome_file

Cambiare i permessi

■ Per sapere come saranno i permessi alla creazione di un file, utilizziamo il comando umask:

• umask [-S] per conoscere quelli attuali• umask permessi per modificarli

■ Anche in questo caso Knoppix non funziona molto bene, ad esempio ha problemi alla creazione del file per i permessi di esecuzione

Comando find

■ Per cercare un file si può utilizzare il comando find:

• find [percorso] [espressione]

• [espressione] -> [opzione] [condizione]

■ Permette effettuare molti tipi di ricerca su espressioni anche molto complesse:

• sulle proprietà di file o directory• sui permessi• sulle caratteristiche dei nomi• sulla data di accesso e modifica• sulla dimensione• altre espressioni

Comando find

■ Vediamo alcuni esempi:

• find / -iname 'desktop'• find / -path '*/doc/*'• find . –amin -5

■ L’effetto:

• cerca i file e le directory di nome desktop in modalità case insensitive

• cerca i pathname che comprendono una directory doc• cerca nella directory corrente i file con data di accesso minore di 5

minuti fa

Comando grep

■ Il comando grep viene utilizzato per cercare stringhe all’interno di file:

• grep [opzioni] modello [file]

■ Tra le opzioni:

• -n restituisce il numero di riga • -i case insensitive• -c restituisce quante righe contengono il modello

■ Per gli esempi spostarsi nella directory /etc dove è presente un file services

Comando grep

■ Vediamo alcuni esempi:

• grep –n “tcpmux” services• grep –in “tcp” services• grep –c “tcp” services

■ Il risultato:

• restituisce il numero di riga della stringa cercata nel file services• come prima, solo che la ricerca è case insensitive• restituisce il numero di righe che hanno un match positivo

Esercitazione

Gestione dei dischi

Memoria di massa

■ La memoria di massa viene utilizzata come supporto non volatile di memoria.

■ Molto utilizzati i dischi magnetici; ad esempio il disco fisso (come memoria secondaria) e il floppy disk (come supporto rimovibile)

■ I dischi hanno un accesso diretto, ma permettono anche un accesso sequenziale

■ Hanno una serie di qualità tecniche che non elenchiamo

■ Conoscete a grandi linee la struttura a basso e medio livello dei dischi

Inizializzazione di file system

■ Prima di poter utilizzare un file system bisogna compiere una serie di operazioni che inizializzano il disco:

• inizializzazione a basso livello• eventuale suddivisione in partizioni• creazione della struttura iniziale

■ La prima operazione consiste nella formattazione

■ La seconda divide il disco in più parti: un’utilità delle partizione è quella di installarci diversi sistemi operativi

■ La terza crea il tipo di file system che si vuole utilizzare

Inizializzazione

■ Per i dischi il format è un’istruzione passata direttamente agli strumenti firmware (controller dei dischi)

■ Per formattare un disco rimovibile si usa il comando fdformat:

• fdformat [-n] dispositivo• con l’opzione –n non effettua il controllo alla fine

• fdformat /dev/fd0• formatta il floppy

■ Il comando badblocks serve ad effettuare una ricerca dei blocchi difettosi:

• badblocks [opzioni] dispositivo [fine] [inizio]

Partizioni

■ Il comando badblocks /dev/hda 100 1 effettua il controllo sul disco partendo dal primo blocco e fermandosi al numero 100

■ Un disco fisso può contenere più di una partizione e una partizione può essere formata da più di un disco

■ I dischi vengono indicati con hda, hdb, …, sda, sdb, …, dove i primi sono dischi ATA e gli altri SCSI (o SATA, USB, ...)

■ Le partizioni vengono indicate con hda1, hda2, dove abbiamo indicato partizioni dello stesso disco (hda1, hdb1 sono dischi diversi che formano una partizione)

■ Se si vuole installare Linux su una macchina e lasciare un altro sistema operativo bisogna avere più partizioni

Partizioni

■ Per partizionare il disco si può usare il programma fdisk

■ Permette di creare partizioni primarie, estese:

• permette di creare massimo quattro partizioni primarie• si può creare una partizione estesa che contiene molte partizioni

logiche

■ Se vogliamo installare Linux e mantenere Windows:

• creare due partizioni primarie• creare una partizione estesa• creare una partizione logica di swap dentro quella estesa

■ Il comando fdisk /dev/hda è interattivo

Esempio

■ Partizioniamo il disco (ATTENZIONE NON PREMERE W):

• cancellare le partizioni esistenti (d)• creare una partizione (n) primaria (p) o estesa (e)• controllare (p)• modificare in NTFS (t)• creare una per Linux native• creare una estesa • creare una di logica di swap• uscire senza scrivere (q)

■ Il comando cfdisk contiene le stesse funzioni, ha solo un’interfaccia più friendly

Mount di file system

■ Prima di poter accedere al file system, bisogna montarlo: questa operazione richiede un punto d’innesto (o mountpoint)

■ Dopo aver montato il file system, possiamo accedervi tramite il punto d’innesto

■ Il file /etc/fstab specifica le caratteristiche e i punti di innesto dei vari file system; in questo file si possono specificare i file system che devono essere montati automaticamente

■ Questo file è formato da record:

• nel primo c’è il nome del file system• nel secondo la directory d’innesto• nel terzo il tipo di file system


• nel quarto ci vanno opzioni speciali per il file system• nel quinto si specifica se può essere effettuato il dumping del file

system• nel sesto viene specificato l’ordine con cui effettuare il controllo di

integrità

■ Il file /etc/mtab ha la stessa notazione di /etc/fstab, ma contiene un elenco dei file system montati

■ Per effettuare il mount di un file system si utilizza il comando mount:

• mount [opzioni] [dispositivo] [directory]

• bisogna indicare il dispositivo dove si trova il file system da montare e la directory d’innesto


■ Tra le opzioni:

• -a per montare tutti i file system in /etc/fstab (ad eccezione di quelli con opzione noauto)

• -t tipo_filesystem per specificare il tipo• -o opzioni_speciali per specificare speciali opzioni

■ Esempio: montare un floppy nella directory /mnt

• mount /dev/fd0 /mnt

■ Esempio: montare un cdrom nella directory /cdrom

• mount /dev/cdrom /cdrom


■ Spesso capita di dover montare la pen-drive:

• bisogna inserirla e vedere come viene riconosciuta dal sistema, tramite il comando dmesg alla riga Attached scsi removable…

• poi effettuare il mount specificando il tipo di file system:

> mount –t vfat /dev/sdb1 /floppy

> effettua il mount nella directory d’innesto dei floppy di un file system creato da Windows

■ Alla fine bisogna smontare il file system col comando umount:

• umount [opzioni] [dispositivo] [directory]

• valgono le opzioni -a e –t del comando mount

Comando df

■ Il comando df elenca lo spazio libero delle partizioni:

• df [opzioni] [dispositivo]

■ Tra le opzioni:

• -i per sapere gli i-node liberi• -h per specificare l’unità di misura


Utenti Gruppi Password


Controllo degli accessi

■ Linux è un sistema multiutente, rende cioè possibile l’utilizzo simultaneo di una macchina da parte di più utenti.

■ L’accesso può avvenire da terminali locali connessi attraverso porte seriali, terminali locali connessi attraverso una rete locale e terminali remoti connessi attraverso il modem.

■ Ogni utente che accede deve avere un account, cioè deve essere stato registrato precedentemente con un nome (username) e una parola di accesso segreta (password).

■ La fase in cui un utente viene riconosciuto e quindi abilitato all’accesso, è detta login. La conclusione dell'attività è detta logout.

Tipologie di utenti

■ La multiutenza implica una distinzione tra i vari utenti. Prima distinzione: l'amministratore del sistema e gli altri utenti.

■ L'amministratore del sistema (superuser) è quell'utente che non ha restrizioni nell’uso e che può quindi modificare le caratteristiche del sistema.

■ L'utente comune utilizza il sistema senza poter cambiare la sua organizzazione e senza poter avviare programmi o accedere a dati che non lo riguardano.

■ Ogni utente ha una directory personale (home), abbreviata nei percorsi con il simbolo tilde (~) o mediante ~username.

Definizione degli utenti

■ Il nome dell'amministratore è sempre root, quello degli altri utenti viene deciso di volta in volta.

■ Ogni altro utente viene denominato con uno user name di al più 8 caratteri, assegnato dall'amministratore del sistema.

■ Ad esso corrisponde biunivocamente uno user-id numerico (UID), assegnato dal sistema.

■ User name e user-id sono pubblici.

Definizione dei gruppi

■ Ogni utente può far parte di uno o più gruppi, definiti dall'amministratore del sistema.

■ Ogni gruppo è identificato da un group name di al più 8 caratteri, associato biunivocamente ad un group-id numerico (GID).

■ Ad ogni istante, solo la appartenenza a un unico gruppo è attiva.

■ Il file pubblico /etc/group contiene la lista dei gruppi e delle appartenenze.

superuser

■ È un utente privilegiato (user name = root) al quale sono riservati i compiti di amministrazione del sistema.

■ Per quanto riguarda la gestione delle utenze e dei gruppi, le funzioni principali sono:

• la creazione, l’eliminazione delle utenze e la modifica delle loro caratteristiche, tramite i comandi: useradd, userdel, usermod.

• la creazione e l’eliminazione dei gruppi, mediante i comandi: addgrp, delgrp.

Comando id

■ id [opzione]

■ Il comandi Identifier visualizza user-id, user name, group-id e il group name dell'utente (cioè il gruppo attivo).

■ L’opzione -a permette di visualizzare tutti i gruppi di appartenenza.

■ Esempio

• $ id

• uid=207(tacconi) gid=100(nusmv)

Meccanismi di sicurezza

■ I meccanismi di sicurezza che Linux/Unix possiede per la protezione da accessi indesiderati sono di tre tipi:

• Accesso al sistema

L'uso del sistema è consentito soltanto agli utenti autorizzati, mediante uno schema di login/logout.

• Accesso ai files

L'accesso ai files è consentito soltanto agli utenti autorizzati, mediante uno schema di permessi di accesso.

• Accesso ai processi

L'accesso ai processi (ad esempio per terminarli) è consentito solo agli utenti autorizzati.

Accesso al sistema (login)

Conservazione e controllo password

■ Le password sono stringhe segrete registrate (in forma nascosta) nel file di testo pubblico /etc/passwd assieme ad altre informazioni.

■ Ad ogni utente abilitato all’accesso corrisponde una riga del file avente il seguente formato:

• username:password:UID:GID:nome:home:shell

■ Esempio• rossi:x:502:100:Mario Rossi:/home/rossi:/bin/bash• bianchi:x:504:100:Anna Bianchi:/home/bianchi:/bin/bash

■ Tramite questo file il sistema verifica la correttezza della password e quindi autentica (identifica) l’utente stesso.

Definizione e modifica password

■ Ogni utente può definire (e in seguito modificare) la propria password con il comando passwd.

■ Esempio

• $ passwd

passwd: Changing password for tacconi

Old password:

New password:

Re-enter new password:

Esempi

■ $ passwd

passwd: Changing password for tacconi

Old password:

New password:

Passwords must differ by at least 3 positions

New password:

Password is too short - must be at least 6 characters.

New password:

Password must contain at least two alphabetic

characters and at least one numeric or special character.

Too many failures - try later.

Uscita dal sistema (logout)

■ Il sistema prevede solitamente il comando exit o logout per terminare l’esecuzione di una shell aperta da un utente.

■ Se si tratta di una shell avviata automaticamente, il sistema provvederà ad avviare nuovamente la procedura di accesso.

■ Esempio

Red Hat Linux release 7.0

Kernel 2.2.16-22 on an i686

login: tacconi

Password:

Last login: Thu Apr 5 15:05:20 on tty1

(...sessione di lavoro...)

[tacconi@pc-41 tacconi]$ logout

login:

Comando su

■ su [username]

■ Il comando substitute user permette di diventare l'utente denominato username senza chiudere la sessione di lavoro.

■ Se il parametro username manca, si assume che il nuovo utente sia il root.

■ Il sistema chiede la password dell’utente di cui si vuole assumere l’identità, impedendo cambiamenti non autorizzati.

■ Esempio• $ su rossi• Password:

• su: incorrect password

Comando last

■ last [username]

■ Consente di avere informazioni sugli ultimi accessi di un determinato utente o, in assenza di username, di tutti gli ultimi accessi.

■ Esempio• $ last tacconi

tacconi pts/0 193.205.129.33 Thu Apr 5 09:27 still logged in tacconi tty1 Thu Apr 5 09:26 still logged in tacconi tty1 Thu Apr 5 09:25 - 09:25 (00:00) tacconi pts/0 193.205.129.33 Thu Apr 5 09:24 - 09:26 (00:02) tacconi pts/1 193.205.129.33 Wed Apr 4 14:42 - 18:56 (04:13) tacconi tty1 Wed Apr 4 14:38 - 14:41 (00:02)


File System II


Tipologie di file

■ Nei file system dei sistemi UNIX/Linux i files possono essere suddivisi in tre grandi categorie:

• File ordinari

• Directory

• File speciali

■ Ricordiamo che il sistema assegna in modo biunivoco a ciascun file un identificatore numerico, detto i-number (index-number), che gli permette di individuarlo all’interno del file system.

File Ordinari

■ I files ordinari sono caratterizzati dalle seguenti peculiarità:

• sono costituiti da sequenze di byte (byte stream)

• possono contenere informazioni qualsiasi (dati, programmi sorgente, programmi oggetto,...)

• il sistema non impone per loro nessuna struttura interna

■ Esempio:

Organizzazione dei file

■ Per consentire all'utente di rintracciare facilmente i propri files, il sistema permette di raggrupparli in directories, organizzate in una (unica) struttura gerarchica

■ Le directories sono sequenze di bytes come i files ordinari

■ Il loro contenuto è una serie di directory entries, che definiscono l'associazione fra gli i-number ed i filename mnemonici

Esempio

Percorsi

■ Ogni file viene identificato univocamente specificando il suo pathname, che individua il cammino dalla directory radice al file.

Organizzazione di un file system

Directories principali

■ /dev : contiene i files speciali associati ai dispositivi di I/O

■ /etc : contiene una serie di file di configurazione del sistema

■ /home : contiene le home directories degli utenti del sistema

■ /lib : contiene i file delle librerie condivise dalle applicazioni

■ /tmp : contiene i dati transitori delle applicazioni in esecuzione

■ /usr : contiene i componenti di supporto alle applicazioni

■ Ad ogni utente viene assegnata, ad opera dell’amministratore del sistema, una directory di sua proprietà (home directory) che ha come nome lo username dell’utente assegnatario.

■ In genere le home directories sono sotto la cartella di sistema /home

Home directory

Pathname

■ Ogni file di un utente può essere identificato univocamente specificando solamente il suo percorso (pathname) relativo alla directory corrente.

■ Esempio

File Speciali

■ Ogni dispositivo di I/O viene visto, a tutti gli effetti, come un file (file speciale)

■ Le richieste di lettura/scrittura da/a files speciali si traducono in operazioni di input/output dai/ai dispositivi associati.

■ Esempio:

• La sigla tty (teletype) identifica un terminale generico, ad esempio la console (= tastiera + video).

Vantaggi

■ Il sistema adotta un trattamento uniforme per i files e i dispositivi di I/O, in modo che i programmi non sappiano se operano su un file o su un dispositivo.

■ In questo modo si ottiene l’indipendenza delle applicazioni dall’hardware.

Documents

Esercitazione Linux