Capitolo 9. Suggerimenti per il sistema

Indice

9.1. Suggerimenti per la console
9.1.1. Registrare le attività della shell in modo pulito
9.1.2. Il programma screen
9.1.3. Navigare nelle directory
9.1.4. Wrapper per readline
9.1.5. Strumenti per la fusione di codice sorgente
9.2. Personalizzare vim
9.2.1. Personalizzare vim con le funzionalità interne
9.2.2. Personalizzare vim con pacchetti esterni
9.3. Registrazione e presentazione di dati
9.3.1. Demoni di registro
9.3.2. Analizzatori di registro
9.3.3. Visualizzazione personalizzata di dati di testo
9.3.4. Visualizzazione personalizzata di date e orari
9.3.5. Output colorato per la shell
9.3.6. Comandi colorati
9.3.7. Registrare le attività dell'editor per ripetizioni complesse
9.3.8. Registrare l'immagine grafica di un'applicazione X
9.3.9. Registrare i cambiamenti a file di configurazione
9.4. Monitorare, controllare ed avviare l'attività dei programmi
9.4.1. Cronometrare un processo
9.4.2. Priorità di schedulazione
9.4.3. Il comando ps
9.4.4. Il comando top
9.4.5. Elencare i file aperti da un processo
9.4.6. Tenere traccia delle attività di un programma
9.4.7. Identificazione di processi in base a file o socket
9.4.8. Ripetere un comando ad intervalli costanti
9.4.9. Ripetere un comando su diversi file
9.4.10. Avviare un programma dalla GUI
9.4.11. Personalizzare i programmi da avviare
9.4.12. Uccidere un processo
9.4.13. Pianificare compiti da eseguire una volta sola
9.4.14. Pianificare compiti in modo regolare
9.4.15. Pianificare compiti da eseguire in caso di un evento
9.4.16. Tasto Alt-SysRq
9.5. Suggerimenti per l'amministrazione del sistema
9.5.1. Chi è nel sistema?
9.5.2. Avvertire tutti gli utenti
9.5.3. Identificazione dell'hardware
9.5.4. Configurazione dell'hardware
9.5.5. Orario di sistema e hardware
9.5.6. Configurazione del terminale
9.5.7. L'infrastruttura audio
9.5.8. Disabilitare il salvaschermo
9.5.9. Disabilitare i bip sonori
9.5.10. Uso della memoria
9.5.11. Verifica della sicurezza e dell'integrità del sistema
9.6. Suggerimenti per l'archiviazione dei dati
9.6.1. Uso dello spazio su disco
9.6.2. Configurazione del partizionamento dei dischi
9.6.3. Accedere alle partizioni usando UUID
9.6.4. LVM2
9.6.5. Configurazione del file system
9.6.6. Creare file system e verificarne l'integrità
9.6.7. Ottimizzare il file system con opzioni di mount
9.6.8. Ottimizzare il file system tramite il superblocco
9.6.9. Ottimizzare il disco rigido
9.6.10. Ottimizzare le unità a stato solido
9.6.11. Usare SMART per prevedere danni ai dischi fissi
9.6.12. Specificare una directory per l'archiviazione di dati temporanei usando $TMPDIR
9.6.13. Espandere lo spazio di archiviazione utilizzabile con LVM
9.6.14. Espandere lo spazio di archiviazione utilizzabile montando un'altra partizione
9.6.15. Espandere lo spazio di archiviazione utilizzabile montando un collegamento ad un'altra directory
9.6.16. Espandere lo spazio di archiviazione utilizzabile montando un'altra directory da sovrapporre
9.6.17. Espandere lo spazio di archiviazione utilizzabile usando collegamenti simbolici
9.7. Immagine del disco
9.7.1. Creare un file con un'immagine di disco
9.7.2. Scrivere direttamente sul disco
9.7.3. Montare un file con un'immagine di disco
9.7.4. Pulire un file con un'immagine di disco
9.7.5. Creare un file con immagine di disco vuoto
9.7.6. Creare un file con un'immagine ISO9660
9.7.7. Scrivere direttamente sul CD/DVD-R/RW
9.7.8. Montare un file con un'immagine ISO9660
9.8. I dati binari
9.8.1. Visualizzare e modificare dati binari
9.8.2. Manipolare file senza montare i dischi
9.8.3. Dati ridondanti
9.8.4. recupero di file dati ed analisi forensi
9.8.5. Suddividere un file grande in file più piccoli
9.8.6. Pulire il contenuto di file
9.8.7. File fittizi
9.8.8. Cancellare un intero disco fisso
9.8.9. Cancellare area inutilizzate di un disco fisso
9.8.10. De-cancellare file cancellati ma ancora aperti
9.8.11. Cercare tutti i collegamenti fisici
9.8.12. Consumo invisibile dello spazio su disco
9.9. Suggerimenti per la cifratura dei dati
9.9.1. Cifratura di dischi removibili con dm-crypt/LUKS
9.9.2. Montare dischi removibili con dm-crypt/LUKS
9.10. Il kernel
9.10.1. Parametri del kernel
9.10.2. Header del kernel
9.10.3. Compilare il kernel ed i moduli relativi
9.10.4. Compilare i sorgenti del kernel: il metodo raccomandato dal Team del Kernel di Debian
9.10.5. Driver per hardware e firmware
9.11. Sistema virtualizzato
9.11.1. Strumenti per virtualizzazione ed emulazione
9.11.2. Fasi del processo di virtualizzazione
9.11.3. Montare il file immagine di disco virtuale
9.11.4. Sistema chroot
9.11.5. Sistemi desktop multipli

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

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


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.

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


