Cap. 3. Inițializarea sistemului

# Cap. 3. Inițializarea sistemului

Este recomandabil ca administratorul de sistem să cunoască în linii mari modul în care sistemul Debian este pornit și configurat. Deși detaliile exacte se găsesc în fișierele sursă ale pachetelor instalate și în documentația acestora, pentru majoritatea dintre noi acestea sunt puțin copleșitoare.

Iată o prezentare generală a punctelor cheie ale inițializării sistemului Debian. Deoarece sistemul Debian este o țintă în mișcare, ar trebui să consultați cea mai recentă documentație.

- Debian Linux Kernel Handbook - (Manualul nucleului Debian Linux) este sursa principală de informații despre nucleul Debian.

- `bootup`(7) descrie procesul de pornire a sistemului bazat pe `systemd` . (Debian recent)

- `boot`(7) descrie procesul de pornire a sistemului bazat pe UNIX System V Release 4. (Debian mai vechi)

## 3.1. O prezentare generală a procesului de inițializare

Sistemul informatic trece prin mai multe faze ale proceselor de inițializare de la momentul pornirii până când oferă utilizatorului un sistem de operare (SO) complet funcțional.

Pentru simplitate, voi limita discuția la platforma tipică de PC cu instalarea implicită.

Procesul tipic de inițializare este ca o rachetă cu patru trepte (în cazul nostru, etape). Fiecare treaptă a rachetei predă controlul sistemului treptei următoare.

- Secțiune 3.1.1, „Etapa 1: UEFI”

- Secțiune 3.1.2, „Etapa 2: încărcătorul de pornire”

- Secțiune 3.1.3, „Etapa 3: sistemul mini-Debian”

- Secțiune 3.1.4, „Etapa 4: sistemul Debian normal”

Desigur, acestea pot fi configurate diferit. De exemplu, dacă ați compilat propriul nucleu, este posibil să săriți peste pasul cu sistemul mini-Debian. Așadar, vă rugăm să nu presupuneți că acesta este cazul pentru sistemul dvs. până nu verificați personal.

### 3.1.1. Etapa 1: UEFI

Interfața firmware extensibilă unificată (UEFI) definește un administrator de pornire ca parte a specificației UEFI. Când un calculator este pornit, administratorul de pornire este prima etapă a procesului de pornire, care verifică configurația de pornire și, pe baza parametrilor săi, execută încărcătorul de sistem de operare specificat sau nucleul sistemului de operare (de obicei încărcătorul de pornire). Configurația de pornire este definită de variabile stocate în NVRAM, inclusiv variabile care indică rutele sistemului de fișiere către încărcătoarele de sistem de operare sau nucleele sistemului de operare.

O partiție de sistem EFI (ESP) este o partiție a dispozitivului de stocare a datelor utilizată în calculatoarele care respectă specificațiile UEFI. Accesată de firmware-ul UEFI la pornirea calculatorului, aceasta stochează aplicațiile UEFI și fișierele necesare pentru rularea acestor aplicații, inclusiv programele de încărcare a sistemului de operare. (Pe sistemele PC vechi, se poate utiliza în schimb BIOS stocat în MBR.)

### 3.1.2. Etapa 2: încărcătorul de pornire

Încărcătorul de pornire este a doua etapă a procesului de pornire, care este inițiat de UEFI. Acesta încarcă imaginea nucleului sistemului și imaginea initrd în memorie și le transferă controlul. Această imagine initrd este imaginea sistemului de fișiere rădăcină, iar suportul acesteia depinde de încărcătorul de pornire utilizat.

Sistemul Debian utilizează în mod normal nucleul Linux ca nucleu implicit al sistemului. Imaginea initrd pentru nucleul Linux 5.x actual este, din punct de vedere tehnic, imaginea initramfs (sistem de fișiere RAM inițial).

Există multe opțiuni disponibile pentru încărcătoare de pornire și configurare.

Tabel 3.1. Lista încărcătorilor de pornire

pachet | popcon(popularitate) | dimensiune | initrd | încărcător de pornire | descriere
--- | --- | --- | --- | --- | ---
grub-efi-amd64 | I:436 | 142 | Compatibil | GRUB UEFI | Este suficient de inteligent pentru a înțelege partițiile de disc și sistemele de fișiere precum vfat, ext4, …. (UEFI)
grub-pc | V:16, I:539 | 479 | Compatibil | GRUB 2 | Este suficient de inteligent pentru a înțelege partițiile de disc și sistemele de fișiere precum vfat, ext4, …. (BIOS)
grub-rescue-pc | V:0, I:0 | 7323 | Compatibil | GRUB 2 | Acestea sunt imagini de recuperare ice pot fi pornite GRUB 2 (CD și dischetă) (versiunea PC/BIOS)
grml-rescueboot | V:0, I:1 | 36 | N/D | GRUB 2 plug-in | grml-rescueboot adds live Linux ISO images to the grub2 boot menu
syslinux | V:2, I:31 | 325 | Compatibil | Isolinux | Acesta înțelege sistemul de fișiere ISO9660. Acesta este utilizat de CD-ul de pornire.
syslinux | V:2, I:31 | 325 | Compatibil | Syslinux | Acesta înțelege sistemul de fișiere MSDOS (FAT). Acesta este utilizat de discheta de pornire.
loadlin | V:0, I:0 | 87 | Compatibil | Loadlin | Noul sistem este pornit din sistemul FreeDOS/MSDOS.
mbr | V:0, I:3 | 47 | Necompatibil | MBR de Neil Turton | Acesta este un software liber care înlocuiește MSDOS MBR. Acesta recunoaște numai partițiile de disc.

