Kapitel 9. Systemtipps

# Kapitel 9. Systemtipps

Hier beschreibe ich einige grundlegende Tipps zur Konfiguration und Verwaltung des Systems, überwiegend für die Konsole.

## 9.1. Tipps für die Konsole

Es gibt einige Hilfsprogramme, die Sie bei Ihren Konsolenaktivitäten unterstützen können:

Tabelle 9.1. Liste von Programmen für Konsolenaktivitäten

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`mc` | V:43, I:183 | 1590 | siehe Abschnitt 1.3, „Midnight Commander (MC)“
`bsdutils` | V:439, I:999 | 335 | `script`(1)-Befehl, um eine Aufzeichnung von einer Terminal-Sitzung zu erstellen
`screen` | V:54, I:199 | 1006 | Terminal-Multiplexer mit VT100-/ANSI-Terminal-Emulation
`tmux` | V:79, I:153 | 1292 | Terminal-Multiplexer-Alternative (verwenden Sie "Strg-B")
`fzf` | V:8, I:31 | 4651 | Unschärfe-Textsuch-Programm
`fzy` | V:0, I:0 | 59 | Unschärfe-Textsuch-Programm
`rlwrap` | V:1, I:12 | 328 | Befehlszeilen-Wrapper mit readline-Funktionalität
`ledit` | V:0, I:8 | 375 | Befehlszeilen-Wrapper mit readline-Funktionalität
`rlfe` | V:0, I:0 | 45 | Befehlszeilen-Wrapper mit readline-Funktionalität
`ripgrep` | V:9, I:30 | 5342 | schnelle rekursive Textsuche für Quellcode-Bäume mit automatischer Filterung

### 9.1.1. Shell-Aktivitäten sauber aufzeichnen

Die schlichte Verwendung von `script`(1) wie in Abschnitt 1.4.9, „Aufzeichnen der Shell-Aktivitäten“ erzeugt eine Datei mit Steuerzeichen. Sie können dies durch Nutzung von `col`(1) wie folgt beheben:

    $ script
    Script started, file is typescript

Machen Sie irgendetwas … und drücken Sie `Strg-D`, um `script` zu beenden.

    $ col -bx < typescript > cleanedfile
    $ vim cleanedfile

Es gibt alternative Methoden, um Shell-Aktivitäten aufzuzeichnen:

- Verwendung von `tee` (auch verwendbar während des Boot-Vorgangs in der initramfs):

      $ sh -i 2>&1 | tee typescript

- Verwendung von `gnome-terminal` erweitertem Zeilenpuffer, um zurückscrollen zu können.

- Verwendung von `screen` mit "`^A H`" (siehe Abschnitt 9.1.2, „Das Programm screen“), um eine Konsolensitzung aufzuzeichnen.

- Verwendung von `vim` mit "`:terminal`", um in den Terminal-Modus zu wechseln. (Mit "`Ctrl-W N`" kommen Sie vom Terminal-Modus zurück in den Normalmodus.) Geben Sie "`:w typescript`" ein, um den Puffer in eine Datei zu schreiben.

- Verwendung von `emacs` mit "`M-x shell`", "`M-x eshell`" oder "`M-x term`", um eine Konsolensitzung aufzuzeichnen. Um den Puffer in eine Datei zu schreiben, verwenden Sie "`C-x C-w`".

### 9.1.2. Das Programm screen

`screen`(1) bietet nicht nur die Möglichkeit, in einem Terminal-Fenster mehrere Prozesse laufen zu lassen, sondern erlaubt auch einem Remote-Shell-Prozess, Verbindungsunterbrechungen zu überstehen. Hier ein typisches Anwendungsszenario für `screen`(1):

1. Sie melden sich auf einer fernen Maschine an.

2. Sie starten `screen` auf einer einfachen Konsole.

3. Sie führen mehrere Programme in `screen`-Fenstern aus, die Sie über `^A c` ("Strg-A" gefolgt von "c") erzeugen.

4. Sie können mittels `^A n` ("Strg-A" gefolgt von "n") zwischen den verschiedenen `screen`-Fenstern hin- und herschalten.

5. Plötzlich müssen Sie Ihr Terminal verlassen, aber Sie möchten Ihre aktuelle Arbeit nicht verlieren und deshalb die Verbindung erhalten.

6. Sie können die Verbindung zur `screen`-Sitzung durch eine der folgenden Methoden lösen:

   - Ganz brutal: die Netzwerkverbindung trennen;

   - Tippen Sie `^A d` ("Strg-A" gefolgt von "d") und melden Sie sich händisch von der Fernverbindung ab;

   - Tippen Sie `^A DD` ("Strg-A" gefolgt von "DD"), damit `screen` die Verbindung löst und Sie abmeldet.

7. Sie melden Sich am gleichen fernen Rechner erneut an (funktioniert sogar bei Anmeldung über ein anderes Terminal).

8. Sie starten `screen` über "`screen -r`".

9. `screen` verbindet ganz von selbst alle vorherigen `screen`-Fenster mit allen aktuell laufenden Programmen.

| Tipp
Bei Verbindungen, die über Zeit oder Volumen abgerechnet werden, können Sie mit `screen` Kosten sparen, indem Sie einen Prozess aktiv laufen lassen, während die Verbindung aber unterbrochen ist, und die Sitzung später erneut verbinden, wenn Sie sich wieder einwählt haben.

In einer `screen`-Sitzung werden alle Tastatureingaben zu Ihrem aktuell laufenden screen-Fenster gesendet, außer Befehlseingaben. Alle `screen`-Befehlseingaben werden mittels `^A` ("Strg-A") plus einer einzelnen Taste [plus eventuellen Parametern] eingegeben. Hier einige wichtige zur Erinnerung:

Tabelle 9.2. Liste von Tastaturkürzeln für screen

Tastaturbefehl | Bedeutung
--- | ---
`^A ?` | eine Hilfe anzeigen (Tastaturkürzel anzeigen)
`^A c` | ein neues Fenster erstellen und dorthin wechseln
`^A n` | zu nächstem Fenster wechseln
`^A p` | zu vorherigem Fenster wechseln
`^A 0` | zu Fenster Nr. 0 wechseln
`^A 1` | zu Fenster Nr. 1 wechseln
`^A w` | eine Liste vorhandener Fenster anzeigen
`^A a` | ein Strg-A als Tastatureingabe an das aktuelle Fenster senden
`^A h` | Hardcopy des aktuellen Fensters in eine Datei schreiben
`^A H` | Starten/stoppen des Aufzeichnens vom aktuellen Fenster in eine Datei
`^A ^X` | Terminal sperren (Passwort-geschützt)
`^A d` | Verbindung der screen-Sitzung zum Terminal lösen
`^A DD` | Verbindung der screen-Sitzung lösen und abmelden

Lesen Sie `screen`(1) bezüglich weiterer Details.

Lesen Sie `tmux`(1) für Funktionalitäten einer Alternative zum Befehl screen.

### 9.1.3. Durch Verzeichnisse navigieren

In Abschnitt 1.4.2, „Anpassen der bash“ finden Sie 2 Tipps, die eine schnelle Navigation durch Verzeichnisse ermöglichen: `$CDPATH` und `mc`.

Wenn Sie einen Unschärfe-Textfilter verwenden, müssen Sie dabei nicht einmal den exakten Pfad angeben. Für `fzf` geben Sie dazu folgendes in `~/.bashrc` ein:

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

Beispiele:

- Sie können mit minimalem Aufwand in ein sehr tief verschachteltes Unterverzeichnis springen. Zunächst geben Sie "`cd **`" ein und drücken `Tab`. Es werden Ihnen jetzt die in Frage kommenden Pfade angezeigt. Durch Eingabe von Teilen des Pfads, z.B. `s/d/b foo`, schränken Sie die Kandidaten weiter ein. Den gewünschten Pfad wählen Sie mittels `cd` und Pfeil-/Entertasten aus.

- Sie können ganz einfach und effizient einen Befehl aus der Befehlshistorie aufrufen. Drücken Sie dazu am Eingabe-Prompt `Strg-R`. Es werden Ihnen die in Frage kommenden Befehle angezeigt. Durch Eingabe von Teilen des Befehls, z.B. `vim d`, schränken Sie die Kandidaten weiter ein. Den gewünschten Befehl wählen Sie mittels Pfeil-/Entertasten aus.

### 9.1.4. Readline-Wrapper

Einige Befehle wie z.B. `/usr/bin/dash`, die nicht die Fähigkeit zum Editieren der Befehlshistorie haben, können diese Fähigkeit trotzdem erlangen, indem sie mittels `rlwrap` (oder seinen Äquivalenten) ausgeführt werden.

     $ rlwrap dash -i

Dies bietet eine komfortable Plattform, um gewisse Dinge mit `dash` zu testen mit dem Komfort einer `bash`-ähnlichen Umgebung.

### 9.1.5. Durchsuchen eines Quellcode-Baums

Der Befehl `rg`(1) aus dem `ripgrep`-Paket ist eine schnellere Alternative zu `grep`(1) zum Durchsuchen eines Quellcode-Baums nach typischen Situationen. Er nutzt die Vorteile moderner Multi-Kern-CPUs und wendet bei einigen Dateien automatisch passende Filter an.

## 9.2. Anpassen von vim

Nachdem Sie die Grundlagen von `vim`(1) in Abschnitt 1.4.8, „Verwenden von vim“ kennengelernt haben, lesen Sie bitte Bram Moolenaars "Seven habits of effective text editing (2000)", um zu verstehen, wie `vim` genutzt werden sollte.

### 9.2.1. Anpassen von vim mit internen Funktionalitäten

Das Verhalten von `vim` kann signifikant verändert werden, indem über `Ex`-Modus-Befehle interne Funktionalitäten aktiviert werden, wie z.B. "`set ...`" zum Setzen von vim-Optionen.

