DIIGA - Università Politecnica delle Marche

A.A. 2009/10

Esercitazione di laboratorio -
Sistemi di Elaborazione dell'Informazione

Introduzione a Linux
 Francesco Spegni
[email protected]
Ricevimento su appuntamento

Gianluca Capuzzi
[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 privilegi

si 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;
 DIIGA - Università Politecnica delle Marche
A.A. 2009/10

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 *.doc
Elenca tutti i file che terminano con il suffisso .doc che si trovano
nella directory corrente.
• $ ls –help oppure $ls -h
Mostra 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 /root
ls: 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
$ pwd
Cosa 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
DIIGA - Università Politecnica delle Marche
A.A. 2009/10

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

>

stdout
stdin Processo
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 Processo 2
(ls –al) stdout stdin (less)
 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”
 Soluzioni
Esercizio 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 tabella
sigla 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 tabella
sigla 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

DIIGA - Università Politecnica delle Marche
A.A. 2007/08

Esercitazione di laboratorio

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

 Esempio
Processo Tempo di Classe di Priorità Quanto Nice CPU burst
Arrivo scheduling RT RT
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 = 5

Crediti(P2) = (20 + 4)/4 = 6
21: Ricalcolo crediti

| P1 | P2 | P3 | P4 |P3 | P2 | P1 |
0 5 9 12 18 19 25 27

Prelazione Scelta tra P1 (0 cred)

e P2 (2 cred)
 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

 DIIGA - Università Politecnica delle Marche
A.A. 2007/08

Esercitazione di laboratorio

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 runlevel.
runlevel
 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

/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

(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 di
default

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 getopt
STRINGA_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
;;
--) shift
break
;;
*) echo "Errore imprevisto"
exit 1
;;
esac
done
echo “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 Num Total Size Pages
Kmem_cache 64 64 244 4
Ip_fib_hash 4 203 16 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
 Mount 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
 Mount di file system

■ 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

 Mount di file system

■ 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
DIIGA - Università Politecnica delle Marche
A.A. 2009/10

Esercitazione di laboratorio

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)
DIIGA - Università Politecnica delle Marche
A.A. 2009/10

Esercitazione di laboratorio

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

 Home directory

■ 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
 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.