Pentru sistemul UEFI, GRUB2 citește mai întâi partiția ESP și utilizează UUID-ul specificat pentru `search.fs_uuid` în „`/boot/efi/EFI/debian/grub.cfg`” pentru a determina partiția fișierului de configurare a meniului GRUB2 „`/boot/grub/grub.cfg`”.

Partea esențială a fișierului de configurare a meniului GRUB2 arată astfel:

    menuentry 'Debian GNU/Linux' ... {
            load_video
            insmod gzio
            insmod part_gpt
            insmod ext2
            search --no-floppy --fs-uuid --set=root fe3e1db5-6454-46d6-a14c-071208ebe4b1
            echo    'Loading Linux 5.10.0-6-amd64 ...'
            linux   /boot/vmlinuz-5.10.0-6-amd64 root=UUID=fe3e1db5-6454-46d6-a14c-071208ebe4b1 ro quiet
            echo    'Loading initial ramdisk ...'
            initrd  /boot/initrd.img-5.10.0-6-amd64
    }

Pentru această parte din `/boot/grub/grub.cfg`, această intrare din meniu înseamnă următoarele.

Tabel 3.2. Semnificația intrării din meniul din partea de sus a `/boot/grub/grub.cfg`

parametrul | valoare
--- | ---
module GRUB2 încărcate | `gzio`, `part_gpt`, `ext2`
partiția sistemului de fișiere rădăcină utilizată | partiția identificată prin `UUID=fe3e1db5-6454-46d6-a14c-071208ebe4b1`
ruta către imaginea nucleului în sistemul de fișiere rădăcină | `/boot/vmlinuz-5.10.0-6-amd64`
parametru de pornire al nucleului utilizat | "`root=UUID=fe3e1db5-6454-46d6-a14c-071208ebe4b1 ro quiet`"
ruta către imaginea „initrd” în sistemul de fișiere rădăcină | `/boot/initrd.img-5.10.0-6-amd64`

On Debian system, "`/boot/grub/grub.cfg`" is managed by the installed GRUB package (e.g. `grub-efi-amd64`) and direct user modification to this file is deprecated. You should customize configuration files in "`/etc/grub.d/`" and "`/etc/default/grub`", instead. Then configure the GRUB configuration files and update NVRAM variables to automatically boot into Debian by:

    # dpkg-reconfigure grub-efi-amd64

| Indicație
You can show kernel boot log messages by removing "`quiet`" from the "`GRUB_CMDLINE_LINUX_DEFAULT`" value in "`/etc/default/grub`".

| Indicație
You can add GRUB splash background by placing its image file in "`/boot/grub/`".

See "`info grub`", `grub-install`(8), `grub-mkconfig`(8).

### 3.1.3. Etapa 3: sistemul mini-Debian

Sistemul mini-Debian este a treia etapă a procesului de pornire, care este inițiată de încărcătorul de pornire. Acesta rulează nucleul sistemului cu sistemul său de fișiere rădăcină în memorie. Aceasta este o etapă pregătitoare opțională a procesului de pornire.

| Notă
Termenul „sistemul mini-Debian” este inventat de autor pentru a descrie această a treia etapă a procesului de pornire în acest document. Acest sistem este denumit în mod obișnuit initrd sau sistem initramfs. Un sistem similar în memorie este utilizat de programul de instalare Debian.

Programul „`/init`” este executat ca primul program din acest sistem de fișiere rădăcină din memorie. Este un program care inițializează nucleul în spațiul utilizatorului și transferă controlul către etapa următoare. Acest mini-sistem Debian oferă flexibilitate procesului de pornire, cum ar fi adăugarea de module de nucleu înainte de procesul principal de pornire sau montarea sistemului de fișiere rădăcină ca unul criptat.

- Programul „`/init`” este un program script shell dacă initramfs a fost creat de `initramfs-tools`.

  - Puteți întrerupe această parte a procesului de pornire pentru a obține shell-ul root, furnizând „`break=init`” etc. parametrului de pornire al nucleului. Consultați scriptul „`/init`” pentru mai multe condiții de întrerupere. Acest mediu shell este suficient de sofisticat pentru a efectua o inspecție bună a hardware-ului mașinii dvs.

  - Comenzile disponibile în acest mini-sistem Debian sunt simplificate și furnizate în principal de un instrument GNU numit `busybox`(1).