Vedere screen(1) per i dettagli.

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

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.

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.

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
"colorscheme default
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

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

[Attenzione] 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\+\%#\@<!$/

Pacchetti per plugin esterni interessanti possono essere trovati in:

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.


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] Suggerimento

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

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'").


[Suggerimento] 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'

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}"

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

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:880, I:999 18307 nice(1): esegue un programma con priorità di schedulazione modificata
bsdutils V:519, I:999 356 renice(1): modifica la priorità di schedulazione di un processo in esecuzione
procps V:766, I:999 2389 utilità per il file system "/proc": ps(1), top(1), kill(1), watch(1), …
psmisc V:420, I:775 908 utilità per il file system "/proc": killall(1), fuser(1), peekfd(1), pstree(1)
time V:7, I:132 129 time(1): esegue un programma per riportare l'uso delle risorse di sistema in funzione del tempo
sysstat V:148, I:170 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:422, I:945 482 lsof(8): elenca, usando l'opzione "-p", i file aperti da un processo in esecuzione
strace V:12, I:119 2897 strace(1): traccia le chiamate e i segnali di sistema
ltrace V:0, I:16 330 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:18, I:217 677 powertop(1): informazioni sull'uso dell'alimentazione da parte del sistema
cron V:872, I:995 244 esegue processi dal demone cron(8) sullo sfondo in base ad una pianificazione
anacron V:396, I:479 93 pianificatore di comandi in stile cron, per i sistemi che non sono in esecuzione 24 ore al giorno
at V:101, I:154 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] Suggerimento

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

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

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

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.

L'ambiente desktop imposta le variabili d'ambiente $XDG_DATA_HOME e $XDG_DATA_DIR. Per esempio, in GNOME 3:

  • $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] Suggerimento

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

[Suggerimento] Suggerimento

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

[Suggerimento] 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] 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).

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

[Suggerimento] Suggerimento

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

[Suggerimento] 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] 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

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] 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] 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) .

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.

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


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

[Suggerimento] 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)

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.


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

[Suggerimento] Suggerimento

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

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] Suggerimento

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

Vedere la documentazione seguente.

[Suggerimento] Suggerimento

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

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] Suggerimento

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

[Suggerimento] 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.


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.


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

L'avvio del sistema con un CD live Linux o un CD del debian-installer in modalità ripristino rende semplice la riconfigurazione dell'archiviazione dei dati sul dispositivo di avvio.

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.

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.


[Attenzione] 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] 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.

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

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.


[Suggerimento] 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»).

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.

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/hda".

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

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

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

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.

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

Questa sezione tratta della manipolazione di immagini di dischi.