Diese `Ex`-Modus-Befehle können in der vimrc-Datei des Benutzers (traditionell "`~/.vimrc`", oder auch git-freundlich "`~/.vim/vimrc`") eingefügt werden. Hier ein einfaches Beispiel [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

Die Tastenbelegung von `vim` kann in der vimrc-Datei des Benutzers geändert werden. Z.B.:

| Achtung
Versuchen Sie nicht ohne guten Grund, die Standard-Tastaturkürzel zu ändern.

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

Damit die oben aufgeführten Tastaturkürzel korrekt funktionieren, muss das Terminal-Programm so konfiguriert sein, dass es "ASCII DEL" für die `Backspace`-Taste und "Escape sequence" für die `Entf`-Taste generiert.

Weitere Konfigurationsparameter können in der vimrc-Datei des Benutzers angepasst werden. Z.B.:

    """ 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. Anpassen von vim mit externen Paketen

Interessante externe Plugin-Pakete finden Sie unter:

- Vim - the ubiquitous text editor -- Die offizielle Upstream-Seite von Vim und Vim-Scripten

- VimAwsome -- Auflistung von Vim-Plugins

- vim-scripts -- Debian-Paket: eine Sammlung von Vim-Scripten

Plugin-Pakete aus dem vim-scripts-Paket können über die vimrc-Datei des Benutzers aktiviert werden. Z.B.:

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

Das neue native Vim-Paketsystem funktioniert sehr gut mit "`git`" und "`git submodule`". Eine solche Beispielkonfiguration finden Sie in meinem git-Repository: dot-vim. Was sie bewirkt, ist letztlich:

- Durch Verwenden von "`git`" und "`git submodule` werden die aktuellsten externen Pakete in `~/.vim/pack/*/opt/` abgelegt, z.B. für "`name`" in `~/.vim/pack/*/opt/name`, und entsprechend für andere Pakete.

- Indem eine `:packadd! name`-Zeile zur vimrc-Datei des Benutzers hinzugefügt wird, werden die entsprechenden Pakete im `runtimepath` abgelegt.

- Vim lädt diese Pakete während der Initialisierung aus dem `runtimepath`.

- Am Ende der Initialisierung werden die Marker (Tags) für die installierten Dokumente mit "`helptags ALL`" aktualisiert.

Wenn Sie es genauer wissen möchten, starten Sie `vim` mit "`vim --startuptime vimstart.log`", um die aktuell ausgeführte Startsequenz sowie die für jeden Schritt benötigte Zeit kontrollieren zu können.

Es kann sehr verwirrend sein, wenn es zu viele Wege [3] für die Verwaltung und das Herunterladen externer `vim`-Pakete gibt. Sich an die Original-Informationen zu halten, ist dann die beste Hilfe.

Tabelle 9.3. Informationen zur Initialisierung von `vim`

Tastatureingabe | Information
--- | ---
`:help package` | Erklärung zum Vim-Paket-Mechanismus
`:help runtimepath` | Erklärung zum `runtimepath`-Mechanismus
`:version` | interner Status inklusive Kandidaten für die vimrc-Datei
`:echo $VIM` | die Umgebungsvariable "`$VIM`", die verwendet wird, um die vimrc-Datei zu finden
`:set runtimepath?` | Liste der Verzeichnisse, die auf der Suche nach runtime-Support-Dateien durchsucht werden
`:echo $VIMRUNTIME` | die Umgebungsvariable "`$VIMRUNTIME`", die verwendet wird, um verschiedene (vom System bereitgestellte) Runtime-Support-Dateien zu finden

## 9.3. Datenaufzeichnung und -darstellung

### 9.3.1. Der log-Daemon

Viele traditionelle Programme zeichnen ihre Aktivitäten als Textdatei im "`/var/log/`"-Verzeichnis auf.

`logrotate`(8) wird verwendet, um die Administration der Logdateien auf Systemen zu vereinfachen, die viele solcher Logdateien erzeugen.

Viele neue Programme hingegen zeichnen ihre Aktivitäten in binärem Format mittels dem Journal-Service `systemd-journald`(8) im Verzeichnis "`/var/log/journal`" auf.

Sie können Logdaten von einem Shell-Skript zum `systemd-journald`(8)-Journal hinzufügen, indem Sie den `systemd-cat`(1)-Befehl nutzen.

Lesen Sie dazu Abschnitt 3.5, „Die Systemmeldungen“ und Abschnitt 3.4, „Die Kernel-Meldungen“.

### 9.3.2. Analyseprogramme für Logdateien

Hier eine Liste erwähnenswerter Analyseprogramme für Logdateien ("`~Gsecurity::log-analyzer`" in `aptitude`(8)):

Tabelle 9.4. Liste von System-Log-Analyzern

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`logwatch` | V:9, I:10 | 2435 | Log-Analysator mit netter Ausgabe, geschrieben in Perl
`fail2ban` | V:95, I:106 | 2191 | IP-Adressen sperren, die vielfache Authentifizierungsfehler verursachen
`analog` | V:3, I:88 | 3739 | Webserver-Log-Analysator
`awstats` | V:5, I:8 | 6935 | leistungsfähiger und mit vielen Funktionen ausgestatteter Webserver-Log-Analysator
`sarg` | V:0, I:0 | 863 | Analysereportgenerator für Squid
`pflogsumm` | V:1, I:3 | 170 | Programm zur Zusammenfassung von Postfix-Logeinträgen
`fwlogwatch` | V:0, I:0 | 487 | Firewall-Log-Analysator
`squidview` | V:0, I:0 | 189 | Programm zum Beobachten und Analysieren von Squid-access.log-Dateien
`swatch` | V:0, I:0 | 99 | Logdatei-Betrachter mit Unterstützung für reguläre Ausdrücke, Hervorhebung und Einsprungstellen
`crm114` | V:0, I:0 | 1371 | Programm zur flexiblen Einordnung von E-Mails und anderen Daten (CRM114)
`icmpinfo` | V:0, I:0 | 42 | Programm zur Interpretation von ICMP-Nachrichten

| Anmerkung
CRM114 bietet eine Sprachinfrastruktur, um Unschärfe-Filter (fuzzy filters) mittels der TRE-regex-Bibliothek zu erstellen. Ein populärer Anwendungsfall ist der Spam-Mail-Filter, aber es kann auch als Log-Analysator verwendet werden.

### 9.3.3. Angepasste Anzeige von Textdaten

Obwohl Pager wie `more`(1) und `less`(1) (lesen Sie dazu Abschnitt 1.4.5, „Der Pager“) sowie spezielle Werkzeuge für Hervorhebung und Formatierung (Näheres dazu in Abschnitt 11.1.8, „Hervorheben und Formatieren von reinen Textdaten“) Text gut anzeigen können, sind normale Texteditoren (Details in Abschnitt 1.4.6, „Der Texteditor“) vielseitiger und besser anzupassen.

| Tipp
Bei `vim`(1) und seinem Pager-Modus alias `view`(1) wird über "`:set hls`" die Suche mit Hervorhebung aktiviert.

### 9.3.4. Angepasste Anzeige von Datum und Uhrzeit

Das Standard-Anzeigeformat von Datum und Uhrzeit bei dem Befehl "`ls -l`" hängt vom gewählten Gebietsschema (locale) ab (siehe dazu auch Abschnitt 1.2.6, „Zeitstempel“). Die Variable "`$LANG`" wird als erstes abgefragt, der Wert kann jedoch mittels der "`$LC_TIME`"- oder "`$LC_ALL`"-Variable überschrieben werden.

Das letztlich verwendete Anzeigeformat für das jeweilige Gebietsschema hängt von der verwendeten Standard-C-Bibliothek (aus dem `libc6`-Paket) ab. Aufgrunddessen hatten verschiedene Debian-Veröffentlichungen unterschiedliche Standardeinstellungen. Bezüglich der ISO-Formate besuchen Sie ISO 8601.

Wenn Sie das Anzeigeformat von Datum und Uhrzeit wirklich über die locale-Einstellung hinaus anpassen möchten, sollten Sie die Option time style value setzen, entweder über das "`--time-style`"-Argument oder über den Wert der Variable "`$TIME_STYLE`" (Näheres unter `ls`(1), `date`(1) und "`info coreutils 'ls invocation'`").

Tabelle 9.5. Anzeigebeispiele von Datum und Uhrzeit für den Befehl "`ls -l`" mit time style value-Einstellung

time style value | Locale | Anzeige von Datum und Uhrzeit
--- | --- | ---
`iso` | alle | `01-19 00:15`
`long-iso` | alle | `2009-01-19 00:15`
`full-iso` | alle | `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` | alle | `19.01.09 00:15`
`+%d.%b.%y %H:%M` | `C` oder `en_US.UTF-8` | `19.Jan.09 00:15`
`+%d.%b.%y %H:%M` | `es_ES.UTF-8` | `19.ene.09 00:15`

| Tipp

Sie können die Eingabe langer Optionsparameter auf der Befehlszeile vermeiden, indem sie einen Befehls-Alias verwenden (siehe Abschnitt 1.5.9, „Befehls-Alias“):

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

### 9.3.5. Farbige Shell-Ausgabe

Die Shell-Ausgabe der meisten modernen Terminals kann über ANSI-Escape-Codes farbig gestaltet werden (lesen Sie dazu auch "`/usr/share/doc/xterm/ctlseqs.txt.gz`").

Probieren Sie zum Beispiel folgendes:

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

### 9.3.6. Farbige Befehle

Farbige Befehle sind praktisch, um deren Ausgabe in einer interaktiven Umgebung zu kontrollieren. Ich habe Folgendes in meiner "`~/.bashrc`":

    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

Die Verwendung von Befehls-Alias beschränkt die Farbeffekte auf interaktive Befehlseingaben. Dies ist ein Vorteil gegenüber dem Exportieren der Umgebungsvariablen ("`export GREP_OPTIONS='--color=auto'`"), da die Farben auch in Pager-Programmen wie `less`(1) sichtbar sind. Falls Sie die Farbeffekte bei Weiterleitung zu anderen Programmen deaktivieren möchten, nutzen Sie stattdessen "`--color=auto`" in dem obigen Beispiel für die "`~/.bashrc`".

| Tipp
Sie können die Farb-Alias in der interaktiven Umgebung ausschalten, indem Sie die Shell mit "`TERM=dumb bash`" starten.

### 9.3.7. Aufzeichnen von Editor-Aktivitäten für komplexe Wiederholungen

Sie können Editor-Aktivitäten aufzeichnen, um sie später für komplexe Wiederholungen wiederzuverwenden.

Bei Vim wie folgt:

- "`qa`": Aufnahme der eingegebenen Zeichen in das Register "`a`" starten;

- … Editor-Aktivitäten;

- "`q`": Aufnahme der eingegebenen Zeichen beenden;

- "`@a`": Ausführen des Inhalts von Register "`a`".

Bei Emacs wie folgt:

- "`C-x (`": Definition eines Tastaturmakros starten;

- … Editor-Aktivitäten;

- "`C-x )`": Definition des Tastaturmakros beenden;

- "`C-x e`": Ausführen des Tastaturmakros.

### 9.3.8. Die Bildschirmanzeige einer X-Anwendung aufzeichnen

Es gibt mehrere Wege, die Anzeige einer X-Anwendung aufzuzeichnen, inklusive eines `xterm`-Displays:

Tabelle 9.6. Liste von Werkzeugen zur Bildbearbeitung

Paket | Popcon | Größe | Umgebung | Befehl
--- | --- | --- | --- | ---
`gnome-screenshot` | V:13, I:111 | 1115 | Wayland | Bildschirmfoto-Applikation für GNOME
`flameshot` | V:7, I:17 | 3532 | Wayland | Bildschirmfoto-Applikation auf Steroid
`gimp` | V:35, I:229 | 31748 | Wayland + X | Bildschirmfoto im GUI-Menü
`x11-apps` | V:33, I:464 | 2461 | X | `xwd`(1)
`imagemagick` | I:290 | 77 | X | `import`(1)
`scrot` | V:4, I:53 | 141 | X | `scrot`(1)

### 9.3.9. Aufzeichnen von Änderungen in Konfigurationsdateien

Es gibt spezielle Werkzeuge, um Änderungen in Konfigurationsdateien mit Hilfe von DVCS-Systemen aufzuzeichnen sowie System-Schnappschüsse mittels Btrfs zu erstellen:

Tabelle 9.7. Liste von Paketen zur Aufzeichnung der Konfigurations-Historie

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`etckeeper` | V:24, I:27 | 157 | Konfigurationsdateien und deren Metadaten mit Git (Standard), Mercurial oder GNU Bazaar abspeichern
`timeshift` | V:7, I:13 | 4481 | Werkzeug zur Systemwiederherstellung mittels rsync oder BTRFS-Schnappschüssen
`snapper` | V:6, I:8 | 2410 | Verwaltungswerkzeug für Linux-Dateisystem-Schnappschüsse

Sie könnten auch den Ansatz über ein lokales Skript wie in Abschnitt 10.2.3, „Backup-Tipps“ in Erwägung ziehen.

## 9.4. Überwachen, Steuern und Starten von Programmaktivitäten

Programmaktivitäten können mittels spezieller Werkzeuge überwacht und kontrolliert werden:

Tabelle 9.8. Liste von Werkzeugen zur Überwachung und Steuerung von Programmaktivitäten

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | `nice`(1): ein Programm mit veränderter Ablaufpriorität ausführen
`bsdutils` | V:439, I:999 | 335 | `renice`(1): die Ablaufpriorität eines laufenden Prozess verändern
`procps` | V:818, I:998 | 2404 | Werkzeuge für das "`/proc`"-Dateisystem: `ps`(1), `top`(1), `kill`(1), `watch`(1), …
`psmisc` | V:410, I:742 | 950 | Werkzeuge für das "`/proc`"-Dateisystem: `killall`(1), `fuser`(1), `peekfd`(1), `pstree`(1)
`time` | V:5, I:85 | 129 | `time`(1): ein Programm ausführen und die Zeit ausgeben, während der Ressourcen verbraucht wurden
`sysstat` | V:123, I:162 | 1904 | `sar`(1), `iostat`(1), `mpstat`(1), …: Werkzeuge zur Messung der System-Performance unter Linux
`isag` | V:0, I:3 | 109 | Interaktive grafische Darstellung der Systemaktivität, basierend auf sysstat
`lsof` | V:443, I:949 | 492 | `lsof`(8): mit der Option "`-p`" diejenigen Dateien auflisten, die von einem gerade laufenden Prozess geöffnet wurden
`strace` | V:10, I:103 | 3253 | `strace`(1): Systemaufrufe und -signale verfolgen
`ltrace` | V:0, I:11 | 420 | `ltrace`(1): Bibliotheksaufrufe verfolgen
`xtrace` | V:0, I:0 | 353 | `xtrace`(1): Kommunikation zwischen X11-Client und -Server verfolgen
`powertop` | V:33, I:232 | 696 | `powertop`(1): Informationen über verbrauchte Systemleistung
`cron` | V:901, I:996 | 250 | Prozesse laut dem Ablaufplan des `cron`(8)-Daemons im Hintergrund ausführen
`anacron` | V:418, I:493 | 112 | cron-ähnlicher Programmablauf-Planer für Systeme, die nicht 24 Stunden am Tag laufen
`at` | V:74, I:102 | 158 | `at`(1) oder `batch`(1): einen Prozess zu einer bestimmten Zeit oder unterhalb einer bestimmten Systembelastung ausführen

| Tipp
Das `procps`-Paket enthält sehr grundlegende Werkzeuge zum Überwachen, Steuern und Starten von Programmaktivitäten. Sie sollten sich mit diesen vertraut machen.

### 9.4.1. Zeitmessung für einen Prozess

Zeit anzeigen, die der von dem Befehl angestossene Prozess benötigt hat:

    # 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. Die Ablaufpriorität

Der nice-Wert wird verwendet, um die Ablaufpriorität von Prozessen zu steuern.

Tabelle 9.9. Liste der nice-Werte für die Ablaufpriorität

nice-Wert | Ablaufpriorität
--- | ---
19 | niedrigste Prozesspriorität (sparsam)
0 | sehr hohe Prozesspriorität für Benutzer
-20 | sehr hohe Prozesspriorität für root (nicht sparsam)

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

Manchmal schadet ein extremer nice-Wert dem System mehr als er ihm nützt. Nutzen Sie diesen Befehl mit Vorsicht.

### 9.4.3. Der Befehl ps

Der `ps`(1)-Befehl im Debian-System unterstützt sowohl BSD- wie auch SystemV-Funktionalitäten und hilft dabei, die Prozessaktivitäten (in statischem Zustand) zu beurteilen.

Tabelle 9.10. Liste von ps-Befehlen

Art | typischer Befehl | Funktionalität
--- | --- | ---
BSD | `ps aux` | anzeigen von %CPU und %MEM
System V | `ps -efH` | anzeigen der PPID

Nicht mehr vorhandene Zombie-Kindprozesse können Sie über die Prozess-ID des Eltern-Prozesses in dem "`PPID`"-Feld beenden.

Der Befehl `pstree`(1) zeigt alle Prozesses in Form eines Hierarchie-Baums an.

### 9.4.4. Der Befehl top

`top`(1) auf einem Debian-System hat reichhaltige Funktionalitäten und hilft dabei, Prozesse zu identifizieren, die sich sehr auffällig dynamisch verhalten.

Es ist ein interaktives Programm mit Vollbildschirmmodus. Sie erhalten eine Hilfe zur Nutzung, indem Sie die Taste "h" drücken; mit "q" beenden Sie das Programm.

### 9.4.5. Dateien auflisten, die von einem Prozess geöffnet wurden

Sie können wie folgt alle Dateien auflisten, die von einem Prozess mit einer bestimmten Prozess-ID (PID), z.B. 1, geöffnet wurden:

    $ sudo lsof -p 1

PID 1 ist normalerweise das `init`-Programm.

### 9.4.6. Programmaktivitäten verfolgen

Sie können Programmaktivitäten mit `strace`(1) (für Systemaufrufe und -signale), `ltrace`(1) (für Bibliotheksaufrufe) oder `xtrace`(1) (für die Kommunikation zwischen X11-Client und -Server) verfolgen.

Systemaufrufe des `ls`-Befehls verfolgen Sie z.B. wie folgt:

    $ sudo strace ls

| Tipp
Nutzen Sie das Skript strace-graph aus /usr/share/doc/strace/examples/, um eine hübsche Baumansicht zu erstellen.

### 9.4.7. Identifikation von Prozessen, die Dateien oder Sockets verwenden

Auch können Sie Prozesse, die bestimmte Dateien nutzen, mit `fuser`(1) identifizieren, hier z.B. "`/var/log/mail.log`":

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

Sie sehen, dass die Datei "`/var/log/mail.log`" von dem Befehl `rsyslogd`(8) zum Schreiben geöffnet wurde.

Prozessse, die bestimmte Sockets verwenden, können Sie ebenfalls mittels `fuser`(1) identifizieren, für "`smtp/tcp`" z.B. wie hier:

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

Jetzt wissen Sie, dass auf Ihrem System `exim4`(8) läuft, um TCP-Verbindungen zum SMTP-Port (25) zu bedienen.

### 9.4.8. Einen Befehl mit festem Intervall wiederholt ausführen

`watch`(1) führt ein Programm wiederholt mit einem festen Intervall aus und zeigt dessen Ausgabe im Vollbildschirmmodus an.

    $ watch w

Hiermit wird alle 2 Sekunden neu angezeigt, wer auf dem System angemeldet ist.

### 9.4.9. Einen Befehl wiederholt mit einer Schleife über verschiedene Dateien ausführen

Es gibt verschiedene Wege, um einen Befehl zu wiederholen und jedes Mal eine andere Datei aus einer bestimmten Menge von Dateien (hier z.B. ausgewählt über ein glob-Suchmuster auf "`*.ext`") als Argument zu verwenden.

- Methode mit einer for-Schleife in der Shell (Näheres in Abschnitt 12.1.4, „Shell-Schleifen“):

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

- Kombination aus `find`(1) und `xargs`(1):

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

- `find`(1) mit "`-exec`"-Option und einem Befehl:

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

- `find`(1) mit "`-exec`"-Option und einem kurzen Shell-Skript:

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

Die obigen Beispiele wurden geschrieben, um auch eine korrekte Behandlung von komischen Dateinamen, wie z.B. solche mit Leerzeichen, sicherzustellen. Lesen Sie dazu auch Abschnitt 10.1.5, „Aufrufe für die Auswahl von Dateien“; dort finden Sie außerdem weitergehende Verwendungen des Befehls `find`(1).

### 9.4.10. Ein Programm aus der grafischen Oberfläche heraus starten

Auf der Befehlszeile (command-line interface, CLI) wird das erste Programm mit dem passenden Namen ausgeführt, das in den durch die Umgebungsvariable `$PATH` definierten Verzeichnissen gefunden wird. Lesen Sie dazu auch Abschnitt 1.5.3, „Die "`$PATH`"-Variable“.

Bei einer zum freedesktop.org-Standard konformen grafischen Oberfläche (graphical user interface, GUI) enthalten die `*.desktop`-Dateien in dem Verzeichnis `/usr/share/applications/` alle nötigen Attribute für die Anzeige der Programmeinträge im grafischen Menü. Jedes Paket, das mit dem xdg-Menüsystem von Freedesktop.org konform ist, installiert seine Menüdaten (für die "*.desktop"-Dateien) unter "/usr/share/applications/". Moderne Arbeitsplatzumgebungen gemäß Freedesktop.org-Standard verwenden diese Daten, um mittels dem xdg-utils-Paket das Programmmenü zu erstellen. Näheres dazu in "/usr/share/doc/xdg-utils/README".

Im folgenden Beispiel definiert die Datei `chromium.desktop` die Attribute für den "Chromium-Webbrowser", z.B. "Name" für den Programmnamen, "Exec" für den Pfad zum auszuführenden Programm mit zugehörigen Argumenten, "Icon" für das verwendete Icon-Symbol usw. (Details finden Sie unter Desktop Entry Specification):

    [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

Dies ist eine vereinfachte Beschreibung. Die `*.desktop`-Dateien werden wie folgt eingelesen:

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

- `$XDG_DATA_HOME` wird nicht genutzt (der Standardwert aus `$HOME/.local/share` wird verwendet).

- `$XDG_DATA_DIRS` wird auf `/usr/share/gnome:/usr/local/share/:/usr/share/` gesetzt.

Daher werden die Basisverzeichnisse (lesen Sie XDG Base Directory Specification) und `applications`-Verzeichnisse wie folgt gesetzt:

- `$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/`

Die `*.desktop`-Dateien aus diesen `applications`-Verzeichnissen werden in obiger Reihenfolge eingelesen.

| Tipp
Ein benutzerdefinierter Menüeintrag für die grafische Oberfläche kann erstellt werden, indem eine `*.desktop`-Datei zum Verzeichnis `$HOME/.local/share/applications/` hinzugefügt wird.

| Tipp
Die "`Exec=...`"-Zeile wird nicht durch die Shell ausgewertet. Nutzen Sie den `env`(1)-Befehl, wenn Umgebungsvariablen gesetzt werden müssen.

| Tipp
Ähnlich dazu verhält es sich, wenn eine `*.desktop`-Datei zum `autostart`-Verzeichnis in diesen Basisverzeichnissen hinzugefügt wird: das in der `*.desktop`-Datei definierte Programm wird beim Start der grafischen Benutzeroberfläche automatisch ausgeführt (z.B. nach dem Anmelden). Lesen Sie dazu Desktop Application Autostart Specification.

| Tipp

Ähnlich ist es auch, wenn eine `*.desktop`-Datei im `$HOME/Desktop`-Verzeichnis erstellt wird und die grafische Umgebung die Funktionalität der Programmstarter-Icons (desktop icon launcher) unterstützt: das definierte Programm wird bei Anklicken des Icons ausgeführt. Bitte beachten Sie, dass der eigentliche Name des `$HOME/Desktop`-Verzeichnisses letztlich vom Gebietsschema (Locale) abhängt; Näheres dazu finden Sie in `xdg-user-dirs-update`(1).

### 9.4.11. Anpassen des zu startenden Programms

Einige Programme starten automatisch weitere Programme. Hier einige Punkte bezüglich der Anpassung dieses Prozesses.

- Menü zur Konfiguration von bevorzugten Anwendungen:

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

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

  - Iceweasel-Browser: "Bearbeiten" → "Einstellungen" → "Anwendungen";

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

- Umgebungsvariablen wie "`$BROWSER`", "`$EDITOR`", "`$VISUAL`" und "`$PAGER`" (Näheres in `environ`(7));

- das `update-alternatives`(1)-System für Programme wie "`editor`", "`view`", "`x-www-browser`", "`gnome-www-browser`" und "`www-browser`" (Näheres in Abschnitt 1.4.7, „Einen Standard-Texteditor einstellen“);

- die Inhalte der Dateien "`~/.mailcap`" und "`/etc/mailcap`", über die die MIME-Types bestimmten Programmen zugeordnet werden (Näheres in `mailcap`(5));

- die Inhalte der Dateien "`~/.mime.types`" und "`/etc/mime.types`", über die Dateinamenerweiterungen entsprechenden MIME-Types zugeordnet werden (Näheres in `run-mailcap`(1)).

| Tipp
`update-mime`(8) aktualisiert die "`/etc/mailcap`"-Datei unter Verwendung von "`/etc/mailcap.order`" (Näheres in `mailcap.order`(5)).

| Tipp
Das `debianutils`-Paket stellt `sensible-browser`(1), `sensible-editor`(1) und `sensible-pager`(1) bereit; diese treffen eine sinnvolle Auswahl, welcher Editor, Pager bzw. Webbrowser aufgerufen wird. Ich empfehle, dass Sie diese Shell-Skripte lesen.

| Tipp

Um eine Konsolen-Applikation (hier `mutt`) im GUI als bevorzugte Anwendung festzulegen, sollten Sie wie folgt ein Startskript für die Applikation erzeugen (in diesem Fall "`/usr/local/bin/mutt-term`") und dieses als bevorzugt zu startende Anwendung konfigurieren:

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

### 9.4.12. Einen Prozess beenden (kill)

Verwenden Sie `kill`(1), um über die Prozess-ID einen Prozess zu beenden (oder diesem ein Signal zu senden).

Nutzen Sie `killall`(1) oder `pkill`(1), um das gleiche über den Befehlsnamen und andere Attribute des Prozesses zu erledigen.

Tabelle 9.11. Liste von häufig verwendeten Signalen für den kill-Befehl

Signalwert | Signalname | Aktion | Hinweis
--- | --- | --- | ---
0 | --- | es wird kein Signal gesendet (siehe `kill`(2)) | Überprüfung, ob der Prozess läuft
1 | SIGHUP | den Prozess beenden | nicht mehr verbundenes Terminal (Signal aufgehängt)
2 | SIGINT | den Prozess beenden | Unterbrechen durch die Tastatur (`Strg-C`)
3 | SIGQUIT | den Prozess beenden und Core dump erstellen | Beenden durch die Tastatur (`Strg-\`)
9 | SIGKILL | den Prozess beenden | Signal zum unmittelbaren Beenden
15 | SIGTERM | den Prozess beenden | Anfrage zum Beenden

### 9.4.13. Einmalige Aufgaben planen

Führen Sie den `at`(1)-Befehl wie folgt aus, um eine einmalige Aufgabe zu planen:

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

### 9.4.14. Regelmäßige Aufgaben planen

Verwenden Sie `cron`(8), um regelmäßig wiederkehrende Aufgaben zu planen. Lesen Sie dazu `crontab`(1) and `crontab`(5).

Sie können Prozesse zur Ausführung durch einen normalen Benutzer, z.B. den Benutzer `foo`, einplanen, indem Sie mit dem Befehl "`crontab -e`" eine `crontab`(5)-Datei namens "`/var/spool/cron/crontabs/foo`" erstellen.

Hier ein Beispiel einer `crontab`(5)-Datei:

    # 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

| Tipp
Auf Systemen, die nicht ständig laufen, installieren Sie das `anacron`-Paket, um regelmäßige Aufgaben auszuführen, sobald nach entsprechender Maschinen-Einschaltdauer ein festgelegter Intervall abgelaufen ist. Näheres unter `anacron`(8) und `anacrontab`(5).

| Tipp
Geplante Skripte zur Systemwartung können Sie vom root-Konto aus wiederholt ausführen, indem Sie solche Skripte in "`/etc/cron.hourly/`", "`/etc/cron.daily/`", "`/etc/cron.weekly/`" oder "`/etc/cron.monthly/`" einfügen. Der Ausführungszeitpunkt dieser Skripte kann über "`/etc/crontab`" und "`/etc/anacrontab`" angepasst werden.

Systemd gewisse Fähigkeiten, um die Ausführung von Programmen ohne den `cron`-Daemon zu planen. Zum Beispiel werden über `/lib/systemd/system/apt-daily.timer` und `/lib/systemd/system/apt-daily.service` tägliche Download-Aktivitäten von apt geplant. Näheres in `systemd.timer`(5) .

### 9.4.15. Aufgaben ereignisgesteuert planen

Systemd kann Programme nicht nur über das timer-Ereignis gesteuert ausführen, sondern auch über das mount-Ereignis. Beispiele finden Sie in Abschnitt 10.2.3.3, „Automatisches Backup, durch ein timer-Ereignis ausgelöst“ und Abschnitt 10.2.3.2, „Automatisches Backup, durch ein mount-Ereignis ausgelöst“.

### 9.4.16. Die Alt-SysRq-Tastenkombination

Alt-SysRq (auf deutschen Tastaturen das Drücken von Alt+Druck) gefolgt von einer weiteren Taste löst verschiedene, fast magische Aktionen aus, um im Notfall die Kontrolle über das System wiederzuerlangen:

Tabelle 9.12. Liste erwähnenswerter SAK-Befehlstasten

Taste nach Alt-SysRq | Beschreibung der Aktion
--- | ---
`k` | alle Prozesse auf der aktuellen virtuellen Konsole durch ein kill zum Beenden zwingen (SAK)
`s` | alle eingebundenen Dateisysteme synchronisieren (Dateisystempuffer auf Platte schreiben), um Datenverluste zu vermeiden
`u` | alle eingebundenen Dateisysteme neu einbinden mit Nur-Lese-Berechtigung (umount)
`r` | Tastatur aus dem Roh-Modus (raw) wiederherstellen nach X-Abstürzen

Weitere Details finden Sie im Linux kernel user’s and administrator’s guide » Linux Magic System Request Key Hacks.

| Tipp
Von einem SSH-Terminal u.ä. können Sie die Alt-SysRq-Funktionalität nutzen, indem Sie in "`/proc/sysrq-trigger`" schreiben. Zum Beispiel werden durch "`echo s > /proc/sysrq-trigger; echo u > /proc/sysrq-trigger`" alle eingebundenen Dateisysteme synchronisiert und mittels umount aus der Einbindung gelöst.

Der aktuelle Debian amd64 Linux-Kernel (Stand 2021) hat `/proc/sys/kernel/sysrq=438=0b110110110`:

- 2 = 0x2 - Aktivieren der Kontrolle über das Konsolen-Log-Level (AN)

- 4 = 0x4 - Aktivieren der Kontrolle über die Tastatur (SAK, unraw) (AN)

- 8 = 0x8 - Aktivieren von Speicher-Dumps der Prozesse zwecks Fehlersuche (Debugging) usw. (AUS)

- 16 = 0x10 - Aktivieren des sync-Befehls (AN)

- 32 = 0x20 - Aktivieren von Neueinbinden mit Nur-Lese-Berechtigung (remount read-only) (AN)

- 64 = 0x40 - Aktivieren des Sendens von Signalen an Prozesse (term, kill, oom-kill) (AUS)

- 128 = 0x80 - Erlauben von Neustart/Ausschalten (AN)

- 256 = 0x100 - Erlauben von nice-Prioritäten für all Echtzeit-(RT-)Prozesse (AN)

## 9.5. Tipps zur Systempflege

### 9.5.1. Wer ist/war im System aktiv?

Sie können wie folgt überprüfen, wer derzeit im System aktiv ist:

- `who`(1) zeigt, wer angemeldet ist.

- `w`(1) zeigt, wer angemeldet ist und was derjenige jeweils tut.

- `last`(1) zeigt eine Auflistung der zuletzt angemeldeten Benutzer.

- `lastb`(1) zeigt eine Auflistung der letzten Benutzer mit fehlgeschlagenen Anmeldeversuchen.

| Tipp
Diese Informationen werden in "`/var/run/utmp`" und "`/var/log/wtmp`" zur Verfügung gehalten. Lesen Sie dazu `login`(1) und `utmp`(5).

### 9.5.2. Allen eine Warnung schicken

Mit `wall`(1) können Sie wie folgt eine Nachricht an alle am System angemeldeten Benutzer schicken:

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

### 9.5.3. Hardware-Identifikation

Bei PCI-basierten Geräten (AGP, PCI-Express, CardBus, ExpressCard usw.) ist `lspci`(8) (eventuell mit der Option "`-nn`") ein guter Anfang zur Hardware-Identifikation.

Alternativ können Sie die Hardware auch über das Auslesen der Inhalte von "`/proc/bus/pci/devices`" identifizieren oder indem Sie die Verzeichnisse unterhalb von "`/sys/bus/pci`" durchsuchen (Näheres in Abschnitt 1.2.12, „procfs und sysfs“).

Tabelle 9.13. Liste von Werkzeugen zur Hardware-Identifikation

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`pciutils` | V:254, I:992 | 280 | Hilfsprogramme für PCI unter Linux: `lspci`(8)
`usbutils` | V:80, I:887 | 322 | Hilfsprogramme für USB unter Linux: `lsusb`(8)
`nvme-cli` | V:22, I:30 | 2222 | Hilfsprogramme für NVME unter Linux: `nvme`(1)
`pcmciautils` | V:4, I:7 | 92 | Hilfsprogramme für PCMCIA unter Linux: `pccardctl`(8)
`scsitools` | V:0, I:2 | 261 | Sammlung von Werkzeugen für das SCSI-Hardware-Management: `lsscsi`(8)
`procinfo` | V:0, I:6 | 149 | Systeminformationen, gewonnen aus "`/proc`": `lsdev`(8)
`lshw` | V:13, I:90 | 971 | Informationen über die Hardware-Konfiguration: `lshw`(1)
`discover` | V:27, I:685 | 81 | System zur Hardware-Identifikation: `discover`(8)

### 9.5.4. Hardware-Konfiguration

Obwohl der größte Teil der Hardware-Konfiguration auf modernen GUI-Arbeitsplatzsystemen wie GNOME und KDE über entsprechende GUI-Werkzeuge verwaltet werden kann, ist es eine gute Idee, zumindest einige grundlegende Methoden für deren Konfiguration zu kennen.

Tabelle 9.14. Liste von Werkzeugen zur Hardware-Konfiguration

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`console-setup` | V:77, I:973 | 420 | Werkzeuge für Schriftarten und Tastaturbelegungen auf der Linux-Konsole
`x11-xserver-utils` | V:312, I:542 | 559 | X-Server-Hilfsprogamme: `xset`(1), `xmodmap`(1)
`acpid` | V:58, I:90 | 158 | Daemon zur Verwaltung von Ereignissen der Advanced-Configuration-and-Power-Interface-(ACPI-)Schnittstelle
`acpi` | V:7, I:85 | 49 | Werkzeug zur Anzeige von Informationen über ACPI-Geräte
`sleepd` | V:0, I:0 | 84 | Daemon, mit dem man einen Laptop bei Inaktivität in Ruhemodus schicken kann
`hdparm` | V:117, I:222 | 246 | Optimierung des Festplattenzugriffs (lesen Sie dazu Abschnitt 9.6.9, „Optimierung der Festplatte“)
`smartmontools` | V:229, I:264 | 2455 | Speichersysteme mittels S.M.A.R.T. kontrollieren und überwachen
`setserial` | V:3, I:5 | 104 | Werkzeugsammlung zur Verwaltung von seriellen Ports
`memtest86+` | V:0, I:19 | 12473 | Werkzeugsammlung zur Speicher-Hardware-Verwaltung
`scsitools` | V:0, I:2 | 261 | Werkzeugsammlung zur SCSI-Hardware-Verwaltung
`setcd` | V:0, I:0 | 33 | Optimierung des Zugriffs auf CD-Laufwerke
`big-cursor` | I:0 | 26 | größere Maus-Cursor für X

ACPI ist ein neueres Rahmenwerk für das Power Management und der Nachfolger für das ältere APM.

| Tipp
Die Skalierung der CPU-Frequenz wird auf modernen Systemen durch Kernel-Module wie `acpi_cpufreq` abgewickelt.

### 9.5.5. System- und Hardware-Zeit

Über folgende Befehle wird die System- und Hardware-Zeit auf MM/DD hh:mm, CCYY (MM - Monat, DD - Tag, hh - Stunde, mm - Minute, CCYY - Jahr) gesetzt:

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

Zeiten werden auf einem Debian-System normalerweise in der Lokalzeit angezeigt, aber die Hardware- und Systemzeit verwenden üblicherweise UTC (GMT).

Wenn die Hardware-Zeit (teilweise auch als BIOS-/UEFI- oder CMOS-Uhr bezeichnet) auf UTC eingestellt ist, ändern Sie die Einstellung in "`/etc/default/rcS`" auf "`UTC=yes`".

Mit folgendem Befehl konfigurieren Sie die vom Debian-System verwendete Zeitzone neu:

    # dpkg-reconfigure tzdata

Falls Sie die Systemzeit über das Netzwerk aktualisieren möchten, sollten Sie die Verwendung des NTP-Dienstes in Erwägung ziehen; dazugehörige Pakete sind `ntp`, `ntpdate` und `chrony`.

| Tipp
Unter systemd sollten Sie stattdessen `systemd-timesyncd` für die Netzwerk-Zeitsynchronisation verwenden. Lesen Sie dazu `systemd-timesyncd`(8).

Hier finden Sie weitere Informationen:

- Managing Accurate Date and Time HOWTO;

- NTP Public Services Project;

- im `ntp-doc`-Paket.

| Tipp
`ntptrace`(8) aus dem `ntp`-Paket kann eine Hintereinanderschaltung mehrerer NTP-Server zu deren primärer Quelle zurückverfolgen.

### 9.5.6. Die Terminal-Konfiguration

Es existieren mehrere Komponenten zur Konfiguration von Systemfunktionalitäten für textbasierte Konsolen und `ncurses`(3):

- die Datei "`/etc/terminfo/*/*`" (`terminfo`(5));

- die Umgebungsvariable "`$TERM`" (`term`(7));

- `setterm`(1), `stty`(1), `tic`(1) und `toe`(1).

Falls bei Anmeldung von fern auf einem Debian-System mit einem Debian-fremden `xterm`der `terminfo`-Eintrag für `xterm` nicht funktioniert, ändern Sie den Terminaltyp ("`$TERM`") von "`xterm`" auf eine der funktionseingeschränkten Versionen wie "`xterm-r6`". Näheres dazu finden Sie in "`/usr/share/doc/libncurses5/FAQ`". "`dumb`" ist der kleinste gemeinsame Nenner für "`$TERM`".

### 9.5.7. Die Audio-Infrastruktur

Gerätetreiber für Soundkarten werden in aktuellen Linux-Systemen von Advanced Linux Sound Architecture (ALSA) bereitgestellt. ALSA enthält zwecks Kompatibilität auch einen Emulationsmodus für das ältere Open Sound System (OSS).

Anwendungssoftware kann konfiguriert sein, nicht die Soundkarte direkt anzusprechen, sondern über standardisierte Sound-Server-Systeme darauf zuzugreifen. Derzeit werden PulseAudio, JACK und PipeWire als Sound-Server-Systeme genutzt. Schauen Sie im Debian-Wiki unter Sound, wie die aktuelle Situation ist.

Es gibt normalerweise für jede populäre Arbeitsplatzumgebung eine Sound-Engine. Für jede Sound-Engine, die von einer Anwendung verwendet wird, kann ausgewählt werden, mit welchem der verschiedenen Sound-Server sie sich verbindet.

| Tipp
Verwenden Sie "`cat /dev/urandom > /dev/audio`" oder `speaker-test`(1), um die Lautsprecher zu testen (^C zum stoppen).

| Tipp
Falls Sie keinen Ton hören, sind Ihre Lautsprecher möglicherweise an einem stummgeschalteten Ausgang angeschlossen. Moderne Sound-Systeme haben oft mehrere Ausgänge. `alsamixer`(1) aus dem `alsa-utils`-Paket ist nützlich für die Einstellung von Lautstärke und Stummschaltung.

Tabelle 9.15. Liste von Audio-Paketen

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`alsa-utils` | V:341, I:475 | 2702 | Werkzeuge zur Konfiguration und Nutzung von ALSA
`oss-compat` | V:0, I:10 | 18 | Paket für OSS-Kompatibilität, verhindert unter ALSA das Auftreten von "`/dev/dsp not found`"-Fehlern
`pipewire` | V:316, I:373 | 142 | Multimedia-Server - Engine für Audio- und Videoverarbeitung - Metapaket
`pipewire-bin` | V:324, I:373 | 2094 | Multimedia-Server - Engine für Audio- und Videoverarbeitung - Audio-Server und CLI-Programme
`pipewire-alsa` | V:168, I:238 | 197 | Multimedia-Server - Engine für Audio- und Videoverarbeitung - Audio-Server, um ALSA zu ersetzen
`pipewire-pulse` | V:280, I:340 | 64 | Multimedia-Server - Engine für Audio- und Videoverarbeitung - Audio-Server, um PulseAudio zu ersetzen
`pulseaudio` | V:166, I:197 | 6606 | PulseAudio-Server
`libpulse0` | V:439, I:587 | 977 | PulseAudio-Client-Bibliothek
`jackd` | V:2, I:15 | 8 | JACK Audio Connection Kit (JACK)-Server (niedrige Latenzzeiten)
`libjack0` | V:2, I:9 | 330 | JACK Audio Connection Kit (JACK)-Bibliothek (niedrige Latenzzeiten)
`libgstreamer1.0-0` | V:465, I:602 | 5280 | GStreamer: GNOME-Sound-Engine
`libphonon4qt5-4` | V:28, I:64 | 572 | Phonon: KDE-Sound-Engine

### 9.5.8. Deaktivieren des Bildschirmschoners

Verwenden Sie folgende Befehle, um den Bildschirmschoner zu deaktivieren:

Tabelle 9.16. Liste von Befehlen zur Deaktivierung des Bildschirmschoners

Umgebung | Befehl
--- | ---
Linux-Konsole | `setterm -powersave off`
X-Window (Bildschirmschoner ausschalten) | `xset s off`
X-Window (dpms deaktivieren) | `xset -dpms`
X-Window (grafische Oberfläche zur Konfiguration des Bildschirmschoners) | `xscreensaver-command -prefs`

### 9.5.9. Ausschalten von Pieptönen

Man kann immer den Stecker des internen PC-Lautsprechers abziehen, um jegliche Pieptöne loszuwerden, aber auch über das Entfernen des `pcspkr`-Kernel-Moduls kann dies erreicht werden.

Folgender Befehl verhindert, dass das `readline`(3)-Programm, das von `bash`(1) genutzt wird, einen Piepton ausgibt, wenn es ein Alarm-Zeichen (ASCII=7) empfängt:

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

### 9.5.10. Arbeitsspeichernutzung

Es gibt zwei Ressourcen, über die Sie die aktuelle Situation zur Arbeitsspeichernutzung abfragen können:

- Die Boot-Meldungen des Kernels in "`/var/log/dmesg`" enthalten die exakte Größe des verfügbaren Arbeitsspeichers.

- `free`(1) und `top`(1) zeigen Informationen über Arbeitsspeicher-Ressourcen auf dem laufenden System an.

Hier ein Beispiel:

    # 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

Sie fragen sich vielleicht: "Warum sagt dmesg mir, dass 990 MB frei sind, während free -k sagt, 320 MB seien frei. Da fehlen mehr als 600 MB …"

Sorgen Sie sich nicht über den hohen Wert von "`used`" und die kleine Größe von "`free`" in der "`Mem:`"-Zeile; schauen Sie sich stattdessen die Werte darunter an (inklusive Puffer/Cache, 675404 und 321780 in obigem Beispiel) und entspannen Sie sich.

Auf meinem MacBook mit 1GB=1048576k DRAM (das Grafik-System stiehlt einiges davon) sehe ich Folgendes:

Tabelle 9.17. Liste der gemeldeten Arbeitsspeichergrößen

gemeldet | Größe
--- | ---
absolute Größe in dmesg | 1016784k = 1GB - 31792k
frei in dmesg | 990528k
absolut auf der Shell | 997184k
frei auf der Shell | 20256k (aber effektiv 321780k)

### 9.5.11. Systemsicherheits- und Integritätsüberprüfung

Schlechte Systemwartung könnte Ihr System für Angriffe von extern anfällig machen.

Um eine Systemsicherheits- und Integritätsüberprüfung durchzuführen, sollten Sie mit folgendem beginnen:

- dem `debsums`-Paket, lesen Sie dazu `debsums`(1) und Abschnitt 2.5.2, „"Release"-Datei im Wurzelverzeichnis und Authentizität“;

- dem `chkrootkit`-Paket, lesen Sie dazu `chkrootkit`(1);

- der `clamav`-Paketfamilie, lesen Sie dazu `clamscan`(1) und `freshclam`(1);

- der Debian Sicherheits-FAQ;

- der Anleitung zum Absichern von Debian.

Tabelle 9.18. Liste von Werkzeugen für eine Systemsicherheits- und Integritätsüberprüfung

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`logcheck` | V:5, I:6 | 120 | Daemon, um Anomalien in den System-Logdateien per Mail an den Administrator zu melden
`debsums` | V:4, I:30 | 107 | Hilfsprogramm, um installierte Paketdateien anhand von MD5-Prüfsummen zu verifizieren
`chkrootkit` | V:9, I:14 | 966 | rootkit-Erkennungsprogramm
`clamav` | V:8, I:39 | 33154 | Antiviren-Programm für Unix - Befehlszeilenschnittstelle
`tiger` | V:1, I:1 | 7800 | Sicherheitslücken im System melden
`tripwire` | V:1, I:1 | 5050 | Integritätsüberprüfung für Dateien und Verzeichnisse
`john` | V:1, I:7 | 469 | Programm zum aktiven Knacken von Passwörtern
`aide` | V:1, I:2 | 331 | Fortschrittliche Intrusion-Detection-Umgebung - statische Binärdatei
`integrit` | V:0, I:0 | 2939 | Dateiintegritäts-Verifizierungsprogramm
`crack` | V:0, I:0 | 153 | Programm zum Erraten von Passwörtern

Hier ein einfaches Skript, um nach Dateien mit typischerweise falschen Dateiberechtigungen (schreibbar für alle) zu suchen:

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

| Achtung
Da das `debsums`-Paket MD5-Prüfsummen verwendet, die lokal gespeichert sind, kann ihm als Sicherheits-Audit-Werkzeug gegen bösartige Angriffe nicht vollständig vertraut werden.

## 9.6. Tipps zur Speicherung von Daten

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

Teilweise werden Geräte vom grafischen Arbeitsplatzsystem automatisch eingebunden. Solche Geräte müssen Sie dann händisch über die Befehlszeile vom System trennen (mittels `umount`(8)), bevor Sie daran arbeiten können.

### 9.6.1. Verwendung des Plattenplatzes

Der verwendete Plattenplatz kann mit Programmen aus den Paketen `mount`, `coreutils` und `xdu` beurteilt werden:

- `mount`(8) gibt Informationen über alle eingebundenen Dateisysteme (= "Laufwerke") aus.

- `df`(1) gibt Informationen über den verwendeten Plattenplatz für das Dateisystem aus.

- `du`(1) gibt Informationen über den verwendeten Plattenplatz für den Verzeichnisbaum aus.

| Tipp
Mit "`du -k . |xdu`", "`sudo du -k -x / |xdu`" usw. können Sie die Ausgabe von `du`(8) an `xdu`(1x) weiterleiten, um eine grafische und interaktive Präsentation zu erhalten.

### 9.6.2. Konfiguration der Festplattenpartitionen

Bei der Konfiguration von Laufwerkspartitionen können Sie erwägen, `parted`(8) zu verwenden (obwohl `fdisk`(8) lange als Standard angesehen wurde). Die Begriffe "Partitionstabelle", "Disk partitioning data", "Partition map" und "Disk label" werden alle gleichbedeutend verwendet.

Ältere PCs verwenden das klassische Schema des Master Boot Record (MBR) und legen die Partitionstabelle im ersten Sektor, also im LBA-Sektor 0 (512 Byte) ab.

Aktuelle PCs mit Unified Extensible Firmware Interface (UEFI), inklusive Intel-basierten Macs, verwenden teilweise das GUID Partition Table (GPT)-Schema, bei dem die Partitionstabelle nicht im ersten Sektor liegt.

Obwohl `fdisk`(8) lange Zeit das Standardwerkzeug zur Laufwerkspartitionierung war, ist `parted`(8) dabei, ihm den Rang abzulaufen.

Tabelle 9.19. Liste von Paketen für die Partitionierung

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`util-linux` | V:897, I:999 | 4384 | verschiedene System-Werkzeuge inklusive `fdisk`(8) und `cfdisk`(8)
`parted` | V:445, I:579 | 126 | GNU Parted - Programm zum Anlegen / Ändern von Partitionen
`gparted` | V:13, I:92 | 2313 | GNOME Partitionseditor, basierend auf `libparted`
`gdisk` | V:20, I:309 | 940 | Partitionseditor für GPT/MBR-Hybrid-Laufwerke
`kpartx` | V:17, I:27 | 78 | Programm zur Erzeugung von Gerätezuordnungen (device mappings) für Partitionen

| Achtung
Obwohl `parted`(8) vorgibt, Dateisysteme erzeugen und auch nachträglich in der Größe verändern zu können, ist es sicherer, für solche Dinge gut betreute und spezialisierte Werkzeuge wie `mkfs`(8) (`mkfs.msdos`(8), `mkfs.ext2`(8), `mkfs.ext3`(8), `mkfs.ext4`(8), …) und `resize2fs`(8) zu verwenden.

| Anmerkung
Um zwischen GPT und MBR zu wechseln, müssen Sie die ersten paar Blöcke der Platte löschen (lesen Sie dazu Abschnitt 9.8.6, „Leeren von Dateiinhalten“) und "`parted /dev/sdx mklabel gpt`" oder "`parted /dev/sdx mklabel msdos`" nutzen, um die gewünschte Einstellung neu zu setzen. Bitte beachten Sie, dass hierbei "`msdos`" für MBR verwendet wird.

### 9.6.3. Zugriff auf Partitionen über die UUID-Kennung

Obwohl aufgrund der Neukonfiguration einer Partition oder der Aktivierungsreihenfolge von Wechseldatenträgern Laufwerke von einem zum anderen Mal unterschiedliche Laufwerksnamen haben können, gibt es auch eine Möglichkeit, konsistente Bezeichnungen für den Laufwerkszugriff zu verwenden. Dies ist ebenfalls hilfreich, wenn Sie mehrere Festplatten haben und Ihr BIOS/UEFI die Gerätenamen nicht jedes Mal identisch zuweist.

- `mount`(8) kann über die Option "`-U`" ein blockorientiertes Gerät mittels seiner UUID-Kennung einbinden, statt dessen Gerätedateinamen (wie z.B. "`/dev/sda3`") zu nutzen.

- "`/etc/fstab`" (lesen Sie hierzu auch `fstab`(5)) kann UUID verwenden.

- Auch Bootloader (Abschnitt 3.1.2, „Stufe 2: der Bootloader“) können unter Umständen die UUID benutzen.

| Tipp
Sie können die UUID eines blockorientierten Gerätes mit `blkid`(8) abfragen. Sie können die UUID und weitere Informationen auch mit "`lsblk -f`" abfragen.

### 9.6.4. LVM2

LVM2 ist ein Logical Volume Manager für den Linux-Kernel. Mit LVM2 können Partitionen auf logischen Volumes erzeugt werden statt auf physikalischen Festplatten.

LVM erfordert folgendes:

- device-mapper-Unterstützung im Linux-Kernel (Standardeinstellung für Debian-Kernel);

- die Userspace-Bibliothek zur Unterstützung von device-mapper (`libdevmapper*`-Paket);

- die Userspace-LVM2-Werkzeuge (`lvm2`-Paket).

Lehrreiche Informationen über LVM2 finden Sie mittels folgender Handbuchseiten:

- `lvm`(8): Grundlagen des LVM2-Mechanismus' (Liste aller LVM2-Befehle);

- `lvm.conf`(5): Konfigurationsdatei für LVM2;

- `lvs`(8): Informationen über logische Volumes ausgeben;

- `vgs`(8): Informationen über Volume-Gruppen ausgeben;

- `pvs`(8): Informationen über physikalische Volumes ausgeben.

### 9.6.5. Konfiguration von Dateisystemen

Für das ext4-Dateisystem enthält das `e2fsprogs`-Paket folgendes:

- `mkfs.ext4`(8) zur Erzeugung neuer ext4-Dateisysteme;

- `fsck.ext4`(8) zur Überprüfung und Reparatur vorhandener ext4-Dateisysteme;

- `tune2fs`(8) zur Konfiguration des Superblocks von ext4-Dateisystemen;

- `debugfs`(8) für interaktive Fehlersuche in ext4-Dateisystemen (es enthält den `undel`-Befehl, um gelöschte Dateien wiederherzustellen).

Die Befehle `mkfs`(8) und `fsck`(8) werden durch das `e2fsprogs`-Paket bereitgestellt und sind Frontends für Dateisystem-abhängige Programme (`mkfs.dateisystemtyp` und `fsck.dateisystemtyp`). Für ext4 sind das `mkfs.ext4`(8) und `fsck.ext4`(8) (dies sind symbolischer Link auf `mke2fs`(8) und `e2fsck`(8)).

Ähnliche Befehle sind für jedes von Linux unterstützte Dateisystem verfügbar.

Tabelle 9.20. Liste von Paketen für das Dateisystem-Management

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`e2fsprogs` | V:796, I:997 | 1549 | Hilfsprogramme für ext2/ext3/ext4-Dateisysteme
`btrfs-progs` | V:48, I:76 | 5204 | Hilfsprogramme für das Btrfs-Dateisystem
`reiserfsprogs` | V:9, I:21 | 473 | Hilfsprogramme für das Reiserfs-Dateisystem
`zfsutils-linux` | V:31, I:32 | 1891 | Hilfsprogramme für das OpenZFS-Dateisystem
`dosfstools` | V:247, I:572 | 310 | Hilfsprogramme für das FAT-Dateisystem (Microsoft: MS-DOS, Windows)
`exfatprogs` | V:36, I:467 | 352 | Hilfsprogramme für das von Samsung betreute exFAT-Dateisystem
`exfat-fuse` | V:2, I:50 | 73 | Treiber für das Lesen/Schreiben des exFAT-Dateisystems (Microsoft) über FUSE
`xfsprogs` | V:36, I:86 | 4386 | Hilfsprogramme für das XFS-Dateisystem (SGI: IRIX)
`ntfs-3g` | V:193, I:527 | 1500 | Treiber für das Lesen/Schreiben des NTFS-Dateisystems (Microsoft: Windows NT, ...) über FUSE
`jfsutils` | V:0, I:7 | 1104 | Hilfsprogramme für das JFS-Dateisystem (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 | Hilfsprogramme für das Reiser4-Dateisystem
`hfsprogs` | V:0, I:3 | 394 | Hilfsprogramme für HFS- und HFS Plus-Dateisysteme (Apple: Mac OS)
`zerofree` | V:5, I:119 | 30 | Programm, um freie Blöcke auf ext2/3/4-Dateisystemen mit Nullen zu überschreiben

| Tipp

Ext4 ist das Standard-Dateisystem für Linux-Systeme und Sie sollten dies verwenden, außer Sie haben einen bestimmten Grund, ein anderes zu nutzen.

Den aktuellen Status zu Btrfs finden Sie im Debian Wiki und im kernel.org Wiki. Man geht davon aus, dass dies nach ext4 das neue Standard-Dateisystem wird.

Einige Werkzeuge erlauben den Zugriff auf Dateisysteme ohne entsprechende Unterstützung im Linux-Kernel (lesen Sie dazu Abschnitt 9.8.2, „Manipulieren von Dateien ohne Einbinden der Festplatte“).

### 9.6.6. Dateisystemerzeugung und Integritätsüberprüfung

Der `mkfs`(8)-Befehl erzeugt unter Linux ein Dateisystem. Mit `fsck`(8) führen Sie eine Integritätsüberprüfung oder Reparatur des Dateisystems durch.

Standardmäßig gibt es jetzt auf Debian-Systemen nach der Erzeugung des Dateisystems keinen periodischen Dateisystem-Check (`fsck`) mehr.

| Achtung
Es ist grundsätzlich nicht sicher, `fsck` auf eingebundenen Dateisystemen laufen zu lassen.

| Tipp

Sie können den `fsck`(8)-Befehl auf allen Dateisystemen inklusive dem root-Dateisystem (/) gefahrlos beim Reboot ausführen, indem Sie "`enable_periodic_fsck`" in "`/etc/mke2fs.conf`" setzen und den Max-Wert für die mount-Vorgänge mittels "`tune2fs -c0 /dev/partitionsname`" auf 0 setzen. Details finden Sie in `mke2fs.conf`(5) und `tune2fs`(8).

In "`/var/log/fsck/`" finden Sie Ergebnisse von dem `fsck`(8)-Lauf, der bei jedem Systemstart durch das Boot-Skript durchgeführt wird.

### 9.6.7. Optimierung von Dateisystemen über mount-Optionen

Die grundlegende statische Dateisystem-Konfiguration wird in "`/etc/fstab`" festgelegt. Zum Beispiel:

    «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

| Tipp
Die UUID (Näheres in Abschnitt 9.6.3, „Zugriff auf Partitionen über die UUID-Kennung“) kann statt der normalen Namen für blockorientierte Geräte wie "`/dev/sda1`", "`/dev/sda2`" … verwendet werden, um das Gerät zu identifizieren.

Seit Linux 2.6.30 ist das Standardverhalten die "`relatime`"-Option.

Lesen Sie `fstab`(5) und `mount`(8).

### 9.6.8. Optimierung von Dateisystemen über den Superblock

Die Charakteristik eines Dateisystems kann über seinen Superblock optimiert werden; verwenden Sie dazu den Befehl `tune2fs`(8):

- "`sudo tune2fs -l /dev/sda1`" zeigt den Inhalt des Dateisystem-Superblocks auf "`/dev/sda1`" an.

- "`sudo tune2fs -c 50 /dev/sda1`" ändert den Intervall zur Überprüfung des Dateisystems (Ausführung von `fsck` während des Systemstarts) für "`/dev/sda1`" auf jeden 50. Start.

- "`sudo tune2fs -j /dev/sda1`" fügt Journalfunktionalität zum Dateisystem hinzu; das bedeutet, dass ein ext2-Dateisystem auf "`/dev/sda1`" nach ext3 konvertiert wird. (Führen Sie dies nur bei einem nicht eingebundenen Dateisystem durch.)

- "`sudo tune2fs -O extents,uninit_bg,dir_index /dev/sda1 && fsck -pf /dev/sda1`" konvertiert ein ext3-Dateisystem auf "`/dev/sda1`" nach ext4. (Führen Sie dies nur bei einem nicht eingebundenen Dateisystem durch.)

| Tipp
Ungeachtet seines Namens funktioniert `tune2fs`(8) nicht nur für ext2-Dateisysteme, sondern auch für ext3 und ext4.

### 9.6.9. Optimierung der Festplatte

| Warnung
Bitte überprüfen Sie Ihre Hardware und lesen Sie die Handbuchseite von `hdparm`(8), bevor Sie mit der Festplattenkonfiguration herumspielen, da dies ziemlich gefährlich für die Datenintegrität sein kann.

Sie können die Zugriffsgeschwindigkeit einer Festplatte testen, für "`/dev/sda`" z.B. mit "`hdparm -tT /dev/sda`". Bei einigen Festplatten, die über (E)IDE angeschlossen sind, kann diese über "`hdparm -q -c3 -d1 -u1 -m16 /dev/sda`" erhöht werden; dabei wird "(E)IDE 32-Bit I/O-Unterstützung" aktiviert, außerdem das "using_dma-Flag" und das "interrupt-unmask-Flag" gesetzt sowie die (gefährliche!) "Multiple 16 Sector I/O"-Einstellung aktiviert.

Sie können die Cache-Funktionalität für das Schreiben auf eine Festplatte testen, für "`/dev/sda`" z.B. mit "`hdparm -W /dev/sda`". Mit "`hdparm -W 0 /dev/sda`" deaktivieren Sie diese Funktion.

Im Falle von Problemen beim Lesen von schlecht gepressten CD-ROMs in modernen Hochgeschwindigkeits-CD-ROM-Laufwerken können Sie diese möglicherweise trotzdem lesen, indem Sie mit "`setcd -x 2`" die Geschwindigkeit herabsetzen.

### 9.6.10. Optimierung von Solid State Disks

Eine Solid State Disk (SSD) wird mittlerweile automatisch detektiert.

Reduzieren Sie unnötige Laufwerkszugriffe, um die Laufwerksabnutzung zu minimieren, indem Sie "`tmpfs`" für das Einbinden schnell veränderlicher Daten in Ihrer `/etc/fstab` verwenden.

### 9.6.11. SMART verwenden, um Festplattenausfälle vorherzusehen

Sie können Ihre Festplatte mit dem `smartd`(8)-Daemon überwachen und protokollieren, sofern diese mit dem SMART-Standard kompatibel ist:

1. Aktivieren Sie die SMART-Funktionalität im BIOS.

2. Installieren Sie das Paket `smartmontools`.

3. Identifizieren Sie Ihre Festplatten, indem Sie sie mit `df`(1) auflisten.

   - Wir gehen hier davon aus, dass die zu überwachende Festplatte als "`/dev/sda`" auftaucht.

4. Überprüfen Sie die Ausgabe von "`smartctl -a /dev/sda`", um festzustellen, ob die SMART-Funktionalität derzeit wirklich aktiv ist.

   - Falls nicht, aktivieren Sie sie mit "`smartctl -s on -a /dev/sda`".

5. Aktivieren Sie den `smartd`(8)-Daemon wie folgt:

   - Entfernen Sie das Kommentarzeichen vor "`start_smartd=yes`" in der Datei "`/etc/default/smartmontools`".

   - Führen Sie einen Neustart des `smartd`(8)-Daemons über "`sudo systemctl restart smartmontools`" durch.

| Tipp
Die Einstellungen des `smartd`(8)-Daemons können über die `/etc/smartd.conf`-Datei angepasst werden; dazu gehört auch die Einstellung, auf welchem Wege Sie über Warnungen informiert werden möchten.

### 9.6.12. Angeben eines Verzeichnisses für temporäre Dateien über $TMPDIR

Anwendungen erzeugen temporäre Dateien normalerweise unterhalb des temporären Verzeichnisses "`/tmp`". Falls "`/tmp`" nicht genug freien Speicherplatz bietet, können Sie für Anwendungen, die sich diesbezüglich korrekt verhalten, auch mittels der `$TMPDIR`-Variable festlegen, welches Verzeichnis für solche temporären Daten genutzt werden soll.

### 9.6.13. Vergrößerung des nutzbaren Speicherplatzes mittels LVM

Partitionen, die bei der Installation über den Logical Volume Manager (LVM) (Linux-Funktionalität) erzeugt wurden, können einfach und ohne größere System-Neukonfiguration in der Größe verändert werden, indem Speicherplatz hinzugefügt oder entfernt wird, und zwar über die Grenzen einzelner Laufwerke hinweg.

### 9.6.14. Vergrößerung des nutzbaren Speicherplatzes über das Einbinden anderer Partitionen

Wenn Sie eine leere Partition (z.B. "`/dev/sdx`") haben, können Sie sie mit `mkfs.ext4`(1) formatieren und dann mit `mount`(8) in ein Verzeichnis einbinden, in dem Sie mehr Platz benötigen (Sie müssen die originalen Daten kopieren):

    $ 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

| Tipp
Alternativ können Sie eine leere Festplatten-Image-Datei (lesen Sie dazu Abschnitt 9.7.5, „Eine leere Abbild-Datei erstellen“) als loop-device einbinden (Näheres dazu in Abschnitt 9.7.3, „Einbinden der Festplatten-Abbild-Datei“). Die reelle Größe des Festplatten-Images wächst mit den wirklich darin abgelegten Daten.

### 9.6.15. Vergrößerung des nutzbaren Speicherplatzes, indem ein anderes Verzeichnis mit "mount --bind" eingebunden wird

Wenn Sie ein leeres Verzeichnis (z.B. "`/pfad/zu/leer`") auf einer anderen Partition haben, auf der noch Platz frei ist, können Sie dieses Verzeichnis mit der mount-Option "`--bind`" in ein anderes Verzeichnis (z.B. "`arbeit`") einbinden, in dem Sie mehr Speicherplatz benötigen:

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

### 9.6.16. Vergrößerung des nutzbaren Speicherplatzes, indem ein anderes Verzeichnis mit "Overlay-mounting" eingebunden wird

Wenn Sie freien Platz auf einer anderen Partition haben (mit 2 Verzeichnissen wie "`/pfad/zu/leer`" und "`/pfad/zu/arbeit`"), können Sie dort ein Verzeichnis erstellen und dieses einem anderen alten Verzeichnis (z.B. "`/pfad/zu/alt`") "überstülpen", in dem Sie mehr Platz benötigen. Dies wird ermöglicht durch die OverlayFS-Funktionalität im Linux-Kernel 3.18 oder neuer (ab Debian Stretch 9.0).

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

Hierbei sollten "`/pfad/zu/leer`" und "`/pfad/zu/nutzverzeichnis`" auf einer schreibbaren (RW) Partition liegen, um "`/pfad/zu/alt`" zu überlagern.

### 9.6.17. Vergrößerung des nutzbaren Speicherplatzes über einen symbolischen Link

| Achtung
Diese Methode ist überholt. Manche Software könnte nicht korrekt funktionieren mit "symbolischen Links auf ein Verzeichnis". Verwenden Sie stattdessen einen der oben beschriebenen "mounting"-basierten Ansätze.

Wenn Sie ein leeres Verzeichnis (z.B. "`/pfad/zu/leer`") auf einer anderen Partition haben, auf der noch Platz frei ist, können Sie mit `ln`(8) einen symbolischen Link zu einem anderen Verzeichnis erstellen:

    $ 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

| Warnung
Verwenden Sie solch einen symbolischen Link auf ein Verzeichnis nicht für Verzeichnisse, die von dem System verwaltet werden, wie z.B. "`/opt`". Solch ein Link könnte bei einer Systemhochrüstung überschrieben werden.

## 9.7. Das Festplatten-Abbild

Hier wird die Veränderung eines Festplatten-Abbilds behandelt.

### 9.7.1. Erzeugung der Festplatten-Abbild-Datei

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

Ein Abbild des Master Boot Record (MBR), wie er in traditionellen PCs verwendet wird (lesen Sie auch Abschnitt 9.6.2, „Konfiguration der Festplattenpartitionen“) und der im ersten Sektor der primären IDE-Festplatte abgelegt ist, kann mit `dd`(1) erstellt werden, wie hier:

    # 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`": der MBR mit der Partitionstabelle

- "`mbr-nopart.img`": der MBR ohne Partitionstabelle

- "`mbr-part.img`": die Partitionstabelle nur vom MBR

Falls Sie ein Abbild einer einzelnen Partition der Festplatte erstellen möchten, ersetzen Sie "`/dev/sda`" z.B. durch "`/dev/sda1`".

### 9.7.2. Direkt auf eine Festplatte schreiben

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

Ähnlich dazu kann mit folgendem Befehl die Abbild-Datei "`partition.img`" einer einzelnen Partition auf eine nicht eingebundene Partition passender Größe (hier z.B. die erste Partition der zweiten SCSI- oder Serial-ATA-Festplatte "`/dev/sdb1`") geschrieben werden:

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

### 9.7.3. Einbinden der Festplatten-Abbild-Datei

Das Festplatten-Abbild "`partition.img`", welches ein einfaches Partitions-Abbild enthält, kann mittels einem loop device wie folgt eingebunden und anschließend wieder gelöst werden:

    # 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

Das kann noch weiter vereinfacht werden:

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

Jede Partition des Festplatten-Abbilds "`disk.img`", das mehrere Partitionen enthält, kann mittels loop device eingebunden werden.

    # 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

Alternativ können Sie ähnliche Funktionalitäten auch erreichen, indem Sie wie hier die device-mapper-Geräte nutzen, die von `kpartx`(8) aus dem `kpartx`-Paket erzeugt werden:

    # 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. Eine Festplatten-Abbild-Datei bereinigen

Eine Festplatten-Abbild-Datei (hier "`disk.img`") kann wie folgt von allen gelöschten Dateien bereinigt und in eine gesäuberte kompakte Abbild-Datei "`new.img`" geschrieben werden:

    # 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

Wenn "`disk.img`" auf einem ext2-, ext3- oder ext4-Dateisystem liegt, können Sie auch `zerofree`(8) aus dem `zerofree`-Paket verwenden, wie hier gezeigt:

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

### 9.7.5. Eine leere Abbild-Datei erstellen

Ein leeres Festplatten-Abbild "`disk.img`", das bis zu einer Größe von 5 GiB anwachsen kann, erzeugen Sie mit `dd`(1) wie folgt:

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

Statt `dd`(1) kann hier auch das dafür spezialisierte `fallocate`(8) verwendet werden.

Mittels eines loop device erstellen Sie auf diesem Festplatten-Abbild "`disk.img`" wie folgt ein ext4-Dateisystem:

    # 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

Die Dateigröße von "`disk.img`" ist 5.0 GiB, aber der aktuell von ihm verwendete Speicherplatz ist lediglich 83 MiB. Diese Diskrepanz ist möglich, da ext4 die Verwendung von Sparse-Dateien unterstützt.

| Tipp
Der wirklich genutzte Speicherplatz von Sparse-Dateien wächst mit den Daten, die in diese hineingeschrieben werden.

Die Nutzung von Befehlen ähnlich denen aus Abschnitt 9.7.3, „Einbinden der Festplatten-Abbild-Datei“ auf Geräten, die von loop device oder device-mapper-Geräten erzeugt wurden, erlaubt Ihnen ebenfalls, das Abbild "`disk.img`" über `parted`(8) oder `fdisk`(8) zu erzeugen, sowie Dateisysteme mit `mkfs.ext4`(8), `mkswap`(8) usw. zu erstellen.

### 9.7.6. Erstellen einer ISO9660-Abbild-Datei

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

Eine ISO9660-Abbild-Datei "`cd.iso`" aus einem Quellverzeichnisbaum (hier in "`quell_verzeichnis`") kann mit `genisoimage`(1) aus dem cdrkit-Paket erstellt werden:

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

Ähnlich dazu kann ein boot-fähiges ISO9660-Abbild "`cdboot.iso`" aus einem Verzeichnisbaum ("`quell_verzeichnis`") erstellt werden, der dem des `debian-installer` ähnelt:

    #  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

Hier wird der Isolinux-Bootloader zum Booten verwendet (Näheres in Abschnitt 3.1.2, „Stufe 2: der Bootloader“).

Sie können die Berechnung der md5sum-Prüfsumme und die Erstellung eines ISO9660-Abbilds direkt von der CD-ROM durchführen, wie hier gezeigt:

    $ 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

| Warnung
Sie müssen wie oben gezeigt dafür sorgen, dass Sie nicht von einem Fehler im Linux-Kernel ("ISO9660 filesystem read ahead bug") betroffen werden; nur so können Sie korrekte Ergebnisse erhalten.

### 9.7.7. Direkt auf die CD/DVD-R/RW schreiben

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

Sie finden nutzbare Laufwerke wie folgt:

    # wodim --devices

Dann wird die leere CD-R in das Laufwerk eingelegt und die ISO9660-Abbild-Datei "`cd.iso`" wird wie folgt mit `wodim`(1) auf das Laufwerk (hier "`/dev/sda`") geschrieben:

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

Falls statt der CD-R eine CD-RW genutzt wird, verwenden Sie dies:

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

| Tipp
Wenn Ihre Arbeitsplatzumgebung CDs automatisch einbindet, lösen Sie die Einbindung mit "`sudo umount /dev/sda`" über eine Konsole, bevor Sie den `wodim`(1)-Befehl ausführen.

### 9.7.8. Einbinden einer ISO9660-Abbild-Datei

Wenn "`cd.iso`" ein ISO9660-Abbild enthält, können Sie es wie folgt in "`/cdrom`" einbinden:

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

| Tipp
Moderne Arbeitsplatzsysteme binden Wechseldatenträger (wie mit ISO9660 formatierte CDs) automatisch ein (lesen Sie dazu Abschnitt 10.1.7, „Wechseldatenträger“).

## 9.8. Binärdaten

Hier behandeln wir das Bearbeiten von Binärdaten auf einem Speichermedium.

### 9.8.1. Betrachten und Bearbeiten von Binärdaten

Die grundlegendste Methode zum Betrachten von Binärdaten ist die Verwendung des Befehls "`od -t x1`".

Tabelle 9.21. Liste von Paketen zum Betrachten und Bearbeiten von Binärdaten

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | grundlegendes Paket, das `od`(1) für die Ausgabe von Dateien (HEX, ASCII, OCTAL, …) enthält
`bsdmainutils` | V:4, I:152 | 17 | Hilfspaket, das `hd`(1) für die Ausgabe von Dateien (HEX, ASCII, OCTAL, …) enthält
`hexedit` | V:1, I:8 | 70 | Editor und Betrachter für Binärdateien (HEX, ASCII)
`bless` | V:0, I:1 | 924 | voll ausgestatteter Hexadezimal-Editor (GNOME)
`okteta` | V:1, I:12 | 1590 | voll ausgestatteter Hexadezimal-Editor (KDE4)
`ncurses-hexedit` | V:0, I:1 | 130 | Editor und Betrachter für Binärdateien (HEX, ASCII, EBCDIC)
`beav` | V:0, I:0 | 137 | Editor und Betrachter für Binärdateien (HEX, ASCII, EBCDIC, OKTAL, …)

| Tipp
HEX wird als Acronym für das Hexadezimal-Format mit einer Basis (Radix) von 16 verwendet. OKTAL steht für das Oktal-Format mit einer Basis von 8. ASCII ist der American Standard Code for Information Interchange, also für normalen englischsprachigen Text-Code. EBCDIC steht für den Extended Binary Coded Decimal Interchange Code, der auf IBM Mainframe-Betriebssystemen verwendet wird.

### 9.8.2. Manipulieren von Dateien ohne Einbinden der Festplatte

Diese Werkzeuge können Dateien lesen und schreiben, ohne dass die Festplatte dazu eingebunden werden muss:

Tabelle 9.22. Liste von Paketen zur Manipulation von Dateien ohne Einbinden der Festplatte

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`mtools` | V:7, I:54 | 400 | Hilfsprogramme zur Bearbeitung von MSDOS-Dateien
`hfsutils` | V:0, I:3 | 178 | Hilfsprogramme zur Bearbeitung von HFS- und HFS+-Dateien

### 9.8.3. Datenredundanz

Software RAID-Systeme, bereitgestellt durch den Linux-Kernel, bieten Datenredundanz auf Ebene des Kernel-Dateisystems und erreichen so eine sehr hohe Zuverlässigkeit der Datenspeicherung.

Es gibt auch Werkzeuge, die Datenredundanz für Dateien auf Ebene der Anwendungen ermöglichen und so ebenfalls eine sehr zuverlässige Datenspeicherung erlauben:

Tabelle 9.23. Liste von Werkzeugen, um Redundanz für Dateien hinzuzufügen

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`par2` | V:10, I:119 | 298 | Parity Archive Volume Set, für die Dateiüberprüfung und -reparatur
`dvdisaster` | V:0, I:1 | 1422 | Schutz vor Datenverlust/Kratzern/Alterung von CD-/DVD-Medien
`dvbackup` | V:0, I:0 | 413 | Backup-Werkzeug, das MiniDV-Camcorder verwendet (enthält `rsbep`(1))

### 9.8.4. Datenwiederherstellung und forensische Analyse

Hier einige Programme für Datenwiederherstellung und forensische Analysen:

Tabelle 9.24. Liste von Paketen für Datenwiederherstellung und forensische Analysen

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`testdisk` | V:2, I:26 | 1495 | Hilfsprogramm zum Scannen von Partitionen und Wiederherstellen von Daten
`magicrescue` | V:0, I:2 | 257 | Hilfsprogramm zur Dateiwiederherstellung mittels Suche nach "magischen Bytes"
`scalpel` | V:0, I:2 | 89 | ein sparsamer, sehr leistungsfähiger Datei-Carver
`myrescue` | V:0, I:2 | 83 | Daten von beschädigten Festplatten retten
`extundelete` | V:0, I:7 | 152 | Hilfsprogramm, um gelöschte Dateien von ext3-/ext4-Dateisystemen wiederherzustellen
`ext4magic` | V:0, I:3 | 235 | Hilfsprogramm, um gelöschte Dateien von ext3-/ext4-Dateisystemen wiederherzustellen
`ext3grep` | V:0, I:2 | 299 | Werkzeug, das bei der Wiederherstellung von gelöschten Dateien auf ext3-Dateisystemen hilft
`scrounge-ntfs` | V:0, I:1 | 49 | Datenwiederherstellungsprogramm für NTFS-Dateisysteme
`gzrt` | V:0, I:0 | 33 | Werkzeugsatz für die Wiederherstellung von gzip-Daten
`sleuthkit` | V:2, I:23 | 1729 | Werkzeuge für forensische Analysen (SleuthKit)
`autopsy` | V:0, I:1 | 1026 | grafische Oberfläche für SleuthKit
`foremost` | V:0, I:4 | 102 | forensiche Anwendung zur Datenwiederherstellung
`guymager` | V:0, I:0 | 1047 | forensisches Imaging-Werkzeug, basierend auf Qt
`dcfldd` | V:0, I:2 | 113 | erweitertes `dd` für Forensik und Sicherheit

| Tipp
Sie können gelöschte Dateien auf einem ext2-Dateisystem wiederherstellen, indem Sie `list_deleted_inodes` und den `undel`-Befehl von `debugfs`(8) (aus dem `e2fsprogs`-Paket) verwenden.

### 9.8.5. Aufsplitten einer großen in mehrere kleine Dateien

Wenn eine Datei zu groß ist, um sie als einzelne Datei zu sichern, können Sie trotzdem ein Backup davon erstellen, nachdem Sie sie in kleinere, z.B. 2000 MiB große Stücke aufgeteilt haben; später können diese Stücke wieder zur Originaldatei zusammengesetzt werden.

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

| Achtung
Stellen Sie sicher, dass Sie dort keine anderen Dateien haben, die mit einem "`x`" beginnen, um Kollisionen bei den Dateinamen zu vermeiden.

### 9.8.6. Leeren von Dateiinhalten

Zum Leeren des Inhalt einer Datei, z.B. einer Logdatei, verwenden Sie nicht `rm`(1), um die Datei zu löschen und anschließend eine neue leere Datei zu erstellen, da in der Zeit zwischen den Befehlen möglicherweise Zugriffsversuche auf die Datei erfolgen könnten. Folgender Weg ist der sicherste, um Dateiinhalte zu leeren:

    $ :>file_to_be_cleared

### 9.8.7. Dummy-Dateien

Folgende Befehle erzeugen Dummy- oder leere Dateien:

    $ 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

Sie sollten folgende Dateien vorfinden:

- "`5kb.file`" ist eine 5KB große Datei, die Nullen enthält.

- "`7mb.file`" ist eine 7MB große Datei mit zufälligem Inhalt.

- "`zero.file`" könnte eine 0 Byte große Datei sein. Falls sie bereits existierte, wurde ihr `mtime`-Attribut aktualisiert, aber der Inhalt wurde beibehalten.

- "`alwayszero.file`" ist immer eine 0 Byte große Datei. Falls sie bereits existierte, wurde ihr `mtime`-Attribut aktualisiert und der Inhalt entfernt.

### 9.8.8. Eine vollständige Festplatte löschen

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

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

Löschen Sie den kompletten Inhalt der Platte, indem Sie wie folgt die Daten auf 0 setzen:

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

Löschen Sie alles, indem Sie es wie folgt mit zufälligen Daten überschreiben:

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

Löschen Sie alles, indem Sie es wie hier auf sehr effiziente Art mit zufälligen Daten überschreiben:

    # shred -v -n 1 /dev/sda

Alternativ können Sie auch `badblocks`(8) mit der Option `-t random` verwenden.

Da `dd`(1) auf der Shell vieler boot-fähiger Linux-CDs (wie einer Debian-Installer-CD) verfügbar ist, können Sie Ihr installiertes Betriebssystem vollständig entfernen, indem Sie von solch einer CD einen Löschbefehl auf die System-Festplatte (z.B. "`/dev/sda`", "`/dev/sda`" o.ä.) ausführen.

### 9.8.9. Einen ungenutzten Bereich einer Festplatte löschen

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

| Warnung
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. Wiederherstellen von gelöschten, aber noch geöffneten Dateien

Wenn Sie versehentlich eine Datei gelöscht haben, die noch von einem Programm verwendet wird (lesend oder schreibend), ist es möglich, diese Datei wiederherzustellen.

Probieren Sie zum Beispiel folgendes:

    $ 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

Führen Sie auf einem anderen Terminal (wenn Sie das `lsof`-Paket installiert haben) folgendes aus:

    $ 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. Alle harten Links suchen

Dateien mit harten Links können mittels "`ls -li`" identifiziert werden:

    $ 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

Sowohl bei "`baz`" wie auch bei "`foo`" zeigt die Anzahl der Links von "2" (>1) an, dass für sie harte Links existieren. Sie haben beide die gemeinsame Inode-Nummer "2738404". Das bedeutet, dass dies beides die gleiche hart verlinkte Datei ist. Falls Sie nicht zufällig alle hart verlinkten Dateien finden, können Sie über die Inode (z.B. "2738404") danach suchen:

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

### 9.8.12. Unsichtbarer Verbrauch von Festplattenplatz

Alle gelöschten, aber noch geöffneten Dateien verbrauchen Festplattenplatz, obwohl dies über einen normalen `du`(1)-Befehl nicht festgestellt werden kann. Sie können wie folgt über ihre Größe aufgelistet werden:

    # lsof -s -X / |grep deleted

## 9.9. Tipps zur Datenverschlüsselung

Mit physikalischem Zugriff auf den Rechner kann jeder ganz einfach uneingeschränkte Rechte und Zugriffe auf alle Dateien auf Ihrem PC erlangen (lesen Sie dazu Abschnitt 4.6.4, „Sichern des root-Passworts“). Das passwortgeschützte Anmeldesystem ist nicht in der Lage, Ihre Privatsphäre und sensible Daten vor einem möglichen Diebstahl Ihres PCs zu schützen. Dies kann nur durch Verwendung einer Technologie zur Datenverschlüsselung erreicht werden. Obwohl GNU Privacy Guard (Näheres in Abschnitt 10.3, „Datensicherheits-Infrastruktur“) Dateien verschlüsseln kann, bedeutet es für den Benutzer einigen Aufwand.

dm-crypt ermöglicht eine automatische Datenverschlüsselung über native Linux-Kernel-Module mittels device-mapper bei minimalem Aufwand für den Benutzer.

Tabelle 9.25. Liste von Werkzeugen zur Datenverschlüsselung

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`cryptsetup` | V:30, I:80 | 465 | Werkzeug zur Verschlüsselung von blockorientierten Geräten (dm-crypt / LUKS)
`cryptmount` | V:2, I:2 | 231 | Werkzeuge zur Verschlüsselung von blockorientierten Geräten (dm-crypt / LUKS) mit Fokus auf das Einbinden/Trennen durch normale Benutzer
`fscrypt` | V:0, I:1 | 6471 | Werkzeuge für die Verschlüsselung von Linux-Dateisystemen (fscrypt)
`libpam-fscrypt` | V:0, I:0 | 5589 | PAM-Modul für die Verschlüsselung von Linux-Dateisystemen (fscrypt)

| Achtung
Datenverschlüsselung kostet CPU-Zeit usw. Verschlüsselte Daten sind nicht mehr zugänglich, wenn das zugehörige Passwort verloren ist. Bitte wägen Sie Kosten und Nutzen gegeneinander ab.

| Anmerkung
Mit dem debian-installer (Lenny und später) kann ein vollständiges Debian-System auf einer verschlüsselten Festplatte installiert werden; dabei werden dm-crypt/LUKS und initramfs verwendet.

| Tipp
In Abschnitt 10.3, „Datensicherheits-Infrastruktur“ finden Sie Infos über eine Verschlüsselungslösung, die komplett auf Benutzerebene abläuft: GNU Privacy Guard.

### 9.9.1. Verschlüsselung von Wechseldatenträgern mit 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

Dann kann er in einer modernen Arbeitsplatzumgebung wie ein normaler USB-Stick unter "`/media/benutzername/datenträgername`" eingebunden werden (Näheres hierzu in Abschnitt 10.1.7, „Wechseldatenträger“), nur dass dabei nach dem Passwort gefragt wird; dazu wird das Paket `udisks2` genutzt. Der Unterschied ist, dass jegliche Daten, die auf den Stick geschrieben werden, verschlüsselt sind. Der Passworteintrag kann auch automatisch über einen Schlüsselbund erfolgen (Näheres dazu in Abschnitt 10.3.6, „Passwort-Schlüsselbund“).

Alternativ können Sie solche Medien auch mit anderen Dateisystemen formatieren, z.B. ext4 mit "`mkfs.ext4 /dev/mapper/sdx1`". Falls btrfs genutzt wird, muss das Paket `udisks2-btrfs` installiert sein. Bei diesen Dateisystemen müssen unter Umständen der Eigentümer und die Berechtigungen der Dateien separat konfiguriert werden.

### 9.9.2. Einbinden verschlüsselter Laufwerke mit dm-crypt/LUKS

Eine verschlüsselte Plattenpartition zum Beispiel, die durch den Debian Installer mit dm-crypt/LUKS auf "`/dev/sdc5`" erstellt wurde, kann wie folgt unter "`/mnt`" eingebunden werden:

    $ 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. Der Kernel

Debian stellt für unterstützte Architekturen modulare Linux-Kernel als Pakete bereit.

Wenn Sie diese Dokumentation lesen, müssen Sie vermutlich keinen eigenen Linux-Kernel kompilieren.

### 9.10.1. Kernel-Parameter

Viele Linux-Funktionalitäten sind wie folgt über Kernel-Parameter konfigurierbar:

- Kernel-Parameter, die durch den Bootloader initialisiert werden (Näheres in Abschnitt 3.1.2, „Stufe 2: der Bootloader“);

- Kernel-Parameter, die durch `sysctl`(8) zur Laufzeit geändert werden und die über sysfs erreichbar sind (Näheres in Abschnitt 1.2.12, „procfs und sysfs“);

- Modul-Parameter, die über Argumente von `modprobe`(8) gesetzt werden, wenn ein Modul aktiviert wird (Näheres in Abschnitt 9.7.3, „Einbinden der Festplatten-Abbild-Datei“).

Nähere Details finden Sie unter "The Linux kernel user’s and administrator’s guide » The kernel’s command-line parameters" (Englisch).

### 9.10.2. Kernel-Header

Die meisten normalen Programme benötigen keine Kernel-Header und könnten im Gegenteil sogar gestört werden, wenn Sie diese direkt zum Kompilieren verwenden würden. Sie sollten stattdessen gegen die Header in "`/usr/include/linux`" und "`/usr/include/asm`" aus dem Paket `libc6-dev` kompiliert werden (diese werden auf einem Debian-System aus dem `glibc`-Quellpaket erzeugt).

| Anmerkung
Um einige Kernel-spezifische Programme wie Kernel-Module aus externen Linux-Quellen oder den automounter-Daemon (`amd`) zu kompilieren, müssen Sie den Pfad zu den entsprechenden Kernel-Headern auf der Befehlszeile mit angeben.

### 9.10.3. Kompilieren des Kernels und dazugehöriger Module

Debian hat seine eigene Methode zur Kompilierung des Kernels und zugehöriger Module.

Tabelle 9.26. Liste von Schlüsselpaketen für die Neukompilierung des Kernels auf einem Debian-System

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`build-essential` | I:504 | 17 | Pakete, die zum Bauen von Debian-Paketen essentiell nötig sind: `make`, `gcc`, …
`bzip2` | V:168, I:972 | 114 | Werkzeuge zum Komprimieren und Dekomprimieren von bz2-Dateien
`libncurses5-dev` | I:40 | 6 | Entwickler-Bibliothek und Dokumentation für ncurses
`git` | V:382, I:597 | 50172 | git: vom Linux-Kernel verwendetes verteiltes Versionskontrollsystem
`fakeroot` | V:31, I:507 | 225 | bietet eine fakeroot-Umgebung, um Pakete als nicht-root-Benutzer zu bauen
`initramfs-tools` | V:479, I:988 | 52 | Werkzeug zur Erzeugung eines initramfs (Debian-spezifisch)
`dkms` | V:74, I:146 | 235 | Dynamic Kernel Module Support (DKMS) (generisch)
`module-assistant` | V:0, I:14 | 391 | Hilfsprogramme zum Erstellen von Modulpaketen (Debian-spezifisch)
`devscripts` | V:5, I:33 | 2770 | Helfer-Skripte für Debian-Paketbetreuer (Debian-spezifisch)

Wenn Sie eine `initrd` wie in Abschnitt 3.1.2, „Stufe 2: der Bootloader“ verwenden, lesen Sie unbedingt die entsprechenden Informationen in `initramfs-tools`(8), `update-initramfs`(8), `mkinitramfs`(8) und `initramfs.conf`(5).

| Warnung
Setzen Sie in den Verzeichnissen Ihres Quellcode-Baums (z.B. "`/usr/src/linux*`") keine symbolischen Links auf "`/usr/include/linux`" and "`/usr/include/asm`" (einige veraltete Dokumentationen empfehlen dies).

| Anmerkung

Um den aktuellsten Linux-Kernel auf einem Debian-`Stable`-System zu kompilieren, könnte die Verwendung von rückportierten aktuellen Werkzeugen aus `Unstable` nötig sein.

`module-assistant`(8) (oder seine Kurzform `m-a`) unterstützt Benutzer bei Bau und Installation von Modulpaketen für einen oder mehrere selbst angepasste Kernel.

Dynamic Kernel Module Support (DKMS) ist ein neues distributions-unabhängiges Rahmenwerk, das entwickelt wurde, um die Aktualisierung einzelner Kernel-Module ohne Austausch des kompletten Kernels zu ermöglichen. Dies wird verwendet für die Betreuung von Modulen außerhalb des Linux-Quellcode-Baums. Auch ist es damit sehr einfach, im Zuge der Hochrüstung des Kernels Module neu zu bauen.

### 9.10.4. Kompilieren des Kernel-Quellcodes: Empfehlung des Debian-Kernel-Teams

Um eigene Kernel-Binärpakete aus den Upstream-Kernel-Quelltexten zu erstellen, sollten Sie das angebotene "`deb-pkg`"-Target nutzen:

    $ 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

| Tipp
Das Paket linux-source-version stellt den Linux-Kernel-Quelltext inklusive Debian-Patches als "`/usr/src/linux-version.tar.bz2`" bereit.

Um spezifische Binärpakete aus dem Debian-Kernel-Quellpaket zu bauen, sollten Sie die Targets "`binary-arch_architecture_featureset_flavour`" in "`debian/rules.gen`" verwenden:

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

Hier finden Sie weitere Informationen:

- Debian Wiki: KernelFAQ

- Debian Wiki: DebianKernel

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

### 9.10.5. Hardware-Treiber und Firmware

Der Hardware-Treiber ist Code, der auf der Haupt-CPU des Zielsystems läuft. Die meisten Hardware-Treiber sind heutzutage als freie Software verfügbar und in den normalen Debian-Kernel-Paketen im `main`-Bereich des Debian-Archivs enthalten.

- GPU-Treiber

  - Intel GPU-Treiber (`main`)

  - AMD/ATI GPU-Treiber (`main`)

  - NVIDIA GPU-Treiber (`main` für den nouveau-Treiber, `non-free` für Treiber, die vom Hersteller als Nur-Binär-Variante bereitgestellt werden)

Die Firmware ist Code, der in das (mit dem Zielsystem verbundene) Gerät geladen wird (z.B. CPU-Mikrocode, Rendering-Code, der auf der GPU läuft, oder FPGA-/CPLD-Daten …). Einige Firmware-Pakete gibt es als freie Software, aber viele davon werden nicht als freie Software bereitgestellt, da sie Binärdaten ohne den zugehörigen Quelltext enthalten. Die Installation dieses Firmware-Codes ist erforderlich, damit das Gerät wie vorgesehen funktionieren kann.

- Firmware-Pakete, die Daten enthalten, welche in den flüchtigen Speicher des Zielgeräts geladen werden:

  - 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`)

- Pakete mit Firmware-Update-Programmen, die Daten in den nicht-flüchtigen Speicher des Zielgeräts laden:

  - fwupd (`main`): Firmware-Update-Daemon, der Firmware-Daten vom Linux Vendor Firmware Service herunterlädt

  - gnome-firmware (`main`): GTK-Frontend für fwupd

  - plasma-discover-backend-fwupd (`main`): Qt-Frontend für fwupd

Bitte beachten Sie, dass die offiziellen Installationsmedien seit Debian 12 Bookworm Pakete aus `non-free-firmware` bereithalten, um den Benutzern ein funktionales Installationserlebnis zu ermöglichen.Der Archivbereich `non-free-firmware` ist in Abschnitt 2.1.5, „Grundlagen über das Debian-Archiv“ beschrieben.

Bitte beachten Sie außerdem, dass die Firmware-Daten, die über fwupd vom Linux Vendor Firmware Service heruntergeladen und in den laufenden Linux-Kernel integriert werden, ebenfalls `nicht-frei (non-free)` sein könnten.

## 9.11. Virtualisierte Systeme

Die Verwendung eines virtualisierten Systems ermöglicht es uns, mehrere Instanzen eines Systems gleichzeitig auf einer einzigen Hardware laufen zu lassen.

| Tipp
Lesen Sie die Debian-Wiki-Seite SystemVirtualization.

### 9.11.1. Virtualisierungs- und Emulationswerkzeuge

Es gibt verschiedene Virtualisierungs- und Emulations-Plattformen:

- Vollständige Hardware-Emulations-Pakete, wie die aus dem Metapaket games-emulator

- Plattformen, bei denen die CPU und einige Eingabe-/Ausgabegeräte überwiegend emuliert werden, wie z.B. QEMU

- Plattformen, bei denen die CPU und einige Eingabe-/Ausgabegeräte überwiegend virtualisiert werden, wie z.B. Kernel-based Virtual Machine (KVM) (Betriebssystemkern-basierte virtuelle Maschine)

- Container-Virtualisierung auf Betriebssytemebene mit Kernel-Level-Unterstützung, wie z.B. LXC (Linux Containers), Docker, `systemd-nspawn`(1), ...

- Dateisystemzugriff-Virtualisierung auf Betriebssystemebene, bei der der Aufruf der Systembibliotheken über den Dateipfad überschrieben/geändert wird, wie z.B. chroot

- Dateisystemzugriff-Virtualisierung auf Betriebssystemebene, bei der der Aufruf der Systembibliotheken über die Dateieigentümerschaft überschrieben/geändert wird, wie z.B.fakeroot

- Betriebssystem-API-Emulation, wie z.B. Wine

- Virtualisierung auf Interpreter-Ebene mit Überschreiben von Executable Selection und Runtime-Bibliotheken, wie z.B. virtualenv und venv für Python

Die Container-Virtualisierung nutzt Fähigkeiten aus Abschnitt 4.7.5, „Linux Sicherheits-Funktionalitäten“ sowie die Backend-Technologie aus Abschnitt 7.7, „Sandbox“.

Hier einige Pakete, die Ihnen bei der Einrichtung eines virtualisierten Systems helfen:

Tabelle 9.27. Liste von Virtualisierungswerkzeugen

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | GNU core-Hilfsprogramme, die `chroot`(8) enthalten
`util-linux` | V:897, I:999 | 4384 | miscellaneous system utilities which contain `unshare`(1)
`systemd-container` | V:72, I:76 | 2276 | systemd container/nspawn-Werkzeuge, die `systemd-nspawn`(1) enthalten
`schroot` | V:5, I:7 | 2627 | spezialisiertes Werkzeug, um Debian-Binärpakete in chroot-Umgebungen auszuführen
`sbuild` | V:1, I:4 | 157 | Werkzeug, um Debian-Binärpakete aus Debian-Quellen zu bauen
`debootstrap` | V:4, I:46 | 330 | Programm zum Bootstrap eines grundlegenden Debian-Systems (geschrieben in sh)
`mmdebstrap` | V:5, I:10 | 574 | Programm zum Bootstrap eines Debian-Systems (geschrieben in Perl)
`cdebootstrap` | V:0, I:1 | 114 | Programm zum Bootstrap eines Debian-Systems (geschrieben in C)
`cloud-image-utils` | V:0, I:14 | 66 | Management-Werkzeuge für Cloud-Images
`cloud-guest-utils` | V:4, I:18 | 71 | Cloud-Gast-Werkzeuge
`virt-manager` | V:12, I:49 | 2310 | Virtual Machine Manager: grafische Arbeitsplatzanwendung zur Verwaltung von virtuellen Maschinen
`libvirt-clients` | V:49, I:72 | 1155 | Programme für die libvirt-Bibliothek
`incus` | V:0, I:2 | 21 | Incus: System-Container und Manager für virtuelle Maschinen
`podman` | V:25, I:29 | 81828 | podman: Engine für OCI-basierte Container in Pods
`podman-docker` | V:2, I:2 | 275 | Engine für OCI-basierte Container in Pods - Wrapper für docker
`docker.io` | V:44, I:47 | 95958 | docker: Linux-Container-Runtime
`games-emulator` | I:0 | 21 | games-emulator: Debians Emulatoren für Spiele
`bochs` | V:0, I:0 | 8180 | Bochs: IA-32 PC-Emulator
`qemu-system` | I:22 | 80 | QEMU: Binärdateien zur Emulation eines vollständigen Systems
`qemu-user` | V:5, I:9 | 464225 | QEMU: Binärdateien für User-Mode-Emulation
`qemu-utils` | V:14, I:109 | 12157 | QEMU: Hilfsprogramme
`qemu-system-x86` | V:53, I:93 | 67511 | KVM: vollständige Virtualisierungslösung auf x86-Hardware mit hardware-unterstützter Virtualisierung
`virtualbox` | V:3, I:4 | 151525 | VirtualBox: x86-Virtualisierungslösung auf i386 und amd64
`gnome-boxes` | V:1, I:6 | 6847 | Boxes: einfache GNOME-App für den Zugriff auf virtuelle Systeme
`xen-tools` | V:0, I:1 | 719 | Werkzeuge zur Verwaltung von virtuellen Debian-XEN-Servern
`wine` | V:14, I:57 | 204 | Wine: Windows-API-Implementierung (Standard-Programm-Suite)
`dosbox` | V:1, I:13 | 2697 | DOSBox: x86-Emulator mit Tandy-/Herc-/CGA-/EGA-/VGA-/SVGA-Grafik, Audioausgabe und DOS
`lxc` | V:9, I:12 | 1626 | Linux-Container verwenden Werkzeuge im User-Space-Bereich
`python3-venv` | V:8, I:136 | 6 | venv zur Erzeugung von virtuellen Umgebungen für Python (Systembibliothek)
`python3-virtualenv` | V:8, I:41 | 417 | virtualenv zur Erzeugung isolierter virtueller Umgebungen für Python
`pipx` | V:7, I:43 | 3613 | pipx für die Installation von Python-Applikationen in isolierten Umgebungen

Der Wikipedia-Artikel Comparison of platform virtual machines (Englisch) enthält detaillierte Gegenüberstellungen der verschiedenen Plattform-Virtualisierungslösungen.

### 9.11.2. Arbeitsablauf bei Virtualisierung

| Anmerkung
Standard-Debian-Kernel unterstützen KVM seit `Lenny`.

Ein typischer Arbeitsablauf für eine Virtualisierung enthält folgende Schritte:

- Erzeugen eines leeren Dateisystems (ein Verzeichnisbaum oder ein Festplatten-Image);

  - Ein Verzeichnisbaum kann über "`mkdir -p /path/to/chroot`" erzeugt werden.

  - Eine rohe (leere) Image-Datei kann mittels `dd`(1) erstellt werden (lesen Sie dazu Abschnitt 9.7.1, „Erzeugung der Festplatten-Abbild-Datei“ und Abschnitt 9.7.5, „Eine leere Abbild-Datei erstellen“).

  - `qemu-img`(1) kann verwendet werden, um zu QEMU kompatible Image-Dateien zu erzeugen.

  - Rohe Image-Dateien und solche im VMDK-Format sind weit verbreitet und können bei verschiedenen Virtualisierungslösungen eingesetzt werden.

- Einbinden des Festplatten-Images in das Dateisystem mit `mount`(8) (optional);

  - Bei einer rohen Image-Datei verwenden Sie zum Einbinden ein loop device oder Device Mapper-Geräte (Näheres in Abschnitt 9.7.3, „Einbinden der Festplatten-Abbild-Datei“).

  - Festplatten-Images, die von QEMU unterstützt werden, binden Sie als Network Block Device ein (lesen Sie dazu Abschnitt 9.11.3, „Einbinden des virtuellen Festplatten-Images“).

- Bestücken des Zieldateisystems mit den benötigten Systemdaten;

  - Die Nutzung von Programmen wie `debootstrap` und `cdebootstrap` hilft Ihnen bei diesem Schritt (Details dazu in Abschnitt 9.11.4, „Chroot-System“).

  - Verwenden Sie die Installationsroutinen anderer Betriebssysteme für das in der Emulation laufende System.

- Ausführen eines Programms in der virtualisierten Umgebung;

  - chroot bietet eine grundlegende virtualisierte Umgebung, die zur Kompilierung von Programmen, Ausführung von Konsolenanwendungen sowie Daemons ausreichende Funktionalitäten hat.

  - QEMU stellt eine CPU-Emulation quer über verschiedene Plattformen zur Verfügung.

  - QEMU mit KVM bietet eine vollständige Systememulation mit hardware-unterstützter Virtualisierung.

  - VirtualBox bietet eine vollständige System-Emulation auf i386 und amd64 mit oder ohne hardware-unterstützter Virtualisierung.

### 9.11.3. Einbinden des virtuellen Festplatten-Images

Wenn Sie eine rohe Image-Datei verwenden, finden Sie die nötigen Informationen in Abschnitt 9.7, „Das Festplatten-Abbild“.

Bei anderen Dateiformaten für virtuelle Festplatten-Images können Sie `qemu-nbd`(8) verwenden, um diese über das Network Block Device-Protokoll zu exportieren; dann können sie mittels dem `nbd`-Kernelmodul in das Dateisystem eingebunden werden (mount).

`qemu-nbd`(8) unterstützt Festplattenformate, die auch von QEMU unterstützt werden. QEMU wiederum unterstützt folgende Formate: roh (raw), qcow2, qcow, vmdk, vdi, bochs, cow (User-Mode-Linux Copy-on-Write), parallels, dmg, cloop, vpc, vvfat (virtuelles VFAT) und host_device.

Das Network Block Device unterstützt Partitionen auf die gleiche Art wie das loop device (Näheres hierzu in Abschnitt 9.7.3, „Einbinden der Festplatten-Abbild-Datei“). Sie können die erste Partition von "`disk.img`" wie folgt einbinden:

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

| Tipp
Eventuell möchten Sie lediglich die erste Partition von "`disk.img`" exportieren; geben Sie dazu für `qemu-nbd`(8) die Option "`-P 1`" an.

### 9.11.4. Chroot-System

Wenn Sie eine neue Debian-Umgebung im Terminal ausprobieren möchten, empfehle ich Ihnen, chroot zu verwenden. Es ermöglicht Ihnen, Konsolenapplikationen aus Debian `Unstable` und `Testing` laufen zu lassen ohne die üblichen Risiken, die dies sonst mit sich bringt, und ohne einen Reboot des Systems. `chroot`(8) ist der elementarste Weg für solch einen Ansatz.

| Achtung
Die hier angegebenen Beispiele gehen davon aus, dass sowohl das Elternsystem wie auch das chroot-System die gleiche CPU-Architektur (`amd64`) haben.

Obwohl Sie sich eine `chroot`(8)-Umgebung auch händisch über `debootstrap`(1) erstellen können, erfordert dies einigen nicht ganz trivialen Aufwand.

Das sbuild-Paket zum Bauen von Debian-Paketen aus dem Quellcode nutzt eine chroot-Umgebung, die über das schroot-Paket verwaltet wird. Es enthält das Helfer-Skript `sbuild-createchroot`(1). Hier lernen Sie, wie dies funktioniert:

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

Sie sehen jetzt, wie `debootstrap`(8) Systemdaten für eine `unstable`-Umgebung in "`/srv/chroot/unstable-amd64-sbuild`" anlegt und so ein minimales Build-System erzeugt.

Sie können sich über `schroot`(1) in dieser Umgebung anmelden.

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

Hier sehen Sie nun, wie eine System-Shell in einer `unstable`-Umgebung erstellt wird.

| Anmerkung
Die Datei "`/usr/sbin/policy-rc.d`", die immer mit dem Rückgabewert 101 beendet wird, verhindert, dass Daemon-Programme automatisch in dieser Debian-Umgebung gestartet werden. Lesen Sie hierzu "`/usr/share/doc/init-system-helpers/README.policy-rc.d.gz`".

| Anmerkung
Einige Programme könnten unter chroot Zugriff auf mehr Dateien des Elternsystems erfordern, als `sbuild-createchroot` mit obiger Vorgehensweise bereitstellt. Zum Beispiel könnte es nötig sein, "`/sys`", "`/etc/passwd`", "`/etc/group`", "`/var/run/utmp`", "`/var/log/wtmp`" usw. über bind-mount einzubinden oder zu kopieren.

| Tipp
Das `sbuild`-Paket hilft Ihnen, ein chroot-System zu erstellen mit `schroot` als Backend, und ein Paket innerhalb dieser Umgebung zu bauen. Dies ist ideal, um Paketabhängigkeiten zu testen. Weitere Informationen finden Sie im Debian-Wiki unter sbuild sowie im sbuild-Konfigurationsbeispiel des "Guide for Debian Maintainers".

| Tipp
Der Befehl `systemd-nspawn`(1) hilft dabei, einen Befehl oder ein Betriebssystem in einem ressourcen-schonenden Container laufen zu lassen, ähnlich wie bei `chroot`. Es ist aber leistungsstärker, da es Namensräume verwendet, um Prozessbaum, IPC, Rechnername, Domainname und optional auch Netzwerk- und Benutzerdatenbanken vollständig zu virtualisieren. Siehe systemd-nspawn.

### 9.11.5. System mit mehreren Arbeitsplatzumgebungen

Wenn Sie eine neue grafische Arbeitsplatzumgebung von irgendeinem Betriebssystem ausprobieren möchten, empfehle ich Ihnen, QEMU oder KVM auf einem Debian-`Stable`-System zu verwenden, um mittels Virtualisierung mehrere Arbeitsplatzumgebungen (Desktops) sicher auf einem System laufen lassen zu können. So ist es möglich, Desktop-Anwendungen aus Debian `Unstable` und `Testing` ohne die üblichen damit verbundenen Risiken auszuführen sowie ohne einen Reboot des Systems.

Da reines QEMU sehr langsam ist, wird empfohlen, es mit KVM zu beschleunigen, falls das Host-System dies unterstützt.

Virtual Machine Manager, auch bekannt als `virt-manager`, ist ein praktisches grafisches Werkzeug für die Verwaltung von virtuellen KVM-Maschinen via libvirt.

Ein Image einer virtuellen Festplatte "`virtdisk.qcow2`", mit einem Debian-System für QEMU kann z.B. mittels Debian über das Internet installieren wie folgt erzeugt werden:

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

| Tipp
Andere GNU/Linux-Distributionen wie Ubuntu und Fedora mittels Virtualisierung laufen zu lassen ist eine tolle Möglichkeit, Tipps zur Konfiguration zu bekommen. Auch andere proprietäre Betriebssysteme können über diese GNU/Linux-Virtualisierung bequem zum Laufen gebracht werden.

Weitere Tipps finden Sie im Debian Wiki unter SystemVirtualization.

[2] Tiefergehende Anpassungsbeispiele: "Vim Galore", "sensible.vim", ...

[3] vim-pathogen war sehr populär.

Kapitel 8. I18N und L10N |  | Kapitel 10. Datenmanagement