- Programul „`/init`” este un program binar `systemd` dacă initramfs a fost creat de `dracut`.

  - Comenzile disponibile în acest mini-sistem Debian sunt reduse la mediul `systemd`(1).

| Atenție
Trebuie să utilizați opțiunea „`-n`” pentru comanda `mount` când vă aflați în sistemul de fișiere rădăcină numai pentru citire.

### 3.1.4. Etapa 4: sistemul Debian normal

The normal Debian system is the 4th stage of the boot process which is started by the mini-Debian system. The system kernel for the mini-Debian system continues to run in this environment. The root filesystem is switched from the one on the memory to the one on the physical storage device.

Programul init este executat ca primul program cu PID=1 pentru a efectua procesul principal de pornire a mai multor programe. Ruta implicită a fișierului pentru programul init este „`/usr/sbin/init`”, dar poate fi modificată prin parametrul de pornire al nucleului ca „`init=/ruta/către/programul-init`” .

„`/usr/sbin/init`” este legat simbolic de „`/lib/systemd/systemd`” după Debian 8 Jessie (lansat în 2015).

| Indicație
Comanda init actuală din sistemul dvs. poate fi verificată cu comanda «`ps --pid 1 -f`».

Tabel 3.3. Lista instrumentelor de pornire pentru sistemul Debian

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`systemd` | V:903, I:978 | 10639 | demon bazat pe evenimente `init`(8) pentru execuție simultană (alternativă la `sysvinit`)
`cloud-init` | V:3, I:6 | 3231 | sistem de inițializare pentru instanțele cloud de infrastructură
`systemd-sysv` | V:892, I:979 | 94 | paginile de manual și legăturile necesare pentru ca `systemd` să înlocuiască `sysvinit`
`init-system-helpers` | V:906, I:985 | 133 | instrumente auxiliare pentru comutarea între `sysvinit` și `systemd`
`initscripts` | V:17, I:69 | 203 | scripturi pentru inițializarea și oprirea sistemului
`sysvinit-core` | V:3, I:3 | 369 | instrumente System-V precum `init`(8)
`sysv-rc` | V:35, I:73 | 91 | mecanism de schimbare a nivelului de rulare de tip System-V
`sysvinit-utils` | V:715, I:999 | 106 | instrumente de tip System-V (`startpar`(8), `bootlogd`(8), …)
`lsb-base` | V:250, I:363 | 12 | Linux Standard Base 3.2 Funcționalitatea scriptului init
`insserv` | V:41, I:73 | 132 | instrument pentru organizarea secvenței de pornire utilizând dependențele scriptului LSB init.d
`kexec-tools` | V:1, I:5 | 320 | instrumentul kexec pentru reporniri `kexec`(8) (repornire la cald)
`systemd-bootchart` | V:0, I:0 | 131 | analizator de performanță al procesului de pornire
`mingetty` | V:0, I:2 | 36 | numai consolă `getty`(8)
`mgetty` | V:0, I:0 | 315 | modem inteligent `getty`(8) înlocuitor

| Indicație
Consultați Debian wiki: BootProcessSpeedup pentru cele mai recente sfaturi privind accelerarea procesului de pornire.

## 3.2. Rescue system

| Avertisment
Do not perform system administration tasks around the boot strap process without having a rescue system.

Availability of a rescue system enables us to perform challenging tasks such as:

- Booting a system from a broken boot loader installation
- Fixing a broken boot loader installation
- Extracting data from a broken unbootable system
- Editing filesystems, disk partitions, and LVM volumes involving the root filesystem

Typically, a rescue system is provided as a ISO image file and written to a removable storage media such as:

- USB flash drive prepared as Secțiune 9.7.2, „Scrierea direct pe disc”

- CD / DVD prepared as Secțiune 9.7.7, „Scrierea în mod direct pe CD/DVD-R/RW”

For simplicity, USB flash drive cases are mentioned as examples below but CD or DVD may be used as well.

| Indicație
You may need to change some UEFI NVRAM variables to boot arbitrary boot loaders on the removable storage media.

### 3.2.1. GRUB UEFI rescue system on USB

The GRUB UEFI rescue system with menu can be started by turning on system power with the "GRUB UEFI rescue system on USB" inserted.

This "GRUB UEFI rescue system on USB" is prepared by writing the Super Grub2 Disk ISO image to USB flash drive in advance.

In case of broken boot loader configuration by the installation of another operating system etc., you can fix this by:

- Start the GRUB UEFI rescue system to discover bootable installed systems automatically.

- Start the installed Debian system from the GRUB menu.

- At Linux root shell prompt:

      # dpkg-reconfigure grub-efi-amd64

| Notă
The bootable GRUB rescue ISO image can be generated by following "`info grub-mkrescue`", too. It offers a CLI GRUB shell prompt but doesn't offer automatic discovery of bootable installed systems.