Si può creare un file di immagine del disco, "disco.img", di un dispositivo non montato, ad esempio la seconda unità SCSI o serial ATA "/dev/sdb" usando cp(1) o dd(1) nel modo seguente.

# cp /dev/sdb disk.img
# dd if=/dev/sdb of=disk.img

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/hda of=mbr.img bs=512 count=1
# dd if=/dev/hda of=mbr-nopart.img bs=446 count=1
# dd if=/dev/hda 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 il disco di avvio è un un dispositivo SCSI o serial ATA, sostituire "/dev/hda" con "/dev/sda".

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

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

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

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

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

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.


[Attenzione] 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] 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] Suggerimento

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

Si può cifrare il contenuto di dispositivi di memorizzazione di massa removibili, ad esempio una chiavetta USB in "/dev/sdx", usando dm-crypt/LUKS. Formattarla semplicemente nel modo seguente.

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

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.

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


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

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.

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

[Suggerimento] Suggerimento

Vedere wiki Debian: SystemVirtualization.

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:880, I:999 18307 utilità principali di GNU che contengono chroot(8)
systemd-container V:53, I:61 1330 strumenti systemd container/nspawn che contengono systemd-nspawn(1)
schroot V:5, I:7 2579 strumento specializzato per eseguire pacchetti Debian binari in chroot
sbuild V:1, I:3 243 strumento per compilare pacchetti Debian binari da sorgenti Debian
debootstrap V:5, I:54 314 avviare un sistema Debian base (scritto in sh)
cdebootstrap V:0, I:1 115 avviare un sistema Debian (scritto in C)
cloud-image-utils V:1, I:17 66 utilità di gestione di immagini cloud
cloud-guest-utils V:3, I:13 71 utilità cloud ospiti
virt-manager V:11, I:44 2296 Virtual Machine Manager: applicazione desktop per gestire macchine virtuali
libvirt-clients V:46, I:65 1241 programmi per la libreria libvirt
incus V:0, I:0 56209 Incus: contenitore per sistemi e gestore di macchine virtuali (per Debian 13 "Trixie")
lxd V:0, I:0 52119 LXD: contenitore per sistemi e gestore di macchine virtuali (per Debian 12 "Bookworm")
podman V:14, I:16 41948 podman: motore per eseguire contenitori basati su OCI in Pod
podman-docker V:0, I:0 249 motore per eseguire contenitori basati su OCI in Pod - wrapper per docker
docker.io V:41, I:43 150003 docker: runtime per contenitori Linux
games-emulator I:0 21 games-emulator: emulatori di Debian per i giochi
bochs V:0, I:0 6956 Bochs: emulatore PC IA-32
qemu I:14 97 QEMU: veloce emulatore generico di processore
qemu-system I:22 66 QEMU: binari per emulazione completa del sistema
qemu-user V:1, I:6 93760 QEMU: binari per emulazione in spazio utente
qemu-utils V:12, I:106 10635 QEMU: utilità
qemu-system-x86 V:33, I:91 58140 KVM: virtualizzazione completa su hardware x86 convirtualizzazione assistita da hardware
virtualbox V:6, I:8 130868 VirtualBox: soluzione per virtualizzazione i dx86 su i386 e amd64
gnome-boxes V:1, I:7 6691 Boxes: semplice applicazione GNOME per accedere a sistemi virtuali
xen-tools V:0, I:2 719 strumenti per gestire server virtuali XEN Debian
wine V:13, I:60 132 Wine: implementazione della API Windows (suite standard)
dosbox V:1, I:15 2696 DOSBox: emulatore x86 con grafica Tandy/Herc/CGA/EGA/VGA/SVGA, suono e DOS
lxc V:9, I:12 25890 strumenti in spazio utente per contenitori Linux
python3-venv I:88 6 venv per creare ambienti Python virtuali (libreria di sistema)
python3-virtualenv V:9, I:50 356 virtualenv per creare ambienti Python virtuali isolati
pipx V:3, I:19 3324 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.

[Nota] Nota

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

Il tipico processo di virtualizzazione comporta diverse fasi.

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; QEMU supporta i seguenti formati di dischi: 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] Suggerimento

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

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

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