Capitolo 9. Suggerimenti per il sistema

# Capitolo 9. Suggerimenti per il sistema

In questa sezione vengono descritti suggerimenti base per configurare e gestire il sistema, per lo più dalla console.

## 9.1. Suggerimenti per la console

Esistono alcuni programmi di utilità per aiutare nelle attività in console.

Tabella 9.1. Elenco di programmi che supportano le attività in console

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`mc` | V:43, I:183 | 1590 | Vedere Sezione 1.3, «Midnight Commander (MC)»
`bsdutils` | V:439, I:999 | 335 | Il comando `script`(1) per creare trascrizioni della sessione in terminale
`screen` | V:54, I:199 | 1006 | multiplexer per terminale con emulazione di terminale VT100/ANSI
`tmux` | V:79, I:153 | 1292 | alternativa per multiplexer per terminale (usare invece "Control-B")
`fzf` | V:8, I:31 | 4651 | strumento per ricerca di testo fuzzy
`fzy` | V:0, I:0 | 59 | strumento per ricerca di testo fuzzy
`rlwrap` | V:1, I:12 | 328 | wrapper a riga di comando per la funzionalità readline
`ledit` | V:0, I:8 | 375 | wrapper a riga di comando per la funzionalità readline
`rlfe` | V:0, I:0 | 45 | wrapper a riga di comando per la funzionalità readline
`ripgrep` | V:9, I:30 | 5342 | ricerca veloce e ricorsiva di stringhe nell'albero del codice sorgente con filtraggio automatico

### 9.1.1. Registrare le attività della shell in modo pulito

Il semplice uso di `script`(1) (vedere Sezione 1.4.9, «Registrare le attività della shell») per registrare l'attività della shell produce un file con caratteri di controllo. Ciò può essere evitato usando `col`(1) nel modo seguente.

    $ script
    Script started, file is typescript

Fare tutto quello che si vuole … e poi premere `Ctrl-D` per uscire da `script`.

    $ col -bx < typescript > cleanedfile
    $ vim cleanedfile

Ci sono metodi alternativi per registrare le attività nella shell:

- Usare `tee` (utilizzabile durante il processo di avvio nell'initramfs):

      $ sh -i 2>&1 | tee typescript

- Usare `gnome-terminal` con il buffer delle righe esteso per scorrere all'indietro.

- Usare `screen` con "`^A H`" (vedere Sezione 9.1.2, «Il programma screen») per effettuare la registrazione della console.

- Usare `vim` con "`:terminal`" per entrare nella modalità terminale. Usare "`Ctrl-W N`" per uscire dalla modalità terminale nella modalità normale. Usare "`:w typescript`" per scrivere il buffer in un file.

- Usare `emacs` con "`M-x shell`", "`M-x eshell`" o "`M-x term`" per entrare nella console di registrazione. Usare "`C-x C-w`" per scrivere il buffer in un file.

### 9.1.2. Il programma screen

`screen`(1) non permette solamente il funzionamento di una finestra di terminale con processi multipli, ma permette anche ai processi in shell remote di sopravvivere a connessioni interrotte. Quello che segue è un tipico scenario di uso di `screen`(1).

1. Si fa il login in una macchina remota.

2. Si avvia `screen` in una console singola.

3. Si eseguono svariati programmi in finestre `screen` create con `^A c` ("Control-A" seguito da "c").

4. Ci si sposta tra le svariate finestre `screen` create con `^A n` ("Control-A" seguito da "n").

5. All'improvviso si ha la necessità di lasciare il terminale, ma non si vuole perdere il lavoro attivo e si vuole mantenere la connessione.

6. Si può scollegare la sessione `screen` in uno qualsiasi dei metodi seguenti.

   - Scollegare brutalmente la connessione di rete

   - Digitare `^A d` ("Control-A" seguito da "d") e fare manualmente il log out dalla connessione remota.

   - Digitare `^A DD` ("Control-A" seguito da "DD") per far si che `screen` si scolleghi e faccia il log out.

7. Ci si ricollega alla stessa macchina remota (anche da un terminale diverso).

8. Si avvia `screen` con "`screen -r`".

9. `screen` magicamente ricollega tutte le finestre `screen` precedente con tutti i programmi in esecuzione attivi.

| Suggerimento
Con `screen` si può risparmiare sui costi di connessione per connessioni a tempo, come dial-up o conteggiate a pacchetti, perché si può lasciare un processo attivo mentre si è disconnessi e poi ricollegarvisi successivamente quando è possibile connettersi di nuovo.

In una sessione `screen` tutto l'input da tastiera viene inviato alla finestra attuale, tranne per le combinazioni di tasti per i comandi. Tutte le combinazioni di tasti per i comandi di `screen` vengono inserite digitando `^A` ("Control-A") più un singolo tasto [più eventuali parametri]. Ecco alcune combinazioni di tasti importanti da ricordare.

Tabella 9.2. Elenco di associazioni di tasti per screen

azione associata | significato
--- | ---
`^A ?` | mostra una schermata di aiuto (visualizza le associazioni di tasti)
`^A c` | crea una nuova finestra e si sposta in essa
`^A n` | va alla finestra successiva
`^A p` | va alla finestra precedente
`^A 0` | va alla finestra numero 0
`^A 1` | va alla finestra numero 1
`^A w` | mostra l'elenco delle finestre
`^A a` | invia Ctrl-A alla finestra attuale come input da tastiera
`^A h` | scrive una copia della schermata della finestra attuale in un file
`^A H` | inizia/termina la registrazione dell'attività della finestra attuale in un file
`^A ^X` | blocca il terminale (protetto da password)
`^A d` | scollega la sessione screen dal terminale
`^A DD` | scollega la sessione di screen e fa il log out

Vedere `screen`(1) per i dettagli.

Vedere `tmux`(1) per le funzionalità del comando alternativo.

### 9.1.3. Navigare nelle directory

In Sezione 1.4.2, «Personalizzare bash» sono descritti 2 suggerimenti per permettere una navigazione veloce nelle directory: `$CDPATH` e `mc`.

Se si usa un programma per filtro di testo fuzzy, si può evitare di digitare il percorso esatto. Per `fzf`, includere quanto segue in `~/.bashrc`.

    FZF_KEYBINDINGS_PATH=/usr/share/doc/fzf/examples/key-bindings.bash
    if [ -f $FZF_KEYBINDINGS_PATH ]; then
      . $FZF_KEYBINDINGS_PATH
    fi

Per esempio:

- Ci si può spostare in una sottodirectory molto in profondità con uno sforzo minimo. Prima si digita "`cd **`" e si preme il tasto `Tab`. Poi verrano mostrati i percorsi candidati. Digitando stringhe parziali del percorso, ad esempio `s/d/b foo`, si possono restringere i percorsi candidati. Si seleziona il percorso che deve usare `cd` con i tasti per spostare il cursore e il tasto Invio.

- Si può selezionare un comando dalla cronologia dei comandi in modo più efficiente con sforzo minimo. Si preme `Ctrl-R` al prompt dei comandi. Poi verranno mostrati comandi candidati. Digitando stringhe di comando parziali, es. `vim d`, si restringono i candidati. Si seleziona quello da utilizzare con i tasti per il cursore e il tasto Invio.

### 9.1.4. Wrapper per readline

Alcuni comandi come `/usr/bin/dash` che mancano della funzionalità di modifica della cronologia della riga di comando possono aggiungere tale funzionalità in modo trasparente venendo eseguito sotto `rlwrap` o un suo equivalente.

     $ rlwrap dash -i

Questo fornisce una comoda piattaforma per testare dettagli per `dash` con un ambiente amichevole in stile `bash`.

### 9.1.5. Strumenti per la fusione di codice sorgente

Il comando `rg`(1) nel pacchetto `ripgrep` offre un'alternativa più veloce al comando `grep`(1) per scansionare l'albero del codice sorgente nelle situazioni tipiche. Sfrutta le moderne CPU multi-core e applica automaticamente filtri ragionevoli per saltare alcuni file.

## 9.2. Personalizzare vim

Dopo aver imparato le basi di `vim`(1) attraverso Sezione 1.4.8, «Usare vim», leggere"Seven habits of effective text editing (2000)" di Bram Moolenaar per capire come `vim` dovrebbe essere usato.

### 9.2.1. Personalizzare vim con le funzionalità interne

Il comportamento di `vim` può essere modificato in modo significativo abilitando le sue funzionalità interne attraverso i comandi della modalità `Ex` come "`set ...`" per impostare le opzioni di vim.

Questo comandi per la modalità `Ex` possono essere inclusi nel file vimrc dell'utente, tradizionalmente "`~/.vimrc`" o quello adatto a git "`~/.vim/vimrc`". Ecco un esempio molto semplice [2]:

    """ Generic baseline Vim and Neovim configuration (~/.vimrc)
    """   - For NeoVim, use "nvim -u ~/.vimrc [filename]"
    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    let mapleader = ' '             " :h mapleader
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    set nocompatible                " :h 'cp -- sensible (n)vim mode
    syntax on                       " :h :syn-on
    filetype plugin indent on       " :h :filetype-overview
    set encoding=utf-8              " :h 'enc (default: latin1) -- sensible encoding
    """ current vim option value can be verified by :set encoding?
    set backspace=indent,eol,start  " :h 'bs (default: nobs) -- sensible BS
    set statusline=%<%f%m%r%h%w%=%y[U+%04B]%2l/%2L=%P,%2c%V
    set listchars=eol:¶,tab:⇄\ ,extends:↦,precedes:↤,nbsp:␣
    set viminfo=!,'100,<5000,s100,h " :h 'vi -- bigger copy buffer etc.
    """ Pick "colorscheme" from blue darkblue default delek desert elflord evening
    """ habamax industry koehler lunaperche morning murphy pablo peachpuff quiet ron
    """ shine slate torte zellner
    colorscheme industry
    """ don't pick "colorscheme" as "default" which may kill SpellUnderline settings
    set scrolloff=5                 " :h 'scr -- show 5 lines around cursor
    set laststatus=2                " :h 'ls (default 1)  k
    """ boolean options can be unset by prefixing "no"
    set ignorecase                  " :h 'ic
    set smartcase                   " :h 'scs
    set autoindent                  " :h 'ai
    set smartindent                 " :h 'si
    set nowrap                      " :h 'wrap
    "set list                        " :h 'list (default nolist)
    set noerrorbells                " :h 'eb
    set novisualbell                " :h 'vb
    set t_vb=                       " :h 't_vb -- termcap visual bell
    set spell                       " :h 'spell
    set spelllang=en_us,cjk         " :h 'spl -- english spell, ignore CJK
    set clipboard=unnamedplus       " :h 'cb -- cut/copy/paste with other app
    set hidden                      " :h 'hid
    set autowrite                   " :h 'aw
    set timeoutlen=300              " :h 'tm

La mappa dei tasti di `vim` può essere modificata nel file vimrc dell'utente. Es.:

| Attenzione
Non cercare di cambiare le associazioni dei tasti predefinite senza ottime ragioni.

    """ Popular mappings (imitating LazyVim etc.)
    """ Window moves without using CTRL-W which is dangerous in INSERT mode
    nnoremap <C-H> <C-W>h
    nnoremap <C-J> <C-W>j
    nnoremap <C-K> <C-W>k
    silent! nnoremap <C-L> <C-W>l
    """ Window resize
    nnoremap <C-LEFT> <CMD>vertical resize -2<CR>
    nnoremap <C-DOWN> <CMD>resize -2<CR>
    nnoremap <C-UP> <CMD>resize +2<CR>
    nnoremap <C-RIGHT> <CMD>vertical resize +2<CR>
    """ Clear hlsearch with <ESC> (<C-L> is mapped as above)
    nnoremap <ESC> <CMD>noh<CR><ESC>
    inoremap <ESC> <CMD>noh<CR><ESC>
    """ center after jump next
    nnoremap n nzz
    nnoremap N Nzz
    """ fast "jk" to get out of INSERT mode (<ESC>)
    inoremap  jk <CMD>noh<CR><ESC>
    """ fast "<ESC><ESC>" to get out of TERM mode (CTRL-\ CTRL-N)
    tnoremap <ESC><ESC> <C-\><C-N>
    """ fast "jk" to get out of TERM mode (CTRL-\ CTRL-N)
    tnoremap jk <C-\><C-N>
    """ previous/next trouble/quickfix item
    nnoremap [q <CMD>cprevious<CR>
    nnoremap ]q <CMD>cnext<CR>
    """ buffers
    nnoremap <S-H> <CMD>bprevious<CR>
    nnoremap <S-L> <CMD>bnext<CR>
    nnoremap [b <CMD>bprevious<CR>
    nnoremap ]b <CMD>bnext<CR>
    """ Add undo break-points
    inoremap  , ,<C-G>u
    inoremap  . .<C-G>u
    inoremap  ; ;<C-G>u
    """ save file
    inoremap <C-S> <CMD>w<CR><ESC>
    xnoremap <C-S> <CMD>w<CR><ESC>
    nnoremap <C-S> <CMD>w<CR><ESC>
    snoremap <C-S> <CMD>w<CR><ESC>
    """ better indenting
    vnoremap < <gv
    vnoremap > >gv
    """ terminal (Somehow under Linux, <C-/> becomes <C-_> in Vim)
    nnoremap <C-_> <CMD>terminal<CR>
    "nnoremap <C-/> <CMD>terminal<CR>
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    if ! has('nvim')
    """ Toggle paste mode with <SPACE>p for Vim (no need for Nvim)
    set pastetoggle=<leader>p
    """ nvim default mappings for Vim.  See :h default-mappings in nvim
    """ copy to EOL (no delete) like D for d
    noremap Y y$
    """ sets a new undo point before deleting
    inoremap <C-U> <C-G>u<C-U>
    inoremap <C-W> <C-G>u<C-W>
    """ <C-L> is re-purposed as above
    """ execute the previous macro recorded with Q
    nnoremap Q @@
    """ repeat last substitute and *KEEP* flags
    nnoremap & :&&<CR>
    """ search visual selected string for visual mode
    xnoremap * y/\V<C-R>"<CR>
    xnoremap # y?\V<C-R>"<CR>
    endif

Per far sì che le associazioni di tasti precedenti funzionino correttamente, il programma di terminale deve essere configurato per generare "ASCII DEL" per il tasto `Backspace` e "sequenza Escape" per il tasto `Canc`.

Altre configurazioni varie possono essere modificate nel file vimrc dell'utente. Es.:

    """ Use faster 'rg' (ripgrep package) for :grep
    if executable("rg")
      set grepprg=rg\ --vimgrep\ --smart-case
      set grepformat=%f:%l:%c:%m
    endif
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ Retain last cursor position :h '"
    augroup RetainLastCursorPosition
      autocmd!
      autocmd BufReadPost *
        \ if line("'\"") > 0 && line ("'\"") <= line("$") |
        \   exe "normal! g'\"" |
        \ endif
    augroup END
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ Force to use underline for spell check results
    augroup SpellUnderline
      autocmd!
      autocmd ColorScheme * highlight SpellBad term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellCap term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellLocal term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellRare term=Underline gui=Undercurl
    augroup END
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ highlight tailing spaces except when typing as red (set after colorscheme)
    highlight TailingWhitespaces ctermbg=red guibg=red
    """ \s\+     1 or more whitespace character: <Space> and <Tab>
    """ \%#\@<!  Matches with zero width if the cursor position does NOT match.
    match TailingWhitespaces /\s\+\%#\@<!$/

### 9.2.2. Personalizzare vim con pacchetti esterni

Pacchetti per plugin esterni interessanti possono essere trovati in:

- Vim - the ubiquitous text editor -- Il sito originale a monte ufficiale di Vim e degli script vim

- VimAwsome -- Elenco di plugin per Vim

- vim-scripts -- pacchetto Debian: una raccolta di script per vim

I pacchetti di plugin nel pacchetto vim-scripts possono essere abilitati usando il file vimrc dell'utente. Es:

    packadd! secure-modelines
    packadd! winmanager
    " IDE-like UI for files and buffers with <space>w
    nnoremap <leader>w         :WMToggle<CR>

Il nuovo sistema di pacchetti nativo di Vim funziona bene con "`git`" e "`git submodule`". Una configurazione d'esempio di questo tipo può essere trovata inmy git repository: dot-vim. Essenzialmente fa:

- Usando "`git`" e "`git submodule`", i pacchetti esterni più recenti, come "`nome`", sono messi in `~/.vim/pack/*/opt/nome` e simili.

- Aggiungendo la riga `:packadd! nome` al file vimrc dell'utente, questi pacchetti vengono messi nel `runtimepath`.

- Vim carica questi pacchetti in `runtimepath` durante la sua inizializzazione.

- Al termine della sua inizializzazione, i tag per i documenti installati sono aggiornati con "`helptags ALL`".

Per altro ancora, avviare `vim` con "`vim --startuptime vimstart.log`" per controllare l'effettiva sequenza di esecuzione e il tempo speso in ogni passo.

Può essere fonte di confusione vedere troppi modi[3] per gestire e caricare questi pacchetti esterni in `vim`. Controllare le informazioni originali è la soluzione migliore.

Tabella 9.3. Informazioni sull'inizializzazione di `vim`

Combinazione di tasti | informazioni
--- | ---
`:help pacchetto` | spiegazione sul meccanismo dei pacchetti di vim
`:help runtimepath` | spiegazione del meccanismo `runtimepath`
`:version` | stati interni inclusi i candidati per il file vimrc
`:echo $VIM` | la variabile d'ambiente "`$VIM`" usata per localizzare il file vimrc
`:set runtimepath?` | elenco di directory in cui verranno cercati tutti i file di supporto a runtime
`:echo $VIMRUNTIME` | la variabile d'ambiente "`$VIMRUNTIME`" usata per localizzare vari file di supporto a runtime forniti dal sistema

## 9.3. Registrazione e presentazione di dati

### 9.3.1. Demoni di registro

Molti programmi registrano le proprie attività in formato di file testuale nella directory "`/var/log/`".

`logrotate`(8) viene usato per semplificare l'amministrazione dei file di log in un sistema che genera molti file di log.

Molti nuovi programmi registrano le loro attività nel formato di file binario, usando il servizio Journal `systemd-journald`(8), nella directory "`/var/log/journal`".

Si può fare il registro di dati nel Journal `systemd-journald`(8) da uno script di shell usando il comando `systemd-cat`(1).

Vedere Sezione 3.5, «I messaggi di sistema» e Sezione 3.4, «I messaggi del kernel».

### 9.3.2. Analizzatori di registro

Quelli che seguono sono alcuni analizzatori di registro degni di nota ("`~Gsecurity::log-analyzer`" in `aptitude`(8)).

Tabella 9.4. Elenco di analizzatori del registro di sistema

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`logwatch` | V:9, I:10 | 2435 | analizzatore di registro scritto in Perl con un bell'output
`fail2ban` | V:95, I:106 | 2191 | strumento per interdire IP che causano errori di autenticazione multipli
`analog` | V:3, I:88 | 3739 | analizzatore del registro di server web
`awstats` | V:5, I:8 | 6935 | analizzatore potente e ricco di funzionalità per registro di server web
`sarg` | V:0, I:0 | 863 | generatore di rapporti sull'analisi di squid
`pflogsumm` | V:1, I:3 | 170 | strumento per riassunti delle voci di registro di Postfix
`fwlogwatch` | V:0, I:0 | 487 | analizzatore del registro del firewall
`squidview` | V:0, I:0 | 189 | monitora e analizza i file access.log di squid
`swatch` | V:0, I:0 | 99 | visualizzatore di file di registro con corrispondenze con espressioni regolari, evidenziazione ed eventi
`crm114` | V:0, I:0 | 1371 | Controllable Regex Mutilator e filtro per spam (CRM114)
`icmpinfo` | V:0, I:0 | 42 | interpreta i messaggi ICMP

| Nota
CRM114 fornisce un'infrastruttura basata su un linguaggio per scrivere filtri fuzzy con la libreria per espressioni regolari TRE. Il suo utilizzo più comune è come filtro per la posta spazzatura, ma può anche essere usato come analizzatore di registro.

### 9.3.3. Visualizzazione personalizzata di dati di testo

Sebbene gli strumenti di paginazione, come `more`(1) e `less`(1) (vedere Sezione 1.4.5, «Il paginatore») e gli strumenti personalizzati per l'evidenziazione e la formattazione (vedere Sezione 11.1.8, «Evidenziare e formattare dati in puro testo») possano mostrare il testo in un modo piacevole, gli editor generici (vedere Sezione 1.4.6, «L'editor di testo») sono più versatili e personalizzabili.

| Suggerimento
Per `vim`(1) e la sua modalità per paginatore, ossia `view`(1), "`:set hls`" abilita la ricerca con evidenziazione.

### 9.3.4. Visualizzazione personalizzata di date e orari

Il formato predefinito per la visualizzazione delle date e degli orari per il comando "`ls -l`" dipende dalla localizzazione (vedere Sezione 1.2.6, «Orari» per il valore). Si fa dapprima riferimento alla variabile "`$LANG`" che può essere scavalcata dalle variabili d'ambiente "`$LC_TIME`" o "`$LC_ALL`".

Il formato effettivo di visualizzazione predefinito per ciascuna localizzazione dipende dalla versione della libreria C standard (il pacchetto `libc6`) usata. Differenti rilasci di Debian hanno cioè valori predefiniti diversi. Per i formati ISO, vedere ISO 8601.

Se si desidera veramente personalizzare questo formato di visualizzazione delle date e degli orari, oltre a ciò che è fatto con la localizzazione, si deve impostare il valore dello stile degli orari con l'opzione "`--time-style`" o con il valore di "`$TIME_STYLE`" (vedere `ls`(1), `date`(1), "`info coreutils 'ls invocation'`").

Tabella 9.5. Esempi di visualizzazione di date e orari per il comando "`ls -l`" con il valore dello stile per gli orari

valore dello stile per gli orari | localizzazione | visualizzazione di data e ora
--- | --- | ---
`iso` | qualsiasi | `01-19 00:15`
`long-iso` | qualsiasi | `2009-01-19 00:15`
`full-iso` | qualsiasi | `2009-01-19 00:15:16.000000000 +0900`
`locale` | `C` | `Jan 19 00:15`
`locale` | `en_US.UTF-8` | `Jan 19 00:15`
`locale` | `es_ES.UTF-8` | `ene 19 00:15`
`+%d.%m.%y %H:%M` | qualsiasi | `19.01.09 00:15`
`+%d.%b.%y %H:%M` | `C` o `en_US.UTF-8` | `19.Jan.09 00:15`
`+%d.%b.%y %H:%M` | `es_ES.UTF-8` | `19.ene.09 00:15`

| Suggerimento

Si può evitare di digitare lunghe opzioni nella riga di comando usando alias per i comandi (vedere Sezione 1.5.9, «Alias di comandi»):

    alias ls='ls --time-style=+%d.%m.%y %H:%M'

### 9.3.5. Output colorato per la shell

L'output inviato a schermo dalla shell nella maggior parte dei terminali moderni può essere colorato usando codici di escape ANSI (vedere "`/usr/share/doc/xterm/ctlseqs.txt.gz`").

Per esempio, provare a fare quanto segue.

    $ RED=$(printf "\x1b[31m")
    $ NORMAL=$(printf "\x1b[0m")
    $ REVERSE=$(printf "\x1b[7m")
    $ echo "${RED}RED-TEXT${NORMAL} ${REVERSE}REVERSE-TEXT${NORMAL}"

### 9.3.6. Comandi colorati

I comandi colorati sono comodi per ispezionare il loro output in modo interattivo. Nel mio file "`~/.bashrc`" io includo quanto segue.

    if [ "$TERM" != "dumb" ]; then
        eval "`dircolors -b`"
        alias ls='ls --color=always'
        alias ll='ls --color=always -l'
        alias la='ls --color=always -A'
        alias less='less -R'
        alias ls='ls --color=always'
        alias grep='grep --color=always'
        alias egrep='egrep --color=always'
        alias fgrep='fgrep --color=always'
        alias zgrep='zgrep --color=always'
    else
        alias ll='ls -l'
        alias la='ls -A'
    fi

Questo uso degli alias limita gli effetti colorati all'uso interattivo dei comandi. Ha il vantaggio, rispetto all'esportazione della variabile d'ambiente "`export GREP_OPTIONS='--color=auto'`", che i colori possono essere visti in programmi di paginazione come `less`(1). Se si desidera eliminare i colori quando si invia l'output con una pipe ad altri comandi, usare nell'esempio precedente per "`~/.bashrc`" "`--color=auto`".

| Suggerimento
Questi alias di colorazione possono essere disattivati nell'ambiente interattivo invocando la shell con il comando "`TERM=dumb bash`".

### 9.3.7. Registrare le attività dell'editor per ripetizioni complesse

È possibile registrare le attività dell'editor per ripetere azioni complesse.

Per vim fare nel modo seguente.

- "`qa`": avviare la registrazione dei caratteri digitati in un registro chiamato "`a`".

- … attività nell'editor

- "`q`": terminare la registrazione dei caratteri digitati.

- "`@a`": eseguire il contenuto del registro "`a`".

Per Emacs fare nel modo seguente.

- "`C-x (`": iniziare la definizione di una macro da tastiera.

- … attività nell'editor

- "`C-x )`": terminare la definizione di una macro da tastiera.

- "`C-x e`": eseguire la definizione di una macro da tastiera.

### 9.3.8. Registrare l'immagine grafica di un'applicazione X

Ci sono alcuni modi per registrare l'immagine grafica di un'applicazione X, incluso il display di un `xterm`.

Tabella 9.6. Elenco di strumenti di manipolazione di immagini grafiche

pacchetto | popcon | dimensione | Schermata | comando
--- | --- | --- | --- | ---
`gnome-screenshot` | V:13, I:111 | 1115 | Wayland | applicazione per istantanee dello schermo per GNOME
`flameshot` | V:7, I:17 | 3532 | Wayland | applicazione per istantanee dello schermo sotto anabolizzanti
`gimp` | V:35, I:229 | 31748 | Wayland + X | istantanee nel menu GUI
`x11-apps` | V:33, I:464 | 2461 | per X | `xwd`(1)
`imagemagick` | I:290 | 77 | per X | `import`(1)
`scrot` | V:4, I:53 | 141 | per X | `scrot`(1)

### 9.3.9. Registrare i cambiamenti a file di configurazione

Esistono strumenti specializzati per registrare i cambiamenti nei file di configurazione con l'aiuto del sistema DVCS e per creare istantanee del sistema in Btrfs.

Tabella 9.7. Elenco di pacchetti che possono registrare la cronologia della configurazione

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`etckeeper` | V:24, I:27 | 157 | archivia i file di configurazione ed i loro metadati con Git (predefinito), Mercurial o GNU Bazaar (nuovo)
`timeshift` | V:7, I:13 | 4481 | utilità di ripristino del sistema che usa rsync o istantanee BTRFS
`snapper` | V:6, I:8 | 2410 | strumento di gestione di istantanee del file system Linux

Si può anche pensare di usare un approccio con script locale Sezione 10.2.3, «Suggerimenti per i backup».

## 9.4. Monitorare, controllare ed avviare l'attività dei programmi

Le attività dei programmi possono essere monitorare e controllate usando strumenti specializzati.

Tabella 9.8. Elenco di strumenti per monitorare e controllare l'attività dei programmi.

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | `nice`(1): esegue un programma con priorità di schedulazione modificata
`bsdutils` | V:439, I:999 | 335 | `renice`(1): modifica la priorità di schedulazione di un processo in esecuzione
`procps` | V:818, I:998 | 2404 | utilità per il file system "`/proc`": `ps`(1), `top`(1), `kill`(1), `watch`(1), …
`psmisc` | V:410, I:742 | 950 | utilità per il file system "`/proc`": `killall`(1), `fuser`(1), `peekfd`(1), `pstree`(1)
`time` | V:5, I:85 | 129 | `time`(1): esegue un programma per riportare l'uso delle risorse di sistema in funzione del tempo
`sysstat` | V:123, I:162 | 1904 | `sar`(1), `iostat`(1), `mpstat`(1), …: strumenti per le prestazioni di sistema per Linux
`isag` | V:0, I:3 | 109 | Interactive System Activity Grapher (tracciamento interattivo dell'attivita) per sysstat
`lsof` | V:443, I:949 | 492 | `lsof`(8): elenca, usando l'opzione "`-p`", i file aperti da un processo in esecuzione
`strace` | V:10, I:103 | 3253 | `strace`(1): traccia le chiamate e i segnali di sistema
`ltrace` | V:0, I:11 | 420 | `ltrace`(1): traccia le chiamate di libreria
`xtrace` | V:0, I:0 | 353 | `xtrace`(1): traccia la comunicazione tra client e server X11
`powertop` | V:33, I:232 | 696 | `powertop`(1): informazioni sull'uso dell'alimentazione da parte del sistema
`cron` | V:901, I:996 | 250 | esegue processi dal demone `cron`(8) sullo sfondo in base ad una pianificazione
`anacron` | V:418, I:493 | 112 | pianificatore di comandi in stile cron, per i sistemi che non sono in esecuzione 24 ore al giorno
`at` | V:74, I:102 | 158 | `at`(1) o `batch`(1): esegue un compito ad un orario specificato o quando il carico di sistema scende sotto un certo livello

| Suggerimento
Il pacchetto `procps` fornisce strumenti estremamente di base per monitorare, controllare ed avviare le attività dei programmi. È consigliabile imparare ad usarli tutti.

### 9.4.1. Cronometrare un processo

Mostrare il tempo usato dal processo invocato da un comando.

    # time some_command >/dev/null
    real    0m0.035s       # time on wall clock (elapsed real time)
    user    0m0.000s       # time in user mode
    sys     0m0.020s       # time in kernel mode

### 9.4.2. Priorità di schedulazione

Per controllare la priorità di schedulazione di un processo è usato il valore di nice.

Tabella 9.9. Elenco di valori di nice per la priorità di schedulazione

valore di nice | priorità di schedulazione
--- | ---
19 | processo dalla priorità più bassa possibile (nice - gentile)
0 | processo a priorità molto alta per l'utente
-20 | processo a priorità molto alta per root (not-nice - non gentile)

    # nice  -19 top                                      # very nice
    # nice --20 wodim -v -eject speed=2 dev=0,0 disk.img # very fast

A volte un valore molto alto di nice fa più male che bene al sistema; usare quindi questo comando con molta cautela.

### 9.4.3. Il comando ps

Il comando `ps`(1) in un sistema Debian supporta sia le funzionalità BSD sia quelle SystemV ed aiuta ad identificare l'attività dei processi in modo statico.

Tabella 9.10. Elenco degli stili per il comando ps

stile | comando tipico | funzione
--- | --- | ---
BSD | `ps aux` | mostra %CPU %MEM
System V | `ps -efH` | mostra PPID

È possibile uccidere i processi figli zombie (defunti) tramite l'ID di processo del genitore identificato dal campo "`PPID`".

Il comando `pstree`(1) mostra un albero dei processi.

### 9.4.4. Il comando top

`top`(1) in sistemi Debian ha molte funzionalità e aiuta ad identificare in modo dinamico i processi che si stanno comportando in modo strano.

È un programma interattivo a tutto schermo. Si possono ottenere le informazioni di aiuto sul suo uso premendo il tasto «h» e uscire premendo il tasto «q».

### 9.4.5. Elencare i file aperti da un processo

È possibile elencare tutti i file aperti da un processo attraverso il suo PID (Identificativo di processo), ad esempio 1, con il comando seguente.

    $ sudo lsof -p 1

Di solito il processo con PID=1 è il programma `init`.

### 9.4.6. Tenere traccia delle attività di un programma

Si può tenere traccia dell'attività di un programma con `strace`(1), `ltrace`(1) o `xtrace`(1) rispettivamente per quello che riguarda chiamate e segnali di sistema, chiamate di libreria o comunicazioni tra client e server X11.

Si può tenere traccia delle chiamate di sistema del comando `ls` nel modo seguente.

    $ sudo strace ls

| Suggerimento
Usare lo script strace-graph che si trova in /usr/share/doc/strace/examples/ per creare una bella vista ad albero.

### 9.4.7. Identificazione di processi in base a file o socket

Usando `fuser`(1) è anche possibile identificare i processi in base ai file usando, ad esempio per "`/var/log/mail.log`" con il comando seguente.

    $ sudo fuser -v /var/log/mail.log
                         USER        PID ACCESS COMMAND
    /var/log/mail.log:   root       2946 F.... rsyslogd

Come si vede il file "`/var/log/mail.log`" è aperto in scrittura dal comando `rsyslogd`(8).

Usando `fuser`(1) si può anche identificare i processi in base ai socket, ad esempio per "`smtp/tcp`" con il comando seguente.

    $ sudo fuser -v smtp/tcp
                         USER        PID ACCESS COMMAND
    smtp/tcp:            Debian-exim   3379 F.... exim4

Ora si può vedere che sul sistema è in esecuzione `exim4`(8) per gestire le connessioni TCP alla porta SMTP (25).

### 9.4.8. Ripetere un comando ad intervalli costanti

`watch`(1) esegue un programma in modo ripetitivo ad intervalli regolari mostrando il suo output sullo schermo.

    $ watch w

Questo comando mostra chi è attualmente connesso al sistema in modo aggiornato ogni 2 secondi.

### 9.4.9. Ripetere un comando su diversi file

Ci sono svariati modi di ripetere uno stesso comando su diversi file che rispondono ad una qualche condizione, ad esempio che corrispondono al modello glob "`*.ext`".

- Metodo del ciclo for nella shell (vedere Sezione 12.1.4, «Cicli di shell»):

    for x in *.ext; do if [ -f "$x"]; then command "$x" ; fi; done

- Combinazione di `find`(1) e `xargs`(1):

    find . -type f -maxdepth 1 -name '*.ext' -print0 | xargs -0 -n 1 command

- `find`(1) con l'opzione "`-exec`" con un comando:

    find . -type f -maxdepth 1 -name '*.ext' -exec command '{}' \;

- `find`(1) con l'opzione "`-exec`" con un breve script di shell:

    find . -type f -maxdepth 1 -name '*.ext' -exec sh -c "command '{}' && echo 'successful'" \;

Gli esempi precedenti sono stati scritti per assicurare la gestione appropriata di nomi di file particolari come quelli contenenti spazi. Per usi più avanzati di `find`(1), vedere Sezione 10.1.5, «Esempi di invocazione per la selezione di file».

### 9.4.10. Avviare un programma dalla GUI

Perl l'interfaccia a riga di comando (CLI), viene eseguito il primo programma con un nome corrispondente trovato nelle directory specificate nella variabile d'ambiente `$PATH`. Vedere Sezione 1.5.3, «La variabile "`$PATH`"».

Per l'interfaccia utente grafica (GUI) conforme agli standard di freedesktop.org i file `*.desktop` nella directory `/usr/share/applications/` forniscono gli attributi necessari per la visualizzazione di ogni programma nel menu della GUI. Ogni pacchetto che è conforme al sistema di menu xdg di Freedesktop.org installa i propri dati di menu forniti da "*.desktop" in "/usr/share/applications/". Gli ambienti desktop moderni che sono conformi allo standard Freedesktop.org usano questi dati per generare i loro menu usando il pacchetto xdg-utils. Vedere "/usr/share/doc/xdg-utils/README".

Per esempio, il file `chromium.desktop` definisce gli attributi per il «Browser Web Chromium» come «Name» per il nome di programma, «Exec» per il percorso e gli argomenti di esecuzione del programma, «Icon» per l'icona usata, ecc. (vedere laSpecifica per le voci per desktop), nel modo seguente:

    [Desktop Entry]
    Version=1.0
    Name=Chromium Web Browser
    GenericName=Web Browser
    Comment=Access the Internet
    Comment[fr]=Explorer le Web
    Exec=/usr/bin/chromium %U
    Terminal=false
    X-MultipleArgs=false
    Type=Application
    Icon=chromium
    Categories=Network;WebBrowser;
    MimeType=text/html;text/xml;application/xhtml_xml;x-scheme-handler/http;x-scheme-handler/https;
    StartupWMClass=Chromium
    StartupNotify=true

Questa è una descrizione molto semplificata. I file `*.desktop` vengono analizzati nel modo seguente.

The desktop environment sets `$XDG_DATA_HOME` and `$XDG_DATA_DIR` environment variables. For example, under the GNOME:

- `$XDG_DATA_HOME` non è impostata. (Viene usato il valore predefinito: `$HOME/.local/share`.)

- `$XDG_DATA_DIRS` è impostata a `/usr/share/gnome:/usr/local/share/:/usr/share/`.

Perciò le directory base (vedere la XDG Base Directory Specification) e le directory `applications` sono le seguenti.

- `$HOME/.local/share/` → `$HOME/.local/share/applications/`

- `/usr/share/gnome/` → `/usr/share/gnome/applications/`

- `/usr/local/share/` → `/usr/local/share/applications/`

- `/usr/share/` → `/usr/share/applications/`

I file `*.desktop` vengono analizzati all'interno di queste directory `applications` in tale ordine.

| Suggerimento
Una voce del menu GUI personalizzata dell'utente può essere creata aggiungendo un file `*.desktop` nella directory `$HOME/.local/share/applications/`.

| Suggerimento
La riga "`Exec=...`" non viene analizzata dalla shell. Usare il comando `env`(1) se devono essere impostate variabili d'ambiente.

| Suggerimento
In modo analogo, se viene creato un file `*.desktop` nella directory `autostart` all'interno di queste directory di base, il programma specificato nel file `*.desktop` viene eseguito automaticamente all'avvio dell'ambiente desktop. Vedere la specifica Desktop Application Autostart Specification.

| Suggerimento
In modo simile, se viene creato un file `*.desktop` nella directory `$HOME/Desktop` e l'ambiente desktop è configurato per supportare la funzionalità di avviatore delle icone, il programma specificato in tale file viene eseguito quando si fa clic sull'icona. Notare che il nome effettivo della directory `$HOME/Desktop` dipende dalla localizzazione. Vedere `xdg-user-dirs-update`(1).

### 9.4.11. Personalizzare i programmi da avviare

Alcuni programmi avviano automaticamente altri programmi. Quelli che seguono sono alcuni punti fondamentali per la personalizzazione di questo processo.

- Menu di configurazione delle applicazioni:

  - GNOME desktop: "Settings" → "Apps" → "Default Apps"

  - KDE desktop: "Application Launcher" → "System Settings" → "Default Applications"

  - Browser Iceweasel: "Modifica" → "Preferenze" → "Applicazioni"

  - `mc`(1): "`/etc/mc/mc.ext`"

- Variabili d'ambiente quali "`$BROWSER`", "`$EDITOR`", "`$VISUAL`" e "`$PAGER`" (vedere `environ`(7))

- Il sistema `update-alternatives`(1) per i programmi come "`editor`", "`view`", "`x-www-browser`", "`gnome-www-browser`" e "`www-browser`" (vedere Sezione 1.4.7, «Impostare un editor di testi predefinito»)

- Il contenuto dei file "`~/.mailcap`" e "`/etc/mailcap`" che associano i tipi MIME con programmi (vedere `mailcap`(5))

- Il contenuto dei file "`~/.mime.types`" e "`/etc/mime.types`" che associano le estensioni dei nomi di file con tipi MIME (vedere `run-mailcap`(1))

| Suggerimento
`update-mime`(8) aggiorna il file "`/etc/mailcap`" usando il file "`/etc/mailcap.order`" (vedere `mailcap.order`(5)).

| Suggerimento
Il pacchetto `debianutils` fornisce `sensible-browser`(1), `sensible-editor`(1) e `sensible-pager`(1) che prendono decisioni sensate riguardo, rispettivamente, a quale browser web, editor e paginatore invocare. La lettura di questi script di shell è raccomandata.

| Suggerimento

Per eseguire un'applicazione per console, come `mutt`, come applicazione preferita in X si dovrebbe creare un'applicazione X nel modo seguente ed impostare "`/usr/local/bin/mutt-term`" come applicazione preferite da avviare come descritto in precedenza.

    # cat /usr/local/bin/mutt-term <<EOF
    #!/bin/sh
    gnome-terminal -e "mutt \$@"
    EOF
    # chmod 755 /usr/local/bin/mutt-term

### 9.4.12. Uccidere un processo

Per uccidere un processo (o inviare ad esso un segnale) in base al suo ID (identificativo) usare `kill`(1).

Per fare la stessa cosa ma in base al nome del comando del processo o ad altri attributi, usare `killall`(1) o `pkill`(1).

Tabella 9.11. Elenco dei segnali usati comunemente con il comando kill

valore del segnale | nome del segnale | azione | nota
--- | --- | --- | ---
0 | --- | nessun segnale viene inviato (vedere `kill`(2)) | controlla se il processo è in esecuzione
1 | SIGHUP | termina il processo | terminale disconnesso (segnale hang up)
2 | SIGINT | termina il processo | interrupt dalla tastiera (`CTRL-C`)
3 | SIGQUIT | termina il processo e fa un core dump | esce dalla tastiera (`CTRL-\`)
9 | SIGKILL | termina il processo | segnale di terminazione non bloccabile
15 | SIGTERM | termina il processo | segnale di terminazione bloccabile

### 9.4.13. Pianificare compiti da eseguire una volta sola

Per pianificare un compito da eseguire una volta soltanto eseguire il comando `at`(1) nel modo seguente.

    $ echo 'command -args'| at 3:40 monday

### 9.4.14. Pianificare compiti in modo regolare

Per pianificare compiti in modo regolare usare `cron`(8). Vedere `crontab`(1) e `crontab`(5).

Si può pianificare l'esecuzione di processi come utente normale, ad esempio l'utente `pippo`, creando un file `crontab`(5) come "`/var/spool/cron/crontabs/pippo`" con il comando "`crontab -e`".

Quello seguente è un esempio di file `crontab`(5).

    # use /usr/bin/sh to run commands, no matter what /etc/passwd says
    SHELL=/bin/sh
    # mail any output to paul, no matter whose crontab this is
    MAILTO=paul
    # Min Hour DayOfMonth Month DayOfWeek command (Day... are OR'ed)
    # run at 00:05, every day
    5  0  *  * *   $HOME/bin/daily.job >> $HOME/tmp/out 2>&1
    # run at 14:15 on the first of every month -- output mailed to paul
    15 14 1  * *   $HOME/bin/monthly
    # run at 22:00 on weekdays(1-5), annoy Joe. % for newline, last % for cc:
    0 22 *   * 1-5 mail -s "It's 10pm" joe%Joe,%%Where are your kids?%.%%
    23 */2 1 2 *   echo "run 23 minutes after 0am, 2am, 4am ..., on Feb 1"
    5  4 *   * sun echo "run at 04:05 every Sunday"
    # run at 03:40 on the first Monday of each month
    40 3 1-7 * *   [ "$(date +%a)" == "Mon" ] && command -args

| Suggerimento
Per i sistemi non in esecuzione in maniera continuata, installare il pacchetto `anacron` per pianificare l'esecuzione di comandi periodici, in maniera il più possibile vicina agli intervalli specificati, in base a quanto permesso dal tempo di attività della macchina. Vedere `anacron`(8) e `anacrontab`(5).

| Suggerimento
Gli script con compiti pianificati di amministrazione del sistema possono essere eseguiti periodicamente dall'account di root, ponendoli in "`/etc/cron.hourly/`", "`/etc/cron.daily/`", "`/etc/cron.weekly/`" o "`/etc/cron.monthly/`". L'orario di esecuzione di questi script può essere personalizzato con "`/etc/crontab`" e "`/etc/anacrontab`".

Systemd ha una funzionalità a basso livello per pianificare l'esecuzione di programmi senza il demone `cron`. Per esempio, `/lib/systemd/system/apt-daily.timer` e `/lib/systemd/system/apt-daily.service` impostano le attività giornaliere di scaricamento di apt. Vedere `systemd.timer`(5) .

### 9.4.15. Pianificare compiti da eseguire in caso di un evento

Systemd può pianificare programmi non solo in base ad eventi temporizzati, ma anche in caso di eventi di mount. Vedere Sezione 10.2.3.3, «Backup attivato da un evento timer» e Sezione 10.2.3.2, «Backup attivato da eventi di mount» per alcuni esempi.

### 9.4.16. Tasto Alt-SysRq

Premendo Alt-RSist (Stamp) seguito da un tasto fa la magia di ripristinare il controllo del sistema.

Tabella 9.12. Elenco di tasti per il comando SAK degni di nota

tasto premuto dopo Alt-R_Sist | descrizione dell'azione
--- | ---
`k` | uccide (kill) tutti i processi nella console virtuale attuale (SAK)
`s` | sincronizza tutti i file system montati per evitare corruzione di dati
`u` | monta nuovamente tutti i file system in sola letturra (umount)
`r` | ripristina la tastiera dalla modalità raw dopo un crash di X

Vedere ulteriori informazioni in "Linux kernel user’s and administrator’s guide" » "Linux Magic System Request Key Hacks"

| Suggerimento
Si può usare la funzione Alt-R_Sist da un terminale SSH, ecc. scrivendo su "`/proc/sysrq-trigger`". Per esempio, "`echo s > /proc/sysrq-trigger; echo u > /proc/sysrq-trigger`" dal prompt di shell di root sincronizza ed esegue umount per tutti i file system montati.

L'attuale (2021) kernel Linux amd64 di Debian ha `/proc/sys/kernel/sysrq=438=0b110110110`:

- 2 = 0x2 - abilitare il controllo del livello di log della console (ON)

- 4 = 0x4 - abilitare il controllo della tastiera (SAK, unraw) (ON)

- 8 = 0x8 - abilitare dump di debug dei processi, ecc. (OFF)

- 16 = 0x10 - abilitare commando sync (ON)

- 32 = 0x20 - abiitare il ri-montaggio in sola lettura (ON)

- 64 = 0x40 - abilitare il segnali per i processi (term, kill, oom-kill) (OFF)

- 128 = 0x80 - permettere riavvio/spegnimento (ON)

- 256 = 0x100 - permettere l'impostazione valore di nice di tutte le attività RT (ON)

## 9.5. Suggerimenti per l'amministrazione del sistema

### 9.5.1. Chi è nel sistema?

Si può controllare chi è connesso al sistema nei modi seguenti.

- `who`(1) mostra chi ha fatto il login ed è connesso.

- `w`(1) mostra l'elenco di chi ha fatto il login ed è connesso e cosa sta facendo.

- `last`(1) mostra l'elenco degli utenti che hanno fatto il login più recentemente.

- `lastb`(1) mostra l'elenco degli utenti che hanno tentato il login non riuscendovi più recentemente.

| Suggerimento
Queste informazioni sugli utenti sono contenute in "`/var/run/utmp`" e "`/var/log/wtmp`". Vedere `login`(1) e `utmp`(5).

### 9.5.2. Avvertire tutti gli utenti

Si può mandare un messaggio a tutti gli utenti che sono connessi al sistema con `wall`(1) nel modo seguente.

    $ echo "We are shutting down in 1 hour" | wall

### 9.5.3. Identificazione dell'hardware

Per i dispositivi di tipo simil-PCI (AGP, PCI-Express, CardBus, ExpressCard, ecc.), `lspci`(8) (probabilmente con l'opzione "`-nn`") è un buon punto di partenza per l'identificazione dell'hardware.

In alternativa, si può identificare l'hardware leggendo il contenuto di "`/proc/bus/pci/devices`" o sfogliando l'albero di directory in "`/sys/bus/pci`" (vedere Sezione 1.2.12, «procfs e sysfs»).

Tabella 9.13. Elenco di strumenti per l'identificazione dell'hardware

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`pciutils` | V:254, I:992 | 280 | utilità PCI Linux: `lspci`(8)
`usbutils` | V:80, I:887 | 322 | utilità Linux USB: `lsusb`(8)
`nvme-cli` | V:22, I:30 | 2222 | utilità NVMe per Linux: `nvme`(1)
`pcmciautils` | V:4, I:7 | 92 | utilità PCMCIA per Linux: `pccardctl`(8)
`scsitools` | V:0, I:2 | 261 | raccosta di strumenti per la gestione dell'hardware SCSI:`lsscsi`(8)
`procinfo` | V:0, I:6 | 149 | informazioni sul sistema ottenute da "`/proc`": `lsdev`(8)
`lshw` | V:13, I:90 | 971 | informazioni sulla configurazione hardware: `lshw`(1)
`discover` | V:27, I:685 | 81 | sistema di identificazione dell'hardware: `discover`(8)

### 9.5.4. Configurazione dell'hardware

Sebbene nei moderni sistemi desktop con interfaccia grafica, come GNOME e KDE, la maggior parte della configurazione dell'hardware possa essere gestita attraverso strumenti di configurazione con interfaccia grafica da essi forniti, è bene conoscere alcuni metodi di base di configurazione.

Tabella 9.14. Elenco di strumenti di configurazione dell'hardware

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`console-setup` | V:77, I:973 | 420 | utilità Linux per i tipi di carattere e la mappa di tastiera in console
`x11-xserver-utils` | V:312, I:542 | 559 | utilità del server X: `xset`(1), `xmodmap`(1)
`acpid` | V:58, I:90 | 158 | demone per gestire eventi inviati dall'ACPI (Advanced Configuration and Power Interface, interfaccia avanzata per configurazione ed energia)
`acpi` | V:7, I:85 | 49 | utilità per mostrare informazioni sui device ACPI
`sleepd` | V:0, I:0 | 84 | demone per sospendere un portatile durante l'inattività
`hdparm` | V:117, I:222 | 246 | ottimizzazione degli accessi al disco fisso (vedere Sezione 9.6.9, «Ottimizzare il disco rigido»)
`smartmontools` | V:229, I:264 | 2455 | controllo e monitoraggio dei sistemi di archiviazione usando S.M.A.R.T.
`setserial` | V:3, I:5 | 104 | raccolta di strumenti per la gestione delle porte seriali
`memtest86+` | V:0, I:19 | 12473 | raccolta di strumenti per la gestione di hardware di memoria
`scsitools` | V:0, I:2 | 261 | raccolta di strumenti per la gestione di hardware SCSI
`setcd` | V:0, I:0 | 33 | ottimizzazione dell'accesso alle unità CD
`big-cursor` | I:0 | 26 | puntatori del mouse più grandi per X

ACPI è un'infrastruttura per il sistema di gestione dell'energia più nuovo di APM

| Suggerimento
La modifica della frequenza della CPU nei sistemi moderni è controllata da moduli del kernel come `acpi_cpufreq`.

### 9.5.5. Orario di sistema e hardware

I comandi seguenti impostano l'ora di sistema e hardware a MM/GG hh:mm, AAAA.

    # date MMDDhhmmCCYY
    # hwclock --utc --systohc
    # hwclock --show

Nei sistemi Debian, gli orari sono mostrati normalmente come ora locale, ma l'ora di sistema e quella hardware usano di solito l'ora UTC(GMT).

Se l'ora hardware è impostata ad UTC, modificare l'impostazione nel file "`/etc/default/rcS`" ad "`UTC=yes`".

Il comando seguente riconfigura il fuso orario utilizzato dal sistema Debian.

    # dpkg-reconfigure tzdata

Se si desidera tenere aggiornata l'ora di sistema attraverso la rete, si consideri l'uso del servizion NTP con pacchetti come `ntp`, `ntpdate` e `chrony`.

| Suggerimento
In systemd, usare invece `systemd-timesyncd` per l'ora di rete. Vedere `systemd-timesyncd`(8).

Vedere la documentazione seguente.

- Managing Accurate Date and Time HOWTO

- Progetto servizi NTP pubblici

- Il pacchetto `ntp-doc`

| Suggerimento
`ntptrace`(8), nel pacchetto `ntp` può tracciare una catena di server NTP all'indietro fino alla fonte originaria.

### 9.5.6. Configurazione del terminale

Ci sono diversi componenti per configurare le funzionalità della console a caratteri e il sistema `ncurses`(3).

- Il file "`/etc/terminfo/*/*`" (`terminfo`(5))

- La variabile d'ambiente "`$TERM`" (`term`(7))

- `setterm`(1), `stty`(1), `tic`(1) e `toe`(1)

Se, con un `xterm` non Debian, la voce `terminfo` per `xterm` non funziona, cambiare il tipo di terminale "`$TERM`" da "`xterm`" ad una delle versioni con funzionalità limitate come "`xterm-r6`" quando si fa il login ad un sistema Debian da remoto. Per ulteriori informazioni vedere "`/usr/share/doc/libncurses5/FAQ`" . "`dumb`" è il minimo denominatore comune per "`$TERM`".

### 9.5.7. L'infrastruttura audio

I driver di dispositivo per le schede audio per l'attuale Linux sono forniti da ALSA (Advanced Linux Sound Architecture). ALSA fornisce una modalità di emulazione per la compatibilità con il precedente sistema OSS (Open Sound System).

I software applicativi possono essere configurati non solo per accedere direttamente a device audio, ma anche per accedervi attraverso un qualche sistema server audio standardizzato. Attualmente PulseAudio, JACK e PipeWire vengono usati come sistemi per server audio. Vedere la pagina del wiki Debian sull'Audio per la situazione più recente.

Normalmente esiste un motore audio comune per ciascun ambiente desktop. Ciascun motore audio usato dalle applicazioni può scegliere di connettersi a diversi server audio.

| Suggerimento
Per testare l'altoparlante usare "`cat /dev/urandom > /dev/audio`" oppure `speaker-test`(1) (^C per interrompere).

| Suggerimento
Se non si ottiene l'audio, è possibile che l'altroparlante sia connesso ad un output impostato come muto. I moderni sistemi sonori hanno svariati output. `alsamixer`(1) nel pacchetto `alsa-utils` è utile per configurare le impostazioni del volume e di muto.

Tabella 9.15. Elenco di pacchetti relativi all'audio

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`alsa-utils` | V:341, I:475 | 2702 | utilità per configurare ed usare ALSA
`oss-compat` | V:0, I:10 | 18 | compatibilità OSS in ALSA per prevenire errori "`/dev/dsp not found`"
`pipewire` | V:316, I:373 | 142 | server multimediale per motore di elaborazione audio e video - metapacchetto
`pipewire-bin` | V:324, I:373 | 2094 | server multimediale per motore di elaborazione audio e video - server e CLI audio
`pipewire-alsa` | V:168, I:238 | 197 | server multimediale per motore di elaborazione audio e video - server audio per rimpiazzare ALSA
`pipewire-pulse` | V:280, I:340 | 64 | server multimediale per motore di elaborazione audio e video - server audio per rimpiazzare PulseAudio
`pulseaudio` | V:166, I:197 | 6606 | server PulseAudio
`libpulse0` | V:439, I:587 | 977 | libreria client PulseAudio
`jackd` | V:2, I:15 | 8 | server JACK (JACK Audio Connection Kit) (bassa latenza)
`libjack0` | V:2, I:9 | 330 | libreria JACK (JACK Audio Connection Kit) (bassa latenza)
`libgstreamer1.0-0` | V:465, I:602 | 5280 | GStreamer: motore audio di GNOME
`libphonon4qt5-4` | V:28, I:64 | 572 | Phonon: motore audio di KDE

### 9.5.8. Disabilitare il salvaschermo

Per disabilitare il salvaschermo usare i comandi seguenti.

Tabella 9.16. Elenco di comandi per disabilitare il salvaschermo

ambiente | comando
--- | ---
Console Linux | `setterm -powersave off`
X Window (disabilitare il salvaschermo) | `xset s off`
X Window (disabilitare DPMS) | `xset -dpms`
X Window (configurazione tramite GUI del salvaschermo) | `xscreensaver-command -prefs`

### 9.5.9. Disabilitare i bip sonori

Per disabilitare i bip sonori è sempre possibile disconnettere l'altoparlante del PC; la rimozione del modulo `pcspkr` del kernel fa stessa cosa per conto dell'utente.

Il comando seguente evita che il programma `readline`(3) usato da `bash`(1) emetta suoni bip quando incontra un carattere di allerta (ASCII=7).

    $ echo "set bell-style none">> ~/.inputrc

### 9.5.10. Uso della memoria

Ci sono 2 risorse disponibile per l'utente per ottenere la situazione dell'uso della memoria.

- I messaggi di avvio del kernel nel file "`/var/log/dmesg`" contengono la dimensione esatta della memoria disponibile.

- `free`(1) e `top`(1) mostrano informazioni sulle risorse di memoria nel sistema mentre è in funzione.

Ecco un esempio.

    # grep '\] Memory' /var/log/dmesg
    [    0.004000] Memory: 990528k/1016784k available (1975k kernel code, 25868k reserved, 931k data, 296k init)
    $ free -k
                 total       used       free     shared    buffers     cached
    Mem:        997184     976928      20256          0     129592     171932
    -/+ buffers/cache:     675404     321780
    Swap:      4545576          4    4545572

Ci si potrebbe chiedere perché dmesg dice che ci sono 990 MB liberi e free -k dice che sono liberi 320 MB. Ne mancano più di 600 MB.

Non ci si deve preoccupare della grande dimensione del valore "`used`" (usata) e del piccolo valore di "`free`" (libera) nella riga "`Mem:`", ma si può invece leggere la riga sottostante (con 675404 e 321780 nell'esempio precedente) e rilassarsi.

Per il mio MacBook con 1GB=1048576k DRAM (il sistema video ne ruba un po'), vedo le informazioni seguenti.

Tabella 9.17. Elenco di dimensioni della memoria riportate

fonte | dimensione
--- | ---
Dimensione totale in dmesg | 1016784k = 1GB - 31792k
Libera in dmesg | 990528k
Dimensione totale nella shell | 997184k
Libera nella shell | 20256k (ma in effetti 321780k)

### 9.5.11. Verifica della sicurezza e dell'integrità del sistema

Una cattiva manutenzione del sistema può esporlo ad attacchi esterni.

Per verificare la sicurezza e l'integrità del sistema, si dovrebbe iniziare dai punti seguenti.

- Il pacchetto `debsums`; vedere `debsums`(1) e Sezione 2.5.2, «File "Release" nella directory principale ed autenticità».

- Il pacchetto `chkrootkit`; vedere `chkrootkit`(1).

- La famiglia di pacchetti `clamav`; vedere `clamscan`(1) e `freshclam`(1).

- FAQ Debian Security.

- Manuale Securing Debian.

Tabella 9.18. Elenco di strumenti per verificare la sicurezza e l'integrità del sistema

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`logcheck` | V:5, I:6 | 120 | demone per inviare via posta anomalie nei file di registro di sistema all'amministratore
`debsums` | V:4, I:30 | 107 | utilità per controllare i file dei pacchetti installati con le somme di controllo MD5
`chkrootkit` | V:9, I:14 | 966 | rilevatore di rootkit
`clamav` | V:8, I:39 | 33154 | utilità anti-virus per Unix - interfaccia a riga di comando
`tiger` | V:1, I:1 | 7800 | riporta vulnerabilità nella sicurezza di sistema
`tripwire` | V:1, I:1 | 5050 | strumento di controllo dell'integrità di file e directory
`john` | V:1, I:7 | 469 | strumento di violazione delle password attive
`aide` | V:1, I:2 | 331 | AIDE - ambiente avanzato di rilevamento delle intrusioni - binario statico
`integrit` | V:0, I:0 | 2939 | programma di controllo dell'integrità di file
`crack` | V:0, I:0 | 153 | programma per indovinare password

Con il piccolo script seguente è possibile controllare la presenza di tipici errori con permessi di scrittura per tutti per i file sbagliati.

    # find / -perm 777 -a \! -type s -a \! -type l -a \! \( -type d -a -perm 1777 \)

| Attenzione
Data che il pacchetto `debsums` usa le somme di controllo MD5 salvate localmente, non può essere completamente affidabile come strumento di controllo della sicurezza del sistema contro attacchi malevoli.

## 9.6. Suggerimenti per l'archiviazione dei dati

Booting your system as the Linux live system (see Sezione 3.2.2, «Linux live rescue system on USB» and Sezione 3.2.3, «Linux live rescue system from GRUB») makes it easy for you to reconfigure data storage on the installed system.

Può essere necessario smontare manualmente dalla riga di comando con `umount`(8) alcuni dispositivi prima di operare su di essi se sono stati automaticamente montati dal sistema desktop GUI.

### 9.6.1. Uso dello spazio su disco

L'uso dello spazio su disco può essere valutato con i programmi forniti dai pacchetti `mount`, `coreutils` e `xdu`:

- `mount`(8) mostra tutti i file system (= dischi) montati.

- `df`(1) mostra l'uso dello spazio su disco da parte dei file system.

- `du`(1) mostra l'uso dello spazio su disco da parte dell'albero di directory.

| Suggerimento
Si può indirizzare l'output di `du`(8) a `xdu`(1x) per far sì che che produca la sua rappresentazione grafica e interattiva, usando "`du -k . |xdu`", "`sudo du -k -x / |xdu`", ecc.

### 9.6.2. Configurazione del partizionamento dei dischi

Per la configurazione del partizionamento dei dischi, benché `fdisk`(8) sia considerato lo strumento standard, `parted`(8) merita un po' di attenzione. "Dati di partizionamento del disco", "tabella delle partizioni", "mappa delle partizioni" e "etichetta del disco" sono tutti sinonimi.

I PC più vecchi usano il classico schema basato su MBR (Master Boot Record) per contenere i dati sul partizionamento del disco nel primo settore, cioè il settore LBA 0 (512 byte).

I PC recenti con Unified Extensible Firmware Interface (UEFI), compresi i Mac basati su Intel, usano lo schema GPT (GUID Partition Table) per contenere i dati sul partizionamento del disco non nel primo settore.

Sebbene `fdisk`(8) sia stato lo strumento standard per il partizionamento dei dischi, `parted`(8) lo sta sostituendo.

Tabella 9.19. Elenco di pacchetti di gestione delle partizioni dei dischi

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`util-linux` | V:897, I:999 | 4384 | utilità di sistema varie inclusi `fdisk`(8) e `cfdisk`(8)
`parted` | V:445, I:579 | 126 | programma GNU Parted per il ridimensionamento delle partizioni dei dischi
`gparted` | V:13, I:92 | 2313 | editor delle partizioni di GNOME basato su `libparted`
`gdisk` | V:20, I:309 | 940 | editor delle partizioni per i dischi ibridi GPT/MBR
`kpartx` | V:17, I:27 | 78 | programma per creare la mappatura a device per le partizioni

| Attenzione
Sebbene `parted`(8) sostenga di creare e ridimensionare anche i file system, è più sicuro fare queste cose usando gli strumenti specializzati meglio mantenuti, come `mkfs`(8) (`mkfs.msdos`(8), `mkfs.ext2`(8), `mkfs.ext3`(8), `mkfs.ext4`(8), …) e `resize2fs`(8).

| Nota
Per poter commutare tra GPT e MBR, è necessario cancellare direttamente i primi pochi blocchi del contenuto del disco (vedere Sezione 9.8.6, «Pulire il contenuto di file») e usare "`parted /dev/sdx mklabel gpt`" o "`parted /dev/sdx mklabel msdos`", per fare il cambiamento. Notare che in questo contesto è usato "`msdos`" per MBR.

### 9.6.3. Accedere alle partizioni usando UUID

Anche se la riconfigurazione delle partizioni o l'ordine di attivazione di supporti di archiviazione removibili può portare ad avere nomi diversi per le partizioni, è possibile accedere ad esse in modo coerente. Ciò è utile anche se si hanno più dischi ed il BIOS/UEFI non assegna loro un nome di dispositivo costante.

- `mount`(8) con l'opzione "`-U`" può montare un device a blocchi usando l'UUID invece di usare il suo nome di file come "`/dev/sda3`".

- Il file "`/etc/fstab`" (vedere `fstab`(5)) può usare gli UUID.

- Anche i bootloader (Sezione 3.1.2, «Stadio 2: il bootloader») possono usare gli UUID.

| Suggerimento
Si può scoprire l'UUID di un device a blocchi speciale con `blkid`(8). Si può anche sondare UUID e altre informazioni con "`lsblk -f`".

### 9.6.4. LVM2

LVM2 è un gestore di volumi logici per il kernel Linux. Con LVM2 si possono creare partizioni dei dischi in volumi logici invece che sugli hard disk fisici.

LVM richiede quanto segue.

- la gestione di device-mapper nel kernel Linux (predefinita per i kernel Debian)

- la libreria per la gestione di device-mapper in spazio utente (pacchetto `libdevmapper*`)

- gli strumenti LVM2 in spazio utente (pacchetto `lvm2`)

Per iniziare a comprendere LVM2 guardare le pagine di manuale seguenti.

- `lvm`(8): Principi di base del meccanismo LVM2 (elenco di tutti i comandi di LVM2)

- `lvm.conf`(5): File di configurazione per LVM2

- `lvs`(8): Riporta informazioni sui volumi logici

- `vgs`(8): Riporta informazioni sui gruppi di volumi

- `pvs`(8): Riporta informazioni sui volumi fisici

### 9.6.5. Configurazione del file system

Per il file system ext4, il pacchetto `e2fsprogs` fornisce gli strumenti seguenti.

- `mkfs.ext3`(8) per creare nuovi file system ext4

- `fsck.ext4`(8) per controllare e riparare file system ext4 esistenti

- `tune2fs`(8) per configurare i superblocchi di un file system ext4

- `debugfs`(8) per fare il debug di file system ext4 in modo interattivo. (Ha un comando `undel` per ripristinare file eliminati.)

I comandi `mkfs`(8) e `fsck`(8) sono forniti dal pacchetto `e2fsprogs` come front-end per vari programmi dipendenti dal file syste (`mkfs.tipofs` e `fsck.tipofs`). Per il file system ext4 , sono `mkfs.ext4`(8) e `fsck.ext4`(8) (sono un collegamento simbolico a `mke2fs`(8) e `e2fsck`(8)).

Sono disponibili comandi simili per ciascun file system supportato da Linux.

Tabella 9.20. Elenco di pacchetti di gestione dei file system

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`e2fsprogs` | V:796, I:997 | 1549 | utilità per i file system ext2/ext3/ext4
`btrfs-progs` | V:48, I:76 | 5204 | utilità per i file system Btrfs
`reiserfsprogs` | V:9, I:21 | 473 | utilità per i file system Reiserfs
`zfsutils-linux` | V:31, I:32 | 1891 | utilità per i file system OpenZFS
`dosfstools` | V:247, I:572 | 310 | utilità per i file system FAT (Microsoft: MS-DOS, Windows)
`exfatprogs` | V:36, I:467 | 352 | utilità per i file system exFAT mantenuti Samsung
`exfat-fuse` | V:2, I:50 | 73 | driver (Microsoft) in lettura/scrittura per file system exFAT per FUSE
`xfsprogs` | V:36, I:86 | 4386 | utilità per i file system XFS (SGI: IRIX)
`ntfs-3g` | V:193, I:527 | 1500 | driver in lettura/scrittura per i file system NTFS (Microsoft: Windows NT, …) per FUSE
`jfsutils` | V:0, I:7 | 1104 | utilità per i file system JFS (IBM: AIX, OS/2)
`xorriso` | V:14, I:63 | 347 | utilities for the ISO-9660 filesystem and CD/DVD writing from libburnia
`wodim` | V:8, I:96 | 898 | command line CD/DVD writing tool from cdrkit
`genisoimage` | V:18, I:167 | 1567 | command line ISO-9660 filesystem tool from cdrkit
`reiser4progs` | V:0, I:1 | 1367 | utilità per i file system Reiser4
`hfsprogs` | V:0, I:3 | 394 | utilità per i file system HFS e HFS Plus (Apple: Mac OS)
`zerofree` | V:5, I:119 | 30 | programma per impostare a 0 i blocchi liberi in file system ext2/3/4

| Suggerimento

Il file system Ext4 è il predefinito per il sistema Linux e il suo uso è caldamente raccomandato a meno che non sia abbiano specifiche ragioni per non farlo.

Lo stato di Btrfs può essere trovato nelle pagine del wiki Debian su btrfs e in quelle del wiki di kernel.org su btrfs. Ci si aspetta che sarà il prossimo file system predefinito dopo il file system ext4.

Alcuni strumenti permettono l'accesso a file system non supportati del kernel Linux (vedere Sezione 9.8.2, «Manipolare file senza montare i dischi»).

### 9.6.6. Creare file system e verificarne l'integrità

In un sistema Linux, il comando `mkfs`(8) crea i file system ed il comando `fsck`(8) fornisce funzioni di controllo dell'integrità e di riparazione dei file system.

Debian ora in modo predefinito non fa `fsck` periodici dopo la creazione del file system.

| Attenzione
In generale l'esecuzione di `fsck` su file system montati non è sicura.

| Suggerimento

Si può eseguire in modo sicuro il comando `fsck`(8) su tutti i file system, incluso il file system radice, al riavvio impostando "`enable_periodic_fsck`" in "`/etc/mke2fs.conf`" e il conteggio massimo di montaggi a 0 usando "`tune2fs -c0 /dev/nome_partizione`". Vedere `mke2fs.conf`(5) e `tune2fs`(8).

Per vedere i risultati del comando `fsck`(8) avviato dallo script di avvio, controllare i file in "`/var/log/fsck/`".

### 9.6.7. Ottimizzare il file system con opzioni di mount

La configurazione statica di base del file system è fornita da «`/etc/fstab`». Ad esempio,

    «file system»                   «mount point» «type» «options»    «dump» «pass»
    proc                                      /proc proc   defaults          0 0
    UUID=709cbe4c-80c1-56db-8ab1-dbce3146d2f7 /     ext4   errors=remount-ro 0 1
    UUID=817bae6b-45d2-5aca-4d2a-1267ab46ac23 none  swap   sw                0 0
    /dev/scd0                        /media/cdrom0  udf,iso9660 user,noauto  0 0

| Suggerimento
Per identificare un dispositivo a blocchi si può usare il suo UUID (vedere Sezione 9.6.3, «Accedere alle partizioni usando UUID») invece del normale nome di device a blocchi quale «`/dev/sda1`», «`/dev/sda2`», …

A partire da Linux 2.6.30 il kernel ha in modo predefinito il comportamento fornito dalla opzione "`relatime`".

Vedere `fstab`(5) e `mount`(8).

### 9.6.8. Ottimizzare il file system tramite il superblocco

Le caratteristiche di un file system possono essere ottimizzate attraverso il suo superblocco usando il comando `tune2fs`(8).

- L'esecuzione di "`sudo tune2fs -l /dev/sda1`" mostra il contenuto del superblocco del file system in "`/dev/sda1`".

- L'esecuzione di "`sudo tune2fs -c 50 /dev/sda1`" cambia per "`/dev/sda1`" la frequenza dei controlli dei file system (l'esecuzione di `fsck` all'avvio) a 50 avvii.

- L'esecuzione di "`sudo tune2fs -j /dev/sda1`" aggiunge la funzionalità di journaling al file system in "`/dev/sda1`", cioè converte il file system da ext2 a ext3. (Eseguire questo comando su file system non montati.)

- L'esecuzione di "`sudo tune2fs -O extents,uninit_bg,dir_index /dev/sda1 && fsck -pf /dev/sda1`" converte il filesystem in "`/dev/sda1`" da ext3 a ext4. (Eseguire questo comando su file system non montati.)

| Suggerimento
Nonostante il suo nome, `tune2fs`(8) non funziona soltanto sui file system ext2, ma anche sui file system ext3 e ext4.

### 9.6.9. Ottimizzare il disco rigido

| Avvertimento
Prima di giocare con la configurazione dei dischi controllare il proprio hardware e leggere la pagina man di `hdparm`(8), perché è una cosa piuttosto pericolosa per l'integrità dei dati.

Si può testare la velocità di accesso ai dischi di un disco rigido, ad esempio "`/dev/sda`" con "`hdparm -tT /dev/sda`". È possibile velocizzare alcuni dischi fissi connessi con (E)IDE con "`hdparm -q -c3 -d1 -u1 -m16 /dev/sda`" che abilita il "supporto (E)IDE per I/O a 32 bit", l'uso dell'opzione "using_dma", imposta l'opzione "interrupt-unmask" e imposta l'"I/O di settori multipli a 16" (pericoloso!).

Si possono testare le capacità della cache in scrittura di un disco fisso, ad esempio "`/dev/sda`", con "`hdparm -W /dev/sda`". Si può disabilitare la funzionalità di cache in scrittura con "`hdparm -W 0 /dev/sda`".

Potrebbe essere possibile leggere CDROM masterizzati male in unità CD-ROM moderne ad alta velocità rallentandole con "`setcd -x 2`".

### 9.6.10. Ottimizzare le unità a stato solido

Le unità SSD (Solid State Drive, a stato solido) sono ora rilevate automaticamente.

Ridurre accessi non necessari al disco per prevenire l'usura del disco montando "`tmpfs`" in percorsi dei dati volatili in `/etc/fstab`.

### 9.6.11. Usare SMART per prevedere danni ai dischi fissi

Con il demone `smartd` (8) è possibile monitorare e registrare i dischi fissi che sono conformi a SMART.

1. Abilitare la funzionalità SMART nel BIOS.

2. Installare il pacchetto `smartmontools`.

3. Identificare i dispositivi dei dischi fissi usando `df`(1).

   - Si supponga che uno dei dispositivi dei dischi fissi da monitorare sia "`/dev/sda`".

4. Controllare l'output di "`smartctl -a /dev/sda`" per vedere se la funzionalità SMART è veramente abilitata.

   - Se non la è, abilitarla con "`smartctl -s on -a /dev/sda`".

5. Abilitare l'esecuzione del demone `smartd`(8) nel modo seguente.

   - Rimuovere il carattere iniziale di commento dalla riga "`start_smartd=yes`" nel file "`/etc/default/smartmontools`".

   - Riavviare il demone `smartd`(8) con "`sudo systemctl restart smartmontools`".

| Suggerimento
Il demone `smartd`(8) può essere personalizzato con il file `/etc/smartd.conf`, incluso per ciò che riguarda le notifiche dei messaggi di avvertimento.

### 9.6.12. Specificare una directory per l'archiviazione di dati temporanei usando $TMPDIR

Le applicazioni creano file temporanei normalmente nella directory di memorizzazione temporanea «`/tmp`». Se «`/tmp`» non contiene abbastanza spazio, si può specificare una directory di memorizzazione temporanea usando la variabile `$TMPDIR` per i programmi che si comportano in modo corretto.

### 9.6.13. Espandere lo spazio di archiviazione utilizzabile con LVM

Le partizioni create al momento dell'installazione su LVM (Logical Volume Manager (funzionalità di Linux) possono essere facilmente ridimensionate concatenando ad esse delle estensioni o suddividendo le loro estensioni su dispositivi di archiviazione multipli senza riconfigurazioni importanti del sistema.

### 9.6.14. Espandere lo spazio di archiviazione utilizzabile montando un'altra partizione

Se è disponibile una nuova partizione vuota (per esempio "`/dev/sdx`"), la si può formattare con `mkfs.ext4`(1) e montarla con `mount`(8) in una directory in cui è necessario avere più spazio. (È necessario copiare il contenuto originale della directory.)

    $ sudo mv work-dir old-dir
    $ sudo mkfs.ext4 /dev/sdx
    $ sudo mount -t ext4 /dev/sdx work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Suggerimento
In alternativa si può montare un file immagine vuoto del disco (vedere Sezione 9.7.5, «Creare un file con immagine di disco vuoto») come device loop (vedere Sezione 9.7.3, «Montare un file con un'immagine di disco»). Il reale uso del disco cresce mano a mano che vengono archiviati i dati.

### 9.6.15. Espandere lo spazio di archiviazione utilizzabile montando un collegamento ad un'altra directory

Se è disponibile una directory vuota (ad esempio "`/percorso/della/dir-vuota`") in un'altra partizione con spazio disponibile, si può, usando mount(8) con l'opzione "`--bind`", montarla in una directory (ad esempio "`dir-di-lavoro`") dove è necessario più spazio.

    $ sudo mount --bind /path/to/emp-dir work-dir

### 9.6.16. Espandere lo spazio di archiviazione utilizzabile montando un'altra directory da sovrapporre

Se è disponibile dello spazio utilizzabile in un'altra partizione (ad esempio "`/percorso/della/vuota`" e "`/percorso/di/lavoro`"), si può creare in essa una directory e impilarla in una vecchia directory (es., "`/percorso/della/vecchia`") in cui si ha bisogno di spazio usando OverlayFS con un kernel Linux 3.18 o successivo (Debian Stretch 9.0 o successiva).

    $ sudo mount -t overlay overlay \
      -olowerdir=/path/to/old-dir,upperdir=/path/to/empty,workdir=/path/to/work

Qui, "`/percorso/della/vuota`" e "`/percorso/di/lavoro`" devono essere nella partizione abilitata in lettura e scrittura da scrivere in "`/percorso/della/vecchia`".

### 9.6.17. Espandere lo spazio di archiviazione utilizzabile usando collegamenti simbolici

| Attenzione
Questo è un metodo deprecato. Certo software può non funzionare bene con i "collegamenti simbolici ad una directory". Usare invece gli approcci che usano il "mount" descritti in precedenza.

Se è disponibile una directory vuota (ad esempio "`/percorso/della/dir-vuota`" in un'altra partizione con spazio disponibile, si può creare un collegamento simbolico alla directory con `ln`(8).

    $ sudo mv work-dir old-dir
    $ sudo mkdir -p /path/to/emp-dir
    $ sudo ln -sf /path/to/emp-dir work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Avvertimento
Non usare un "collegamento simbolico ad una directory" per le directory gestite dal sistema, come "`/opt`". Un collegamento simbolico simile potrebbe essere sovrascritto quando il sistema viene aggiornato.

## 9.7. Immagine del disco

Questa sezione tratta della manipolazione di immagini di dischi.

### 9.7.1. Creare un file con un'immagine di disco

The disk image file, "`disk.img`", of an unmounted device, e.g., the second SCSI or serial ATA drive "`/dev/sdb`", can be made by one of the following.

    # dd if=/dev/sdb of=disk.img; sync

    # cp /dev/sdb disk.img ; sync

    # cat /dev/sdb > disk.img ; sync

Si può creare l'immagine del disco del MBR (master boot record) dei PC tradizionali (vedere Sezione 9.6.2, «Configurazione del partizionamento dei dischi»), che risiede nel primo settore del disco IDE primario usando `dd`(1) nel modo seguente.

    # dd if=/dev/sda of=mbr.img bs=512 count=1
    # dd if=/dev/sda of=mbr-nopart.img bs=446 count=1
    # dd if=/dev/sda of=mbr-part.img skip=446 bs=1 count=66

- "`mbr.img`": MBR con tabella delle partizioni

- "`mbr-nopart.img`": MBR senza tabella delle partizioni

- "`mbr-part.img`": solamente la tabella delle partizioni nell'MBR

Se si sta creando l'immagine di una partizione del disco originale, sostituire "`/dev/sda`" con "`/dev/sda1`", ecc.

### 9.7.2. Scrivere direttamente sul disco

The disk image file, "`disk.img`" can be written to an unmounted device, e.g., the second SCSI drive "`/dev/sdb`" with matching size, by one of the following.

    # dd if=disk.img of=/dev/sdb ; sync

    # cp disk.img /dev/sdb ; sync

    # cat disk.img >/dev/sdb ; sync

Analogamente il file immagine di una partizione del disco, "`partizione.img`" può essere scritto in una partizione non montata, ad esempio la prima partizione della seconda unità SCSI "`/dev/sdb1`" di dimensione corrispondente nel modo seguente.

    # dd if=partition.img of=/dev/sdb1 ; sync

### 9.7.3. Montare un file con un'immagine di disco

Un'immagine di disco "`partizione.img`" contenente l'immagine di un'unica partizione, può essere montata e smontata usando il device loop nel modo seguente.

    # losetup --show -f partition.img
    /dev/loop0
    # mkdir -p /mnt/loop0
    # mount -t auto /dev/loop0 /mnt/loop0
    ...hack...hack...hack
    # umount /dev/loop0
    # losetup -d /dev/loop0

Questo può essere semplificato nel modo seguente.

    # mkdir -p /mnt/loop0
    # mount -t auto -o loop partition.img /mnt/loop0
    ...hack...hack...hack
    # umount partition.img

Ogni partizione di un'immagine di disco "`disco.img`" contentente più partizioni, può essere montata usando il device loop.

    # losetup --show -f -P disk.img
    /dev/loop0
    # ls -l /dev/loop0*
    brw-rw---- 1 root disk   7,  0 Apr  2 22:51 /dev/loop0
    brw-rw---- 1 root disk 259, 12 Apr  2 22:51 /dev/loop0p1
    brw-rw---- 1 root disk 259, 13 Apr  2 22:51 /dev/loop0p14
    brw-rw---- 1 root disk 259, 14 Apr  2 22:51 /dev/loop0p15
    # fdisk -l /dev/loop0
    Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 sectors
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: gpt
    Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

    Device         Start     End Sectors  Size Type
    /dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
    /dev/loop0p14   2048    8191    6144    3M BIOS boot
    /dev/loop0p15   8192  262143  253952  124M EFI System

    Partition table entries are not in disk order.
    # mkdir -p /mnt/loop0p1
    # mkdir -p /mnt/loop0p15
    # mount -t auto /dev/loop0p1 /mnt/loop0p1
    # mount -t auto /dev/loop0p15 /mnt/loop0p15
    # mount |grep loop
    /dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
    /dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
    ...hack...hack...hack
    # umount /dev/loop0p1
    # umount /dev/loop0p15
    # losetup -d /dev/loop0

In alternativa, un risultato simile può essere ottenuto utilizzando i device mapper creati da `kpartx`(8), contenuto nel pacchetto `kpartx`, nel modo seguente.

    # kpartx -a -v disk.img
    add map loop0p1 (253:0): 0 3930112 linear 7:0 262144
    add map loop0p14 (253:1): 0 6144 linear 7:0 2048
    add map loop0p15 (253:2): 0 253952 linear 7:0 8192
    # fdisk -l /dev/loop0
    Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 sectors
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: gpt
    Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

    Device         Start     End Sectors  Size Type
    /dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
    /dev/loop0p14   2048    8191    6144    3M BIOS boot
    /dev/loop0p15   8192  262143  253952  124M EFI System

    Partition table entries are not in disk order.
    # ls -l /dev/mapper/
    total 0
    crw------- 1 root root 10, 236 Apr  2 22:45 control
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p1 -> ../dm-0
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p14 -> ../dm-1
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p15 -> ../dm-2
    # mkdir -p /mnt/loop0p1
    # mkdir -p /mnt/loop0p15
    # mount -t auto /dev/mapper/loop0p1 /mnt/loop0p1
    # mount -t auto /dev/mapper/loop0p15 /mnt/loop0p15
    # mount |grep loop
    /dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
    /dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
    ...hack...hack...hack
    # umount /dev/mapper/loop0p1
    # umount /dev/mapper/loop0p15
    # kpartx -d disk.img

### 9.7.4. Pulire un file con un'immagine di disco

Si può pulire un file con immagine di disco "`disco.img`" da tutti i file cancellati creando un'immagine pulita "`nuova.img`" nel modo seguente.

    # mkdir old; mkdir new
    # mount -t auto -o loop disk.img old
    # dd bs=1 count=0 if=/dev/zero of=new.img seek=5G
    # mount -t auto -o loop new.img new
    # cd old
    # cp -a --sparse=always ./ ../new/
    # cd ..
    # umount new.img
    # umount disk.img

Se "`disco.img`" è in ext2, ext3 o ext4, si può anche usare `zerofree`(8), contenuto nel pacchetto `zerofree`, nel modo seguente.

    # losetup --show -f disk.img
    /dev/loop0
    # zerofree /dev/loop0
    # cp --sparse=always disk.img new.img
    # losetup -d /dev/loop0

### 9.7.5. Creare un file con immagine di disco vuoto

Si può creare un'immagine di disco vuota "`disco.img`", che può crescere fino a 5GiB, usando `dd`(1) nel modo seguente.

    $ dd bs=1 count=0 if=/dev/zero of=disk.img seek=5G

Invece di usare `dd`(1), qui si può usare lo specializzato `fallocate`(8).

È possibile creare un file system ext4 in questa immagine di disco, "`disco.img`" usando il device loop nel modo seguente.

    # losetup --show -f disk.img
    /dev/loop0
    # mkfs.ext4 /dev/loop0
    ...hack...hack...hack
    # losetup -d /dev/loop0
    $ du  --apparent-size -h disk.img
    5.0G  disk.img
    $ du -h disk.img
    83M disk.img

La dimensione del file "`disco.img`" è di 5.0GiB e il suo effettivo uso del disco è di soli 83MiB. Questa discrepanza è resa possibile dal fatto che il file system ext4 può contentere file sparsi.

| Suggerimento
L'uso effettivo del disco dei file sparsi cresce insieme ai dati che in essi sono scritti.

Usando operazioni simili su device creati dal device loop o dal device mapper, come in Sezione 9.7.3, «Montare un file con un'immagine di disco», si può partizionare tale immagine di disco "`disco.img`" usando `parted`(8) o `fdisk`(8) e si può creare in essa file system usando `mkfs.ext4`(8), `mkswap`(8), ecc.

### 9.7.6. Creare un file con un'immagine ISO9660

| Suggerimento
Both `genisoimage`(1) provided by cdrkit and `xorrisofs`(1) provided by Libburnia share the same command syntax except for the command name.

Si può creare un file immagine ISO9660 "`cd.iso`" dell'albero di directory originale in "`directory_sorgente`" usando `genisoimage`(1) fornito da cdrkit nel modo seguente.

    #  genisoimage -r -J -T -V volume_id -o cd.iso source_directory

Analogamente, si può creare un file immagine ISO9660 avviabile, "`cdboot.iso`", da un albero di directory simile a quello del `debian-installer` in "`directory_sorgente`" nel modo seguente.

    #  genisoimage -r -o cdboot.iso -V volume_id \
       -b isolinux/isolinux.bin -c isolinux/boot.cat \
       -no-emul-boot -boot-load-size 4 -boot-info-table source_directory

In questo esempio viene usato per l'avvio il bootloader Isolinux (vedere Sezione 3.1.2, «Stadio 2: il bootloader»).

Si può calcolare il valore md5sum e creare l'immagine ISO9660 direttamente dal device CD-ROM nel modo seguente.

    $ isoinfo -d -i /dev/cdrom
    CD-ROM is in ISO 9660 format
    ...
    Logical block size is: 2048
    Volume size is: 23150592
    ...
    # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror | md5sum
    # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror > cd.iso

| Avvertimento
Per ottenere un risultato corretto, si deve accuratamente evitare il bug di Linux riguardante il read ahead del file system ISO9660, come nell'esempio precedente.

### 9.7.7. Scrivere direttamente sul CD/DVD-R/RW

| Suggerimento
DVD is only a large CD to `wodim`(1) provided by cdrkit and `xorrecord`(1) provided by Libburnia. These commands share the same command syntax except for the command name.

Si può trovare un device utilizzabile usando il comando seguente.

    # wodim --devices

Poi si inserisce un CD-R vergine nell'unità CD e si scrive il file immagine ISO9660 "`cd.iso`" su questo device, ad esempio "`/dev/sda`", usando `wodim`(1) nel modo seguente.

    # wodim -v -eject dev=/dev/sda cd.iso

Se viene usato un CD-RW invece di un CD-R, usare quest'altro comando.

    # wodim -v -eject blank=fast dev=/dev/sda cd.iso

| Suggerimento
Se il sistema desktop usato monta automaticamente i CD, prima di usare `wodim`(1) smontarlo usando dalla console "`sudo umount /dev/sda`".

### 9.7.8. Montare un file con un'immagine ISO9660

Se "`cd.iso`" contiene un'immagine ISO9660, lo si può montare manualmente in "`/cdrom`" usando il comando seguente.

    # mount -t iso9660 -o ro,loop cd.iso /cdrom

| Suggerimento
I sistemi desktop moderni possono montare automaticamente i supporti removibili come i CD in formato ISO9660 (vedere Sezione 10.1.7, «Supporti di archiviazione removibili»).

## 9.8. I dati binari

Questa sezione tratta della manipolazione diretta dei dati binari su supporti di archiviazione.

### 9.8.1. Visualizzare e modificare dati binari

Il metodo di visualizzazione dei dati binai più basilare è l'uso del comando "`od -t x1`".

Tabella 9.21. Elenco di pacchetti che visualizzano e modificano dati binari

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | pacchetto base che contiene `od`(1) per fare il dump di file (HEX, ASCII, OCTAL, …)
`bsdmainutils` | V:4, I:152 | 17 | pacchetto di utilità che contiene `hd`(1) per fare il dump di file (HEX, ASCII, OCTAL, …)
`hexedit` | V:1, I:8 | 70 | visualizzatore ed editor binario (HEX, ASCII)
`bless` | V:0, I:1 | 924 | editor esadecimale completo (GNOME)
`okteta` | V:1, I:12 | 1590 | editor esadecimale completo (KDE4)
`ncurses-hexedit` | V:0, I:1 | 130 | visualizzatore ed editor binario (HEX, ASCII, EBCDIC)
`beav` | V:0, I:0 | 137 | visualizzatore ed editor binario (HEX, ASCII, EBCDIC, OCTAL, …)

| Suggerimento
HEX è usato come acronimo per il formato esadecimale con base 16. OCTAL è usato per il formato ottale con base 8. ASCII è usato per American Standard Code for Information Interchange, cioè la normale codifica per testi in inglese. EBCDIC è usato per Extended Binary Coded Decimal Interchange Code usato nei sistemi operativi deimainframe IBM.

### 9.8.2. Manipolare file senza montare i dischi

Esistono strumenti per leggere e scrivere file senza montare i dischi.

Tabella 9.22. Elenco di pacchetti per manipolare file senza montare i dischi

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`mtools` | V:7, I:54 | 400 | utilità per file MSDOS senza montarli
`hfsutils` | V:0, I:3 | 178 | utilità per file HFS e HFS+ senza montarli

### 9.8.3. Dati ridondanti

I sistemi software RAID offerti dal kernel Linux forniscono un livello di ridondanza dei dati nel file system a livello del kernel, allo scopo di ottenere una più alta affidabilità dell'archiviazione.

Esistono strumenti per aggiungere dati ridondanti a file a livello di programmi applicativi per ottenere anche in questo modo una più alta affidabilità dell'archiviazione.

Tabella 9.23. Elenco di strumenti per aggiungere dati ridondanti a file

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`par2` | V:10, I:119 | 298 | insiemi di volumi di archivi di parità, per controllare e riparare file
`dvdisaster` | V:0, I:1 | 1422 | protezione contro perdita di dati/graffi/invecchiamento di supporti CD/DVD
`dvbackup` | V:0, I:0 | 413 | strumento di backup che usa camcorder MiniDV (fornisce `rsbep`(1))

### 9.8.4. recupero di file dati ed analisi forensi

Esistono strumenti per recuperare file dati e fare analisi forensi.

Tabella 9.24. Elenco di pacchetti per recupero di file dati ed analisi forensi.

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`testdisk` | V:2, I:26 | 1495 | utilità per scansione delle partizione e ripristino di dischi
`magicrescue` | V:0, I:2 | 257 | utilità per ripristinare file cercando byte magici
`scalpel` | V:0, I:2 | 89 | strumento di escavazione di file frugale e ad alte prestazioni
`myrescue` | V:0, I:2 | 83 | recupera dati da dischi fissi danneggiati
`extundelete` | V:0, I:7 | 152 | utilità per decancellare file da file system ext3/4
`ext4magic` | V:0, I:3 | 235 | utilità per decancellare file da file system ext3/4
`ext3grep` | V:0, I:2 | 299 | strumento per aiutare a recuperare file cancellati da file system ext3
`scrounge-ntfs` | V:0, I:1 | 49 | programma di recupero di dati da file system NTFS
`gzrt` | V:0, I:0 | 33 | insieme di strumenti di recupero di gzip
`sleuthkit` | V:2, I:23 | 1729 | strumenti per analisi forensi (Sleuthkit)
`autopsy` | V:0, I:1 | 1026 | interfaccia grafica per SleuthKit
`foremost` | V:0, I:4 | 102 | applicazione forense per il recupero dei dati
`guymager` | V:0, I:0 | 1047 | strumento forense per immagini basato su Qt
`dcfldd` | V:0, I:2 | 113 | versione migliorata di `dd` per analisi forensi e sicurezza

| Suggerimento
Si possono ripristinare i file sui file system ext2 usando i comandi `list_deleted_inodes` e `undel` di `debugfs`(8) nel pacchetto `e2fsprogs`.

### 9.8.5. Suddividere un file grande in file più piccoli

Quando dei dati sono troppo grandi affinché ne venga fatto il backup in un file singolo, si può fare il backup dei suoi contenuti dopo averlo suddiviso in pezzi di, ad esempio 2000MiB, che saranno successivamente riuniti a formare il file originale.

    $ split -b 2000m large_file
    $ cat x* >large_file

| Attenzione
Assicurarsi di non avere altri file che iniziano con "`x`" per evitare conflitti nei nomi.

### 9.8.6. Pulire il contenuto di file

Per ripulire i contenuti di un file, come un file di registro, non usare `rm`(1) per cancellarlo e poi crearne un altro, perché nell'intervallo tra i due comandi potrebbe essere ancora possibile accedere al file. Quello che segue è il metodo sicuro per pulire il contenuto di un file.

    $ :>file_to_be_cleared

### 9.8.7. File fittizi

I comandi seguenti creano file fittizi o vuoti.

    $ dd if=/dev/zero    of=5kb.file bs=1k count=5
    $ dd if=/dev/urandom of=7mb.file bs=1M count=7
    $ touch zero.file
    $ : > alwayszero.file

Dovrebbero essere ora presenti i seguenti file.

- "`5kb.file`" è costituito da 5KB di zero.

- "`7mb.file`" è costituito da 7MB di dati casuali.

- "`zero.file`" potrebbe essere un file di 0 byte. Se fosse stato preesistente, il suo orario `mtime` sarebbe stato aggiornato mentre sarebbero stati mantenuti i suoi contenuti e la sua grandezza.

- "`semprezero.file`" è sempre un file di 0 byte. Se fosse stato preesistente, il suo orario `mtime` sarebbe stato aggiornato e il suo contenuto azzerato.

### 9.8.8. Cancellare un intero disco fisso

There are several ways to completely erase data from an entire hard disk like device, e.g., USB flash drive at "`/dev/sda`".

| Attenzione
Check your USB flash drive location with `mount`(8) first before executing commands here. The device pointed by "`/dev/sda`" may be SCSI hard disk or serial-ATA hard disk where your entire system resides.

Cancellare tutti i contenuti del disco reimpostando tutti i dati a 0 con il comando seguente.

    # dd if=/dev/zero of=/dev/sda

Cancellare tutto sovrascrivendo dati casuali con il comando seguente.

    # dd if=/dev/urandom of=/dev/sda

Cancellare tutto sovrascrivendo dati casuali in modo molto efficiente con il comando seguente.

    # shred -v -n 1 /dev/sda

In alternativa si può usare `badblocks`(8) con l'opzione `-t random`.

Dato che `dd`(1) è disponibile dalla shell di molti CD Linux avviabili, come il CD dell'installatore Debian, si può cancellare completamente il sistema installato su un disco fisso, ad esemio "`/dev/sda`", "`/dev/sda`", ecc., eseguendo un comando di cancellazione da un supporto CD simile.

### 9.8.9. Cancellare area inutilizzate di un disco fisso

Unused area on an hard disk (or USB flash drive), e.g. "`/dev/sdb1`" may still contain erased data themselves since they are only unlinked from the filesystem. These can be cleaned by overwriting them.

    # mount -t auto /dev/sdb1 /mnt/foo
    # cd /mnt/foo
    # dd if=/dev/zero of=junk
    dd: writing to `junk': No space left on device
    ...
    # sync
    # umount /dev/sdb1

| Avvertimento
This is usually good enough for your USB flash drive. But this is not perfect. Most parts of erased filenames and their attributes may be hidden and remain in the filesystem.

### 9.8.10. De-cancellare file cancellati ma ancora aperti

Anche se un file è stato cancellato per errore, fintanto che è usato da un'applicazione (in lettura o scrittura), è possibile recuperarlo.

Per esempio, provare a fare quanto segue.

    $ echo foo > bar
    $ less bar
    $ ps aux | grep ' less[ ]'
    bozo    4775  0.0  0.0  92200   884 pts/8    S+   00:18   0:00 less bar
    $ rm bar
    $ ls -l /proc/4775/fd | grep bar
    lr-x------ 1 bozo bozo 64 2008-05-09 00:19 4 -> /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -l
    -rw-r--r-- 1 bozo bozo 4 2008-05-09 00:25 bar
    $ cat bar
    foo

Quando si ha il pacchetto `lsof` installato, eseguire in un altro terminale quanto segue.

    $ ls -li bar
    2228329 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:02 bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar
    $ rm bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -li bar
    2228302 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:05 bar
    $ cat bar
    foo

### 9.8.11. Cercare tutti i collegamenti fisici

I file con collegamenti fisici possono essere identificati usando "`ls -li`".

    $ ls -li
    total 0
    2738405 -rw-r--r-- 1 root root 0 2008-09-15 20:21 bar
    2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 baz
    2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 foo

Entrambi "`pippo`" e "`pluto`" hanno il numero di collegamenti uguale a "2" (>1), il che mostra che hanno collegamenti fisici. Hanno il numero di inode, "2738404", in comune. Ciò significa che sono lo stesso file con un collegamento fisico. Nell'eventualità che non si trovino tutti i file con collegamento fisico, li si possono cercare in base all'inode, ad esempio "2738404", nel modo seguente.

    # find /path/to/mount/point -xdev -inum 2738404

### 9.8.12. Consumo invisibile dello spazio su disco

Tutti i file cancellati ma aperti consumano spazio su disco, anche se non sono visibili con il normale comando `du`(1). Possono essere elencati, insieme alla loro dimensione, nel modo seguente.

    # lsof -s -X / |grep deleted

## 9.9. Suggerimenti per la cifratura dei dati

Avendo l'accesso fisico alla macchina, chiunque può facilmente ottenere privilegi di root e accedere a tutti i file nel PC (vedere Sezione 4.6.4, «Rendere sicura la password di root»). Ciò significa che il sistema delle password di login non può mettere al sicuro i dati privati e sensibili contro un possibile furto del PC. Per farlo deve essere usata una tecnologia di cifratura dei dati. Sebbene GNU Privacy Guard (vedere Sezione 10.3, «Infrastruttura di sicurezza dei dati») possa cifrare file, richiede un po' di lavoro da parte dell'utente.

dm-crypt facilita la cifratura automatica dei dati attraverso moduli nativi del kernel Linux con un minimo lavoro da parte dell'utente usando device-mapper.

Tabella 9.25. Elenco di utilità per la cifratura dei dati

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`cryptsetup` | V:30, I:80 | 465 | utilità per device a blocchi cifrati (dm-crypt / LUKS)
`cryptmount` | V:2, I:2 | 231 | utilità per device a blocchi cifrati (dm-crypt / LUKS) con particolare attenzione al montaggio/smontaggio da parte di utenti normali
`fscrypt` | V:0, I:1 | 6471 | utilità per file cifratura di file system Linux (fscrypt)
`libpam-fscrypt` | V:0, I:0 | 5589 | modulo PAM per cifratura di file system Linux (fscrypt)

| Attenzione
La cifratura dei dati consuma tempo della CPU, ecc. I dati cifrati diventano inaccessibili se la password viene persa. Valutare bene i suoi costi e benefici.

| Nota
È possibile installare un intero file system Debian in un disco cifrato con l'Installatore Debian (lenny o successivo) usando dm-crypt/LUKS e initramfs.

| Suggerimento
Per lo strumento di cifratura in spazio utente GNU Privacy Guard vedere Sezione 10.3, «Infrastruttura di sicurezza dei dati».

### 9.9.1. Cifratura di dischi removibili con dm-crypt/LUKS

You can encrypt contents of removable mass devices, e.g. USB flash drive on "`/dev/sdx`", using dm-crypt/LUKS. You simply format it as the following.

    # fdisk /dev/sdx
    ... "n" "p" "1" "return" "return" "w"
    # cryptsetup luksFormat /dev/sdx1
    ...
    # cryptsetup open /dev/sdx1 secret
    ...
    # ls -l /dev/mapper/
    total 0
    crw-rw---- 1 root root  10, 60 2021-10-04 18:44 control
    lrwxrwxrwx 1 root root       7 2021-10-04 23:55 secret -> ../dm-0
    # mkfs.vfat /dev/mapper/secret
    ...
    # cryptsetup close secret

Si può poi montarla come una chiavetta qualunque in "`/media/nomeutente/etichetta_disco`", tranne per il fatto che verrà chiesta la password (vedere Sezione 10.1.7, «Supporti di archiviazione removibili») nei moderni ambienti desktop che usano il pacchetto `udisks2`. La differenza è che ogni dato scritto in essa è cifrato. L'inserimento della password può essere automatizzato usando un portachiavi (vedere Sezione 10.3.6, «Portachiavi per le password»).

In alternativa si può formattare il supporto con diversi file system, es. ext4 con "`mkfs.ext4 /dev/mapper/sdx1`". Se viene invece usato btrfs, deve essere installato il pacchetto `udisks2-btrfs`. Per questi file system può essere necessario configurare la proprietà e i permessi dei file.

### 9.9.2. Montare dischi removibili con dm-crypt/LUKS

Ad esempio, una partizione di disco cifrata creata con dm-crypt/LUKS su "`/dev/sdc5`" dall'Installatore Debian può essere montata in "`/mnt`" nel modo seguente:

    $ sudo cryptsetup open /dev/sdc5 ninja --type luks
    Enter passphrase for /dev/sdc5: ****
    $ sudo lvm
    lvm> lvscan
      inactive          '/dev/ninja-vg/root' [13.52 GiB] inherit
      inactive          '/dev/ninja-vg/swap_1' [640.00 MiB] inherit
      ACTIVE            '/dev/goofy/root' [180.00 GiB] inherit
      ACTIVE            '/dev/goofy/swap' [9.70 GiB] inherit
    lvm> lvchange -a y /dev/ninja-vg/root
    lvm> exit
      Exiting.
    $ sudo mount /dev/ninja-vg/root /mnt

## 9.10. Il kernel

Debian distribuisce, per le architetture supportate, kernel Linux modulari contenuti in pacchetti.

Se si sta leggendo questa documentazione probabilmente non è necessario compilare in proprio il kernel Linux.

### 9.10.1. Parametri del kernel

Molte caratteristiche di Linux possono essere configurate tramite parametri del kernel, nei modi seguenti.

- Parametri del kernel inizializzati dal bootloader (vedere Sezione 3.1.2, «Stadio 2: il bootloader»)

- Se accessibili attraverso sysfs (vedere Sezione 1.2.12, «procfs e sysfs»), parametri del kernel modificati da `sysctl`(8) durante l'esecuzione del sistema.

- Parametri di moduli impostati dagli argomenti di `modprobe`(8) al momento dell'attivazione di un modulo (vedere Sezione 9.7.3, «Montare un file con un'immagine di disco»)

Per i dettagli vedere "The Linux kernel user’s and administrator’s guide » The kernel’s command-line parameters".

### 9.10.2. Header del kernel

La maggior parte dei normali programmi non ha bisogno degli header del kernel per essere compilata, anzi di fatto può corrompersi se si usano direttamente gli header. Questi programmi dovrebbero essere compilati nel sistema Debian usando gli header in "`/usr/include/linux`" e "`/usr/include/asm`" forniti dal pacchetto `libc6-dev` (creato dal pacchetto sorgente `glibc`).

| Nota
Per compilare alcuni programmi specifici per il kernel, come moduli per il kernel da fonti esterne e il demone automounter (`amd`), è necessario includere nella propria riga di comando il percorso ai corrispondenti header del kernel, ad esempio "`-I/usr/src/linux-particular-version/include/`".

### 9.10.3. Compilare il kernel ed i moduli relativi

Debian ha un proprio metodo di compilazione del kernel e dei moduli relativi.

Tabella 9.26. Elenco di pacchetti chiave da installare per la ricompilazione del kernel in un sistema Debian

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`build-essential` | I:504 | 17 | pacchetti essenziali per compilare pacchetti Debian: `make`, `gcc`, …
`bzip2` | V:168, I:972 | 114 | utilità di compressione e decompressione per file bz2
`libncurses5-dev` | I:40 | 6 | librerie di sviluppo e documentazione per ncurses
`git` | V:382, I:597 | 50172 | git: sistema distribuito di controllo delle revisioni usato dal kernel Linux
`fakeroot` | V:31, I:507 | 225 | fornisce un ambiente fakeroot per compilare pacchetti da utente non root
`initramfs-tools` | V:479, I:988 | 52 | strumento per compilare un initramfs (specifico di Debian)
`dkms` | V:74, I:146 | 235 | DKMS (Dynamic Kernel Module Support, supporto dinamico per i noduli del kernel) (generico)
`module-assistant` | V:0, I:14 | 391 | script di aiuto per creare pacchetti di moduli (specifico di Debian)
`devscripts` | V:5, I:33 | 2770 | script di aiuto per i manutentori di pacchetti Debian (specifico di Debian)

Se si usa `initrd` nello Sezione 3.1.2, «Stadio 2: il bootloader», ci si assicuri di leggere le informazioni relative in `initramfs-tools`(8), `update-initramfs`(8), `mkinitramfs`(8) e `initramfs.conf`(5).

| Avvertimento
Quando si compilano i sorgenti del kernel Linux, non mettere collegamenti simbolici alle directory nell'albero dei sorgenti (ad esempio, "`/usr/src/linux*`") in "`/usr/include/linux`" e "`/usr/include/asm`". (Alcuni documenti ormai datati suggeriscono di farlo.)

| Nota

Quando si compila il kernel Linux più recente nel sistema Debian `stable`, potrebbe essere necessario l'uso delle versioni backport degli strumenti piu recenti da Debian `unstable`.

`module-assistant`(8) (o la sua forma abbreviata `m-a`) aiuta gli utenti a compilare e installare pacchetti di moduli facilmente per uno o più kernel personalizzati.

Il DKMS (Dynamic Kernel Module Support, supporto dinamico per i moduli del kernel) è un nuova infrastruttura indipendente dalla distribuzione progettata per permettere l'aggiornamento di singoli moduli del kernel senza cambiare tutto il kernel. È utilizzata per il mantenimento dei moduli esterni all'albero dei sorgenti. Rende anche molto facile la ricompilazione dei moduli quando si aggiornano i kernel.

### 9.10.4. Compilare i sorgenti del kernel: il metodo raccomandato dal Team del Kernel di Debian

Per compilare pacchetti binari del kernel personalizzati a partire dai sorgenti originali del kernel, si deve usare il target "`deb-pkg` fornito.

    $ sudo apt-get build-dep linux
    $ cd /usr/src
    $ wget https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-version.tar.xz
    $ tar --xz -xvf linux-version.tar.xz
    $ cd linux-version
    $ cp /boot/config-version .config
    $ make menuconfig
     ...
    $ make deb-pkg

| Suggerimento
Il pacchetto linux-source-versione fornisce i sorgenti del kernel Linux con le patch Debian come "`/usr/src/linux-versione.tar.bz2`".

Per compilare pacchetti binari specifici a partire dal pacchetto Debian dei sorgenti del kernel, si devono usare i target "`binary-arch_architettura_featureset_flavour`" in "`debian/rules.gen`".

    $ sudo apt-get build-dep linux
    $ apt-get source linux
    $ cd linux-3.*
    $ fakeroot make -f debian/rules.gen binary-arch_i386_none_686

Ulteriori informazioni:

- Wiki Debian: FAQ del Kernel

- Wiki Debian: Kernel Debian

- Debian Linux Kernel Handbook: https://kernel-handbook.debian.net

### 9.10.5. Driver per hardware e firmware

Un driver hardware è il codice eseguito nelle CPU principali del sistema target. La maggior parte dei driver hardware è ora disponibile come software libero ed è inclusa nei normali pacchetti Debian dei kernel nell'area `main`.

- driver GPU

  - driver GPU Intel (`main`)

  - driver GPU AMD/ATI (`main`)

  - driver GPU NVIDIA (`main` per il driver nouveau e `non-free` per i driver solo binari supportati dal produttore.

Il firmware è il codice o i dati caricati sul dispositivo attaccato al sistema target (ad esempio microcodice della CPU, codice di rendering eseguito nella GPU oppure dati FPGA/CPLD, …). Alcuni pacchetti firmware sono disponibili come software libero, ma molti pacchetti firmware non lo sono dato che contengono dati binari senza sorgenti. L'installazione di questi dati del firmware è necessaria affinché il dispositivo funzioni come atteso.

- I pacchetti dei dati del firmware contengono dati caricati nella memoria volatile nel dispositivo obiettivo.

  - firmware-linux-free (`main`)

  - firmware-linux-nonfree (`non-free-firmware`)

  - firmware-linux-* (`non-free-firmware`)

  - *-firmware (`non-free-firmware`)

  - intel-microcode (`non-free-firmware`)

  - amd64-microcode (`non-free-firmware`)

- I pacchetti dei programmi di aggiornamento del firmware che aggiornano i nella memoria non volatile del dispositivo target.

  - fwupd (`main`): demone per aggiornamento del firmware che scarica dati del firmware da Linux Vendor Firmware Service.

  - gnome-firmware (`main`): frontend GTK per fwupd

  - plasma-discover-backend-fwupd (`main`): frontend Qt per fwupd

Notare che l'accesso ai pacchetti `non-free-firmware` è fornito dai supporti ufficiali di installazione per offrire un'esperienza di installazione funzionale a partire da Debian 12 Bookworm. La sezione `non-free-firmware` è descritta in Sezione 2.1.5, «Nozioni di base sugli archivi Debian».

Notare anche che i dati di firmware che fwupd scarica da Linux Vendor Firmware Service e che sono caricati nel kernel Linux in esecuzione potrebbero essere `non-free`.

## 9.11. Sistema virtualizzato

L'uso di sistemi virtualizzati permette di eseguire più istanze di un sistema simultaneamente su un singolo hardware.

| Suggerimento
Vedere wiki Debian: SystemVirtualization.

### 9.11.1. Strumenti per virtualizzazione ed emulazione

Ci sono diversi piattaforme di strumenti per la virtualizzazione e l'emulazione.

- Pacchetti per l'emulazione hardware completa come quelli installati dal metapacchetto games-emulator.

- Emulazione per lo più a livello di CPU con alcune emulazioni di dispositivi di I/O come QEMU.

- Virtualizzazione per lo più a livello di CPU con alcune emulazioni di dispositivi di I/O come macchine virtuali basate sul Kernel (KVM).

- Virtualizzazione in contenitori a livello di SO con supporto a livello del kernel come LXC (Linux Containers), Docker, `systemd-nspawn`(1), ...

- Virtualizzazione dell'accesso al file system a livello di SO con override del percorso dei file nelle chiamate di libreria di sistema come chroot.

- Virtualizzazione dell'accesso al file system a livello di SO con override della proprietà dei file nelle chiamate di libreria di sistema come chroot.

- Emulazione delle API del SO come Wine

- Virtualizzazione a livello di interprete con selezione del suo eseguibile e override della libreria a runtime come virtualenv e venv per Python.

La virtualizzazione in contenitori usa Sezione 4.7.5, «Funzionalità di sicurezza di Linux» ed è la tecnologia che fa da backend per Sezione 7.7, «Sandbox».

Ecco alcuni pacchetti che aiutano a configurare un sistema virtualizzato.

Tabella 9.27. Elenco di strumenti di virtualizzazione

pacchetto | popcon | dimensione | descrizione
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | utilità principali di GNU che contengono `chroot`(8)
`util-linux` | V:897, I:999 | 4384 | miscellaneous system utilities which contain `unshare`(1)
`systemd-container` | V:72, I:76 | 2276 | strumenti systemd container/nspawn che contengono `systemd-nspawn`(1)
`schroot` | V:5, I:7 | 2627 | strumento specializzato per eseguire pacchetti Debian binari in chroot
`sbuild` | V:1, I:4 | 157 | strumento per compilare pacchetti Debian binari da sorgenti Debian
`debootstrap` | V:4, I:46 | 330 | avviare un sistema Debian base (scritto in sh)
`mmdebstrap` | V:5, I:10 | 574 | avviare un sistema Debian (scritto in Perl)
`cdebootstrap` | V:0, I:1 | 114 | avviare un sistema Debian (scritto in C)
`cloud-image-utils` | V:0, I:14 | 66 | utilità di gestione di immagini cloud
`cloud-guest-utils` | V:4, I:18 | 71 | utilità cloud ospiti
`virt-manager` | V:12, I:49 | 2310 | Virtual Machine Manager: applicazione desktop per gestire macchine virtuali
`libvirt-clients` | V:49, I:72 | 1155 | programmi per la libreria libvirt
`incus` | V:0, I:2 | 21 | Incus: contenitore per sistemi e gestore di macchine virtuali
`podman` | V:25, I:29 | 81828 | podman: motore per eseguire contenitori basati su OCI in Pod
`podman-docker` | V:2, I:2 | 275 | motore per eseguire contenitori basati su OCI in Pod - wrapper per docker
`docker.io` | V:44, I:47 | 95958 | docker: runtime per contenitori Linux
`games-emulator` | I:0 | 21 | games-emulator: emulatori di Debian per i giochi
`bochs` | V:0, I:0 | 8180 | Bochs: emulatore PC IA-32
`qemu-system` | I:22 | 80 | QEMU: binari per emulazione completa del sistema
`qemu-user` | V:5, I:9 | 464225 | QEMU: binari per emulazione in spazio utente
`qemu-utils` | V:14, I:109 | 12157 | QEMU: utilità
`qemu-system-x86` | V:53, I:93 | 67511 | KVM: virtualizzazione completa su hardware x86 convirtualizzazione assistita da hardware
`virtualbox` | V:3, I:4 | 151525 | VirtualBox: soluzione per virtualizzazione i dx86 su i386 e amd64
`gnome-boxes` | V:1, I:6 | 6847 | Boxes: semplice applicazione GNOME per accedere a sistemi virtuali
`xen-tools` | V:0, I:1 | 719 | strumenti per gestire server virtuali XEN Debian
`wine` | V:14, I:57 | 204 | Wine: implementazione della API Windows (suite standard)
`dosbox` | V:1, I:13 | 2697 | DOSBox: emulatore x86 con grafica Tandy/Herc/CGA/EGA/VGA/SVGA, suono e DOS
`lxc` | V:9, I:12 | 1626 | strumenti in spazio utente per contenitori Linux
`python3-venv` | V:8, I:136 | 6 | venv per creare ambienti Python virtuali (libreria di sistema)
`python3-virtualenv` | V:8, I:41 | 417 | virtualenv per creare ambienti Python virtuali isolati
`pipx` | V:7, I:43 | 3613 | pipx per installare applicazioni Python in ambienti isolati

Vedere l'articolo di Wikipedia Comparison of platform virtual machines per una comparazione dettagliata di diverse soluzioni per la virtualizzazione di piattaforme.

### 9.11.2. Fasi del processo di virtualizzazione

| Nota
I kernel Debian predefiniti hanno il supporto per KVM a partire da `lenny`.

Il tipico processo di virtualizzazione comporta diverse fasi.

- Creare un file system vuoto (un albero di file o un'immagine di disco).

  - L'albero di file può essere creato con "`mkdir -p /percorso/di/chroot`".

  - Il file immagine raw del disco può essere creato con `dd`(1) (vedere Sezione 9.7.1, «Creare un file con un'immagine di disco» e Sezione 9.7.5, «Creare un file con immagine di disco vuoto»).

  - Si può usare `qemu-img`(1) per creare e convertire file immagine di dischi supportati da QEMU.

  - I formati di file raw e VMDK possono essere usati come formati comuni tra i vari strumenti di virtualizzazione.

- Montare l'immagine del disco con `mount`(8) nel file system (opzionale).

  - Per il file immagine raw sel disco, montarlo come device loop o device mapper (vedere Sezione 9.7.3, «Montare un file con un'immagine di disco»).

  - Per le immagini disco supportate da QEMU, montarle come device a blocchi di rete (vedere Sezione 9.11.3, «Montare il file immagine di disco virtuale»).

- Popolare il file system obiettivo con i dati di sistema necessari.

  - L'uso di programmi come `debootstrap` e `cdebootstrap` aiuta questo processo (vedere Sezione 9.11.4, «Sistema chroot»).

  - Usare gli installatori di sistemi operativi nell'emulazione di sistemi completi.

- Eseguire un programma in un ambiente virtualizzato.

  - chroot fornisce un ambiente di virtualizzazione base sufficiente a compilare programmi, eseguire applicazioni in console ed eseguire demoni al suo interno.

  - QEMU fornisce emulazione di CPU inter-piattaforma.

  - QEMU con KVM fornisce una completa emulazione di sistema con virtualizzazione assistita da hardware.

  - VirtualBox fornisce una completa emulazione del sistema in i386 e amd64 con o senza virtualizzazione assistita da hardware.

### 9.11.3. Montare il file immagine di disco virtuale

Per i file immagine raw di disco, vedere Sezione 9.7, «Immagine del disco».

Per altri file immagine di dischi virtuali, si può usare `qemu-nbd`(8) per esportarli usando il protocollo per device a blocchi di rete e montarli usando il modulo `nbd` del kernel.

`qemu-nbd`(8) supporta i formati di disco supportati da QEMU: raw, qcow2, qcow, vmdk, vdi, bochs, cow (copy-on-write di user-mode Linux), parallels, dmg, cloop, vpc, vvfat (VFAT virtuale) e host_device.

I device a blocchi di rete possono supportare partizioni nello stesso modo dei device loop (vedere Sezione 9.7.3, «Montare un file con un'immagine di disco»). Si può montare la prima partizione di "`disk.img`" nel modo seguente.

    # modprobe nbd max_part=16
    # qemu-nbd -v -c /dev/nbd0 disk.img
    ...
    # mkdir /mnt/part1
    # mount /dev/nbd0p1 /mnt/part1

| Suggerimento
È possibile esportare solamente la prima partizione di "`disk.img`" usando l'opzione "`-P 1`"per `qemu-nbd`(8).

### 9.11.4. Sistema chroot

Se si desidera provare un nuovo ambiente Debian da una console in terminale, è raccomandato usare chroot. Ciò permette di eseguire applicazioni in console di Debian `unstable` e `testing` senza i consueti rischi associati e senza riavviare. `chroot`(8) è il metodo più basilare.

| Attenzione
Gli esempi seguenti presuppongono che entrambi i sistemi, quello genitore e quello chroot, condividano la stessa architettura `amd64` della CPU.

Sebbene sia possibile creare manualmente un ambiente `chroot`(8) usando `debootstrap`(1), ciò richiede un impegno non banale.

Il pacchetto sbuild per compilare pacchetti Debian da sorgenti usa l'ambiente chroot gestito dal pacchetto schroot. Viene fornito con uno script ausiliario `sbuild-createchroot`(1). Vediamo come funziona eseguendolo nel modo seguente.

    $ sudo mkdir -p /srv/chroot
    $ sudo sbuild-createchroot -v --include=eatmydata,ccache unstable /srv/chroot/unstable-amd64-sbuild http://deb.debian.org/debian
     ...

Si può vedere come `debootstrap`(8) popoli i dati di sistema per l'ambiente `unstable` sotto "`/srv/chroot/unstable-amd64-sbuild`" per un sistema di compilazione minimale.

Si può fare il login in questo ambiente usando `schroot`(1).

    $ sudo schroot -v -c chroot:unstable-amd64-sbuild

Si può vedere come venga creata una shell di sistema in esecuzione nell'ambiente `unstable`.

| Nota
Il file "`/usr/sbin/policy-rc.d`" che termina sempre con 101 evita che, in un sistema Debian, i programmi demone vengano avviati automaticamente. Vedere "`/usr/share/doc/init-system-helpers/README.policy-rc.d.gz`".

| Nota
Alcuni programmi in chroot per funzionare possono aver bisogno dell'accesso a più file nel sistema genitore di quanti ne fornisca `sbuild-createchroot`. Per esempio, può essere necessario montare con bind o copiare "`/sys`", "`/etc/passwd`", "`/etc/group`", "`/var/run/utmp`", "`/var/log/wtmp`", ecc.

| Suggerimento
Il pacchetto `sbuild` aiuta a costruire un sistema chroot e compila un pacchetto dentro la chroot usando `schroot` come suo backend. È un sistema ideale per controllare le dipendenze di compilazione. Vedere ulteriori dettagli su sbuild nel wiki Debian e l'esempio di configurazione di sbuild nella "Guida per il Manutentore Debian".

| Suggerimento
Il comando `systemd-nspawn`(1) aiuta ad eseguire un comando o un sistema operativo in un contenitore leggero in modo simile a `chroot`. È più potente dato che usa gli spazi dei nomi per virtualizzare completamente l'albero dei processi, IPC, nome host, nome di dominio e, opzionalmente, la rete e i database degli utenti. Vedere systemd-nspawn.

### 9.11.5. Sistemi desktop multipli

Se si desidera provare un nuovo ambiente desktop con GUI per qualsiasi SO, l'autore raccomanda l'uso di QEMU o KVM in un sistema Debian `stable` per eseguire sistemi desktop multipli in maniera sicura usando la virtualizzazione. Permettono di eseguire qualsiasi applicazione desktop, incluse quelle di Debian `unstable` e `testing`, senza i consueti rischi ad esse associati e senza riavviare.

Dato che QEMU puro è molto lento, è raccomandata la sua velocizzazione con KVM quando il sistema host lo permette.

Virtual Machine Manager noto anche come `virt-manager` è un comodo strumento GUI per gestire macchine virtuali KVM con libvirt.

L'immagine disco virtuale "`virtdisk.qcow2`" contenente un sistema Debian per QEMU si può creare con i piccoli CD dell'installatore Debian nel modo seguente.

    $ wget https://cdimage.debian.org/debian-cd/5.0.3/amd64/iso-cd/debian-503-amd64-netinst.iso
    $ qemu-img create -f qcow2 virtdisk.qcow2 5G
    $ qemu -hda virtdisk.qcow2 -cdrom debian-503-amd64-netinst.iso -boot d -m 256
    ...

| Suggerimento
Eseguire altre distribuzioni GNU/Linux come Ubuntu e Fedora in una virtualizzazione è un ottimo metodo per imparare trucchetti di configurazione. Anche altri sistemi operativi proprietari possono essere eseguiti tranquillamente in queste virtualizzazioni GNU/Linux.

Vedere ulteriori suggerimenti in wiki Debian: SystemVirtualization.

[2] Esempi di personalizzazione più elaborati: "Vim Galore", "sensible.vim", ...

[3] vim-pathogen era popolare.

Capitolo 8. I18N e L10N |  | Capitolo 10. Gestione dei dati