### 3.2.2. Linux live rescue system on USB

The Linux live rescue system can be started by turning on system power with the "Linux live rescue system on USB" inserted.

This "Linux live rescue system on USB" can be prepared by writing one of Linux live ISO images based on Debian to a USB flash drive in advance. Here are some examples of such Linux live images.

- Debian Live images

- Kali Linux Live

- Grml Live Linux

Here are some use cases of this Linux live rescue system:

- Fix the broken boot loader configuration caused by the installation of another operating system etc.:

  - Start the Linux live rescue system.

  - Mount the partition containing the root filesystem of the unbootable installed Debian system to "`/mnt`".

  - At Linux root shell prompt:

        # chroot /mnt dpkg-reconfigure grub-efi-amd64

- Fix the broken `dpkg` package:

  - Start the Linux live rescue system.

  - Mount the partition containing the root filesystem of the installed Debian system with the broken `dpkg` package to "`/mnt`".

  - At Linux root shell prompt:

        # dpkg --root /mnt -i /mnt/var/cache/apt/archives/dpkg_old_version_amd64.deb

- Perform normally prohibited changes such as filesystem operations to the installed system (see Secțiune 9.6, „Sfaturi pentru stocarea datelor”).

| Avertisment
Your GUI screen of the Linux live system may be locked after the inactivity.

| Indicație

- It's a good idea to set your password as soon as you start a Linux live system.

- You may set your password for example by "`sudo passwd user`" from the user's shell prompt on the Linux virtual consoles (see Secțiune 1.1.6, „Console virtuale”).

- Some Linux live systems may set their default "user/password": "Debian Live" = "user/live", "Kali Linux Live" = "kali/kali"

### 3.2.3. Linux live rescue system from GRUB

The Linux live rescue system can be started from the GRUB menu entry. The GRUB configuration for this is prepared by the following:

- Install the `gmrl-rescueboot` package

- Find a Linux live ISO image which has "`/boot/grub/loopback.cfg`" in its image.

  - ISO images mentioned in Secțiune 3.2.2, „Linux live rescue system on USB” have "`/boot/grub/loopback.cfg`" in their image.

- Copy some of these Linux live ISO images to the "`/boot/grml/`" directory.

- Update GRUB menu by:

      # dpkg-reconfigure grub-efi-amd64

Upon turning on system power, the GRUB displays menu with candidates for Linux live rescue systems.

## 3.3. Systemd

### 3.3.1. Init systemd

Când sistemul Debian pornește, `/usr/sbin/init` legat simbolic la `/usr/lib/systemd` este pornit ca proces al sistemului init (`PID=1`) deținut de root (`UID=0`). Vedeți `systemd`(1).

Procesul de inițializare `systemd` generează procese în paralel pe baza fișierelor de configurare a unităților (vezi `systemd.unit`(5)), care sunt scrise în stil declarativ, în loc de stilul procedural de tip SysV.

Procesele generate sunt plasate în grupuri de control Linux individuale, denumite după unitatea căreia aparțin în ierarhia privată systemd (a se vedea cgroups și Secțiune 4.7.5, „Caracteristici de securitate Linux”).

Unitățile pentru modul sistem sunt încărcate din „Ruta de căutare a unităților sistemului” descrisă în `systemd.unit`(5). Cele principale sunt următoarele, în ordinea priorității:

- „`/etc/systemd/system/*`”: Unități de sistem create de administrator

- „`/run/systemd/system/*`”: Unități de execuție

- „`/lib/systemd/system/*`”: Unități de sistem instalate de gestionarul de pachete al distribuției

Interdependențele lor sunt specificate de directivele „`Wants=`”, „`Requires=`”, „`Before=`”, „`After=`”, … (a se vedea „MAPPING OF UNIT PROPERTIES TO THEIR INVERSES” în `systemd.unit`(5)). De asemenea, sunt definite și controalele resurselor (a se vedea `systemd.resource-control`(5)).

Sufixul fișierului de configurare al unității codifică tipurile acestora astfel:

- *.service descrie procesul controlat și supravegheat de `systemd`. Consultați `systemd.service`(5).

- *.device descrie dispozitivul expus în `sysfs`(5) ca arbore de dispozitive `udev`(7). Consultați `systemd.device`(5).

- *.mount descrie punctul de montare al sistemului de fișiere controlat și supravegheat de `systemd`. Consultați `systemd.mount`(5).

- *.automount descrie punctul de montare automată a sistemului de fișiere controlat și supravegheat de `systemd`. Consultați `systemd.automount`(5).

- *.swap descrie dispozitivul sau fișierul spațiului de interschimb (swap) controlat și supravegheat de `systemd`. Consultați `systemd.swap`(5).

- *.path descrie ruta monitorizată de `systemd` pentru activarea bazată pe rută. Consultați `systemd.path`(5).

- *.socket descrie soclul controlat și supravegheat de `systemd` pentru activarea bazată pe soclu. Consultați `systemd.socket`(5).

- *.timer descrie temporizatorul controlat și supravegheat de `systemd` pentru activarea bazată pe temporizator. Consultați `systemd.timer`(5).

- *.slice gestionează resursele cu ajutorul `cgroups`(7). Consultați `systemd.slice`(5).

- *.scope este creat programatic folosind interfețele de magistrală ale `systemd` pentru a gestiona un set de procese de sistem. Consultați `systemd.scope`(5).

- *.target grupează alte fișiere de configurare ale unității pentru a crea punctul de sincronizare în timpul pornirii. Consultați `systemd.target`(5).

La pornirea sistemului (adică, init), procesul `systemd` încearcă să pornească „`/lib/systemd/system/default.target` (în mod normal, legat simbolic la „`graphical.target`”). Mai întâi, unele unități țintă speciale (vezi `systemd.special`(7)), cum ar fi „`local-fs.target`”, „`swap.target`” și „`cryptsetup.target`”, sunt introduse pentru a monta sistemele de fișiere. Apoi, alte unități țintă sunt, de asemenea, introduse de dependențele unității țintă. Pentru detalii, citiți `bootup`(7).

`systemd` oferă funcții de compatibilitate cu versiunile anterioare. Scripturile de pornire în stil SysV din „`/etc/init.d/rc[0123456S].d/[KS]nume`” sunt în continuare analizate, iar `telinit`(8) este tradus în cereri de activare a unităților systemd.

| Atenție
Nivelurile de execuție emulate 2 până la 4 sunt toate legate prin legături simbolice la aceeași țintă „`multi-user.target`”.

### 3.3.2. Autentificarea cu systemd

Când un utilizator se conectează la sistemul Debian prin `gdm3`(8), `sshd`(8) etc., `/lib/systemd/system --user` este pornit ca proces de gestionare a serviciilor utilizatorului, deținut de utilizatorul corespunzător. Consultați `systemd`(1).

Procesul de gestionare a serviciilor utilizatorului `systemd` generează procese în paralel pe baza fișierelor de configurare declarative ale unităților (consultați `systemd.unit`(5) și `user@.service`(5)).

Unitățile pentru modul utilizator sunt încărcate din „Ruta de căutare a unităților utilizatorului” descrisă în `systemd.unit`(5). Cele principale sunt următoarele, în ordinea priorității:

- „`~/.config/systemd/user/*`”: Unități de configurare utilizator

- „`/etc/systemd/user/*`”: Unități de utilizator create de administrator

- „`/run/systemd/user/*`”: Unități de execuție

- „`/lib/systemd/user/*`”: Unități utilizator instalate de gestionarul de pachete al distribuției

Acestea sunt gestionate în același mod ca Secțiune 3.3.1, „Init systemd”.

## 3.4. Mesajele nucleului

Mesajul de eroare al nucleului afișat pe consolă poate fi configurat prin definirea nivelului lui de prag.

    # dmesg -n3

Tabel 3.4. Lista nivelurilor de eroare ale nucleului

valoarea nivelului de eroare | numele nivelului de eroare | semnificație
--- | --- | ---
0 | KERN_EMERG | sistemul este inutilizabil
1 | KERN_ALERT | trebuie să se ia imediat măsuri
2 | KERN_CRIT | condiții critice
3 | KERN_ERR | condiții de eroare
4 | KERN_WARNING | condiții de avertizare
5 | KERN_NOTICE | condiție normală, dar semnificativă
6 | KERN_INFO | informativ
7 | KERN_DEBUG | mesaje de nivel de depanare

## 3.5. Mesajele sistemului

În cadrul `systemd`, atât mesajele nucleului, cât și cele ale sistemului sunt înregistrate de serviciul jurnal `systemd-journald.service` (cunoscut și sub numele de `journald`) fie într-un fișier binar persistent sub „`/var/log/journal`”, fie într-un fișier binar volatil sub „`/run/log/journal/`”. Aceste date binare din jurnal sunt accesate prin comanda `journalctl`(1). De exemplu, puteți afișa jurnalul de la ultima pornire astfel:

    $ journalctl -b

Tabel 3.5. Lista fragmentelor tipice de comandă `journalctl`

Operația | Fragmente de comandă
--- | ---
Afişarea jurnalului pentru serviciile de sistem şi nucleu de la ultima pornire | «`journalctl -b --system`»
Afişarea jurnalului pentru serviciile utilizatorului curent de la ultima pornire | «`journalctl -b --user`»
Afișarea jurnalului de activitate al „`$unit`” de la ultima pornire | «`journalctl -b -u $unit`»
Afişarea jurnalului de activităţi al „`$unit`” (în stilul „`tail -f`”) de la ultima pornire | «`journalctl -b -u $unit -f`»

În cadrul `systemd`, instrumentul de înregistrare a sistemului `rsyslogd`(8) poate fi dezinstalat. Dacă este instalat, acesta își modifică comportamentul pentru a citi datele volatile din jurnalul binar (în loc de „`/dev/log`” implicit înainte de systemd) și pentru a crea date tradiționale permanente ASCII din jurnalul sistemului. Acest lucru poate fi personalizat prin „`/etc/default/rsyslog`” și „`/etc/rsyslog.conf`” atât pentru fișierul jurnal, cât și pentru afișarea pe ecran. Consultați `rsyslogd`(8) și `rsyslog.conf`(5). Consultați și Secțiune 9.3.2, „Analizator de jurnale”.

## 3.6. Gestionarea sistemului

Sistemul `systemd` oferă nu numai sistemul init, ci și operații generice de gestionare a sistemului cu comanda `systemctl`(1).

Tabel 3.6. Lista fragmentelor tipice de comenzi `systemctl`

Operația | Fragmente de comandă
--- | ---
Listează toate tipurile de unități disponibile | «`systemctl list-units --type=help`»
Listează toate unitățile țintă din memorie | «`systemctl list-units --type=target`»
Afișează toate unitățile de serviciu din memorie | «`systemctl list-units --type=service`»
Listează toate unitățile de dispozitiv din memorie | «`systemctl list-units --type=device`»
Listează toate unitățile de montare din memorie | «`systemctl list-units --type=mount`»
Afișează toate unitățile de soclu din memorie | «`systemctl list-sockets`»
Afișează toate unitățile de temporizare din memorie | «`systemctl list-timers`»
Pornește „`$unit`” | «`systemctl start $unit`»
Oprește „`$unit`” | «`systemctl stop $unit`»
Reîncarcă configurația specifică serviciului | «`systemctl reload $unit`»
Oprește și pornește toate „`$unit`” | «`systemctl restart $unit`»
Pornește „`$unit`” și oprește toate celelalte unități | «`systemctl isolate $unit`»
Comută la „`graphical`” (sistem GUI, cu interfață grafică) | «`systemctl isolate graphical`»
Comută la „`multi-user`” (sistem CLI, cu interfață de linie de comandă) | «`systemctl isolate multi-user`»
Comută la „`rescue`” (sistem CLI, cu interfață de linie de comandă, mono-utilizator) | «`systemctl isolate rescue`»
Trimite semnalul de omorâre către „`$unit`” | «`systemctl kill $unit`»
Verifică dacă serviciul „`$unit`” este activ | «`systemctl is-active $unit`»
Verifică dacă serviciul „`$unit`” a eșuat | «`systemctl is-failed $unit`»
Verificăi starea „`$unit|$PID|dispozitiv`” | «`systemctl status $unit|$PID|$device`»
Afișează proprietățile „`$unit|$job`” | «`systemctl show $unit|$job`»
Reinițializează „`$unit`” eșuată | «`systemctl reset-failed $unit`»
Listează dependențele tuturor serviciilor de unitate | «`systemctl list-dependencies --all`»
Listează fișierele de unitate instalate în sistem | «`systemctl list-unit-files`»
Activează „`$unit`” (adaugă legătură simbolică) | «`systemctl enable $unit`»
Dezactivează „`$unit`” (elimină legătura simbolică) | «`systemctl disable $unit`»
Demască „`$unit`” (elimină legătura simbolică către „`/dev/null`”) | «`systemctl unmask $unit`»
Maschează „`$unit`” (adaugă legătură simbolică la „`/dev/null`”) | «`systemctl mask $unit`»
Obține configurația țintei implicite | «`systemctl get-default`»
Stabilește ținta implicită la „`graphical`” (sistem GUI, cu interfață grafică) | «`systemctl set-default graphical`»
Stabilește ținta implicită la „`multi-user`” (sistem CLI, cu interfață de linie de comandă) | «`systemctl set-default multi-user`»
Afișează mediul de lucru | «`systemctl show-environment`»
Definește „`variabila`” din mediul de lucru la „`valoare`” | «`systemctl set-environment variabilă=valoare`»
Elimină definiția (valoarea) „`variabilei`” din mediul de lucru | «`systemctl unset-environment variabilă`»
Reîncarcă toate fișierele de unitate și demonii | «`systemctl daemon-reload`»
Închide(oprește) sistemul | «`systemctl poweroff`»
Oprește și repornește sistemul | «`systemctl reboot`»
Suspendă sistemul | «`systemctl suspend`»
Hibernează sistemul | «`systemctl hibernate`»

Aici, „`$unit`” din exemplele de mai sus poate fi un singur nume de unitate (sufixele precum `.service` și `.target` sunt opționale) sau, în multe cazuri, mai multe specificații de unități (modele globale de tip shell „`*`”, „`?`”, „`[]`” folosind `fnmatch`(3) care vor fi comparate cu numele primare ale tuturor unităților aflate în prezent în memorie).

Comenzile de modificare a stării sistemului din exemplele de mai sus sunt precedate de obicei de „`sudo`” pentru a obține privilegiile administrative necesare.

Rezultatul comenzii „`systemctl status $unit|$PID|$device`” utilizează culoarea punctului („●”) pentru a rezuma starea unității dintr-o privire.

- Culoarea albă a „●” indică starea „inactivă” sau „dezactivată”.

- Culoarea roșie a „●” indică o stare „eșuată” sau „de eroare”.

- Culoarea verde a „●” indică starea „activă”, „reîncărcare” sau „de activare”.

## 3.7. Alte monitoare de sistem

Iată o listă cu alte fragmente de comenzi de monitorizare sub `systemd`. Vă rugăm să citiți paginile de manual relevante, inclusiv `cgroups`(7).

Tabel 3.7. Lista altor fragmente de comenzi de monitorizare sub `systemd`

Operația | Fragmente de comandă
--- | ---
Afișează timpul petrecut pentru fiecare etapă de inițializare | «`systemd-analyze time`»
Listează toate unitățile în funcție de timpul necesar pentru inițializare | «`systemd-analyze blame`»
Încarcă și detectează erorile din fișierul „`$unit`” | «`systemd-analyze verify $unit`»
Afișează informații succinte despre starea de rulare a utilizatorului sesiunii apelantului | «`loginctl user-status`»
Afișează informații succinte despre starea de rulare a sesiunii apelantului | «`loginctl session-status`»
Urmărește procesul de pornire prin cgroups | «`systemd-cgls`»
Urmărește procesul de pornire prin cgroups | «`ps xawf -eo pid,user,cgroup,args`»
Urmărește procesul de pornire prin cgroups | Citiți sysfs sub „`/sys/fs/cgroup/`”

## 3.8. Configurația sistemului

### 3.8.1. Numele gazdei

Nucleul menține numele de gazdă al sistemului. Unitatea de sistem pornită de `systemd-hostnamed.service` definește numele de gazdă al sistemului la pornire ca fiind numele stocat în „`/etc/hostname`”. Acest fișier trebuie să conțină numai numele de gazdă al sistemului, nu un nume de domeniu complet calificat.

Pentru a imprima numele actual al gazdei, executați `hostname`(1) fără niciun argument.

### 3.8.2. Sistemul de fișiere

Opțiunile de montare ale sistemelor de fișiere normale de disc și de rețea sunt definite în „`/etc/fstab`”. Consultați `fstab`(5) și Secțiune 9.6.7, „Optimizarea sistemului de fișiere prin opțiuni de montare”.

Configurația sistemului de fișiere criptat este definită în „`/etc/crypttab`”. Consultați `crypttab`(5)

Configurația RAID software cu `mdadm`(8) este definită în „`/etc/mdadm/mdadm.conf`”. Consultați `mdadm.conf`(5).

| Avertisment
După montarea tuturor sistemelor de fișiere, fișierele temporare din „`/tmp`”, „`/var/lock`” și „`/var/run`” sunt șterse la fiecare pornire.

### 3.8.3. Inițializarea interfeței de rețea

Interfețele de rețea sunt inițializate de obicei din „`networking.service`” pentru interfața `lo` și din „`NetworkManager.service`” pentru alte interfețe în sistemele Debian moderne sub `systemd`.

Consultați Cap. 5, Configurarea rețelei pentru a afla cum să le configurați.

### 3.8.4. Inițializarea sistemului cloud

Instanța sistemului cloud poate fi lansată ca o clonă a „Imaginilor cloud oficiale Debian” sau a unor imagini similare. Pentru o astfel de instanță de sistem, caracteristici precum numele gazdei, sistemul de fișiere, rețeaua, configurația regională, cheile SSH, utilizatorii și grupurile pot fi configurate folosind funcționalitățile oferite de pachetele `cloud-init` și `netplan.io` cu mai multe surse de date, cum ar fi fișierele plasate în imaginea originală a sistemului și datele externe furnizate în timpul lansării sale. Aceste pachete permit configurarea declarativă a sistemului utilizând date YAML.

Pentru mai multe informații, consultați „Cloud Computing cu Debian și descendenții săi”, „Documentația Cloud-init” și Secțiune 5.4, „Configurația modernă a rețelei pentru cloud”.

### 3.8.5. Exemplu de personalizare pentru ajustarea serviciului sshd

Cu instalarea implicită, multe servicii de rețea (a se vedea Cap. 6, Aplicații de rețea) sunt pornite ca procese demon după `network.target` la pornire de către `systemd`. „`sshd`” nu face excepție. Să schimbăm acest lucru în pornirea la cerere a „`sshd`” ca exemplu de personalizare.

Mai întâi, dezactivați unitatea de serviciu instalată în sistem.

     $ sudo systemctl stop sshd.service
     $ sudo systemctl mask sshd.service

Sistemul de activare la cerere a soclurilor serviciilor Unix clasice se realiza prin intermediul superserverului `inetd` (sau `xinetd`). În cadrul `systemd`, echivalentul poate fi activat prin adăugarea fișierelor de configurare a unităților *.socket și *.service.

`sshd.socket` pentru specificarea unui soclu pe care să se asculte

    [Unit]
    Description=SSH Socket for Per-Connection Servers

    [Socket]
    ListenStream=22
    Accept=yes

    [Install]
    WantedBy=sockets.target

`sshd@.service` ca fișier de serviciu corespunzător pentru `sshd.socket`

    [Unit]
    Description=SSH Per-Connection Server

    [Service]
    ExecStart=-/usr/sbin/sshd -i
    StandardInput=socket

Apoi reîncărcați.

     $ sudo systemctl daemon-reload

## 3.9. Sistemul udev

Sistemul udev oferă un mecanism pentru detectarea și inițializarea automată a hardware-ului (a se vedea `udev`(7)) începând cu nucleul Linux 2.6. La detectarea fiecărui dispozitiv de către nucleu, sistemul udev pornește un proces de utilizator care folosește informații din sistemul de fișiere sysfs (a se vedea Secțiune 1.2.12, „procfs și sysfs”), încarcă modulele de nucleu necesare utilizând programul `modprobe`(8) (a se vedea Secțiune 3.10, „Inițializarea modulelor de nucleu”) și creează nodurile de dispozitiv corespunzătoare.

| Indicație

Dacă „`/lib/modules/versiunea-nucleului/modules.dep`” nu a fost generat corect de `depmod`(8) din anumite motive, este posibil ca modulele să nu fie încărcate așa cum se așteaptă sistemul udev. Executați „`depmod -a`” pentru a remedia problema.

Pentru regulile de montare din „`/etc/fstab`”, nodurile dispozitivelor nu trebuie să fie statice. Puteți utiliza UUID pentru a monta dispozitive în locul numelor de dispozitive, cum ar fi „`/dev/sda`”. Consultați Secțiune 9.6.3, „Accesarea partiției folosind UUID”.

Deoarece sistemul udev este o țintă în continuă schimbare, las detaliile pentru alte documentații și descriu aici doar informațiile minimale.

| Avertisment
Nu încercați să rulați programe de lungă durată, cum ar fi scriptul de copie de rezervă, cu `RUN` în regulile udev, așa cum se menționează în `udev`(7). Creați în schimb un fișier `systemd.service`(5) adecvat și activați-l. Consultați Secțiune 10.2.3.2, „Mount event triggered backup”.

## 3.10. Inițializarea modulelor de nucleu

Programul `modprobe`(8) ne permite să configurăm nucleul Linux în execuție din procesul utilizatorului prin adăugarea și eliminarea modulelor nucleului. Sistemul udev (a se vedea Secțiune 3.9, „Sistemul udev”) automatizează invocarea acestuia pentru a ajuta la inițializarea modulului nucleului.

Există module non-hardware și module speciale de controlor hardware, precum cele enumerate mai jos, care trebuie preîncărcate prin listarea lor în fișierul „`/etc/modules`” (consultați `modules`(5)).

- Modulele TUN/TAP furnizează dispozitive de rețea virtuale punct-la-punct (TUN) și dispozitive de rețea Ethernet virtuale (TAP),

- modulele netfilter care oferă funcționalități de paravan de protecție netfilter (`iptables`(8), Secțiune 5.7, „Infrastructura netfilter”), și

- și modulul controlorului watchdog timer.

Fișierele de configurare pentru programul `modprobe`(8) se află în directorul „`/etc/modprobes.d/`”, așa cum se explică în `modprobe.conf`(5). (Dacă doriți să evitați încărcarea automată a anumitor module ale nucleului, luați în considerare adăugarea acestora pe lista neagră din fișierul „`/etc/modprobes.d/blacklist`”.)

Fișierul „`/lib/modules/versiune/modules.dep`” generat de programul `depmod`(8) descrie dependențele modulelor utilizate de programul `modprobe`(8).

| Notă
Dacă întâmpinați probleme la încărcarea modulelor la pornirea sistemului sau cu `modprobe`(8), comanda „`depmod -a`” poate rezolva aceste probleme prin reconstruirea fișierului „`modules.dep`”.

Programul `modinfo`(8) afișează informații despre un modul al nucleului Linux.

Programul `lsmod`(8) formatează conținutul „`/proc/modules`”, arătând ce module ale nucleului sunt încărcate în prezent.

| Indicație
Puteți identifica hardware-ul exact din sistemul dvs. Consultați Secțiune 9.5.3, „Identificarea hardware-ului”. Puteți configura hardware-ul la pornire pentru a activa funcțiile hardware dorite. Consultați Secțiune 9.5.4, „Configurația hardware”. Probabil puteți adăuga suport pentru dispozitivul dvs. special prin recompilarea nucleului. Consultați Secțiune 9.10, „Nucleul”.

Cap. 2. Gestionarea pachetelor Debian |  | Cap. 4. Autentificare și controale de acces