PicciHud/mywiki
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added new config files

Browse Source
This commit is contained in:
piccihud
2023-09-02 13:54:58 +02:00
parent 7b026897fe
commit e36bdb347a
15 changed files with 43 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
linux/filesystem/asset/fstab/fstab.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 22 KiB

144
linux/filesystem/dd.md Normal file
View File

@@ -0,0 +1,144 @@
# dd
`dd` è un comando che serve a copiare `blocchi di dati` grezzi da una sorgente verso una destinazione.
Il concetto è molto differente dalla semplice copia, infatti agisce direttamente a basso livello, cioé bit per bit.
Normalmente questo strumento è utilizzato per le seguenti motivazioni:
- formattazione a basso livello;
- backup di intere partizioni;
- creazione di dischi di avvio.
## Sintassi
La sintassi base di dd è la seguente:
```bash
dd if=FILEINPUT of=FILEOUTPUT
```
È doverosa qui una precisazione: su un sistema UNIX `qualunque cosa è un file`, anche un drive esterno.
## Specificare la dimensione dei blocchi
Quando si scrive a basso livello è bene ricordarsi che i byte scritti vengono sempre inviati nel file di uscita a blocchi.
Per specificare la dimensione di questi blocchi vi sono essenzialmente tre possibili parametri:
- `ibs`= numero di byte per la dimensione del blocco in ingresso;
- `obs`= numero di byte per la dimensione del blocco in uscita;
- `bs`= numero di byte per la dimensione di entrambi i blocchi
Il valore default di questi parametri è 512.
Si possono specificare delle unità di misura, come Kilo (K), Mega (M), Giga (G) e così via…
Ad esempio per trasferire 8 Mega alla volta:
```bash
dd if=nomefile of=nomefile bs=8M
```
### Numero blocchi trasferiti
Si può inserire il numero di blocchi che devono essere trasferiti con il parametro `count`. Ad esempio per trasferire 4MB bisogna scrivere:
```bash
dd if=nomefile of=nomefile count=8000 iflag=fullblock
```
> Ad esempio, per trasferire 2GiB in blocchi da 8M, sono necessari $2048/8 = 256$ blocchi
Il flag `iflag=fullblock` assicura che vengano trasferiti i blocchi nella dimensione intera.
## Visualizzare lo stato del comando
Il flag `status=progress` consente di visualizzare lo stato di avanzamento del comando:
```bash
dd if=FILEINPUT of=FILEOUTPUT status=progress
```
## Esempi d’uso
Per individuare una periferica di archiviazione attaccata utilizziare il comando:
```bash
blkid
```
Un output tipo potrebbe essere:
```bash
/dev/sda1: UUID="b4c1041e-7027-4619-aaa5-900e24c1fdee" BLOCK_SIZE="4096" TYPE="ext4"
/dev/sda2: UUID="dc1014fd-6c84-4dcd-acc3-13e914685136" TYPE="swap"
/dev/sdb1: UUID="3255683f-53a2-4fdf-91cf-b4c1041e2a62" BLOCK_SIZE="4096" TYPE="ext4"
```
Quello sull’estrema sinistra è un identificativo che rappresenta una particolare partizione del disco, nel primo caso è /dev/sda1 e nell’ultimo /dev/sdb1.
La lettera rappresenta univocamente il disco, mentre il numero la partizione.
Nel caso di nvme e di supporti sd potrebbe cambiare la nomenclatura, ma il concetto è sempre simile.
### Scrittura di un immagine iso
L’utilizzo più famoso è forse quello di scrittura di un immagine iso in una pen-drive. Per prima cosa si deve creare il file-system col comando [mkfs](./mount.md)
Scaricato e individuato il file iso (ad esempio /percorso/file/immagine.iso) bisogna prima individuare il supporto d’uscita, utilizzando il comando `blkid`.
Quindi nel comando dd utilizzare come file di INPUT l’immagine iso e come file di OUTPUT il disco.
Il block size dovrebbe essere allineato alla capacità di scrittura della pen-drive e della porta usb del pc, affinché sia possibile sfruttare più buffer:
```bash
dd if=/percorso/file/immagine.iso of=/dev/sda status=progress bs=8M
```
### Formattare un dispositivo
Per azzerare un dispositivo viene utilizzato un file virtuale creato da GNU/Linux contenente tutti e soli zeri che si trova nel percorso `/dev/zero`.
Quindi scrivere il comando dd utilizzando come file di INPUT /dev/null, mentre come file di OUTPUT il disco.
```bash
dd if=/dev/zero of=/dev/sda status=progress bs=8M
```
### Backup
Con dd si può effettuare il backup di interi dischi.
Quindi utilizzare il disco come parametro di INPUT e un file come parametro di OUTPUT. Il file sarà necessariamente un file IMG (immagine disco).
```bash
dd if=/dev/sda of=/percorso/backup.img status=progress bs=8M
```
Si può poi ripristinare invertendo gli operandi. Si può applicare il concetto anche alle partizioni:
```bash
dd if=/dev/sda1 of=/percorso/backupp1.img status=progress bs=8M
```
#### Backup e compressione
Se non viene specificato alcun file di output, viene utilizzato lo standard output del sistema.
Questo permette di concatenare `dd` con altri comandi, ad esempio gzip, in modo da poter fare un backup che viene compresso al volo:
```bash
dd if=/dev/sda | gzip > /percorso/backup.gz
```
### Clonazione di un disco
`dd` copia bit a bit. Questo significa che se si tenta di duplicare una partizione o un disco, copierà anche lo spazio libero.
Quindi, ad esempio, se si clona un disco rigido con 4 TB, si avrà bisogno di un'unità di destinazione con almeno 4 TB.
```bash
dd if=/dev/sda of=/dev/sdb status=progress bs=8M conv=noerror,sync
```
Con l'opzione `conv-noerror` eventuali errori saranno ignorati. Il programma proseguirà fino al blocco finale senza fermarsi.
Se utilizzato in combinazione con `noerror`, `sync` assicurerà che eventuali blocchi di dati mancanti vengano automaticamente riempiti con informazioni nulle.
## Collegamenti
- [https://linuxhub.it/articles/howto-usare-dd/](https://linuxhub.it/articles/howto-usare-dd/)
- [https://linuxhandbook.com/dd-command/](https://linuxhandbook.com/dd-command/)

200
linux/filesystem/formatfs.md Normal file
View File

@@ -0,0 +1,200 @@
# Formattare un device da terminale
## Identificare la periferica
Per identificare la periferica in questione si possono utilizzare diversi comandi:
```bash
sudo fdisk -l
sudo blkid
df
```
Ecco un esempio:
```bash
sudo blkid
[sudo] password di davide:
/dev/mapper/luks-44d72477-5d0f-4d0d-a54b-f721a7e5a320: UUID="cd370d97-dd7c-41d1-9b53-1504c89f64fd" TYPE="swap"
/dev/nvme0n1p1: UUID="487ce502-4541-488c-b07f-ea2ac4e91b9f" TYPE="crypto_LUKS" PARTUUID="0559b9a4-01"
/dev/nvme0n1p2: UUID="44d72477-5d0f-4d0d-a54b-f721a7e5a320" TYPE="crypto_LUKS" PARTUUID="0559b9a4-02"
/dev/mapper/luks-487ce502-4541-488c-b07f-ea2ac4e91b9f: UUID="ce884a78-4404-4ea9-b6e7-d543bfb38a41" BLOCK_SIZE="4096" TYPE="ext4"
/dev/sda1: BLOCK_SIZE="2048" UUID="2022-12-17-13-13-38-00" LABEL="d-live nf 11.6.0 kd amd64" TYPE="iso9660" PTUUID="66641822" PTTYPE="dos" PARTUUID="66641822-01"
/dev/sda2: SEC_TYPE="msdos" UUID="DEB0-0001" BLOCK_SIZE="512" TYPE="vfat" PARTUUID="66641822-02"
```
oppure
```bash
df
File system 1K-blocchi Usati Disponib. Uso% Montato su
udev 7084012 0 7084012 0% /dev
tmpfs 1426036 2380 1423656 1% /run
/dev/dm-0 446217344 113436124 310041144 27% /
tmpfs 7130160 6748 7123412 1% /dev/shm
tmpfs 5120 16 5104 1% /run/lock
tmpfs 1426032 164 1425868 1% /run/user/1000
/dev/sda1 3600960 3600960 0 100% /media/davide/d-live nf 11.6.0 kd amd64
```
La chiavetta USB è identificata in questo caso come `/dev/sda` (/dev/sda1 e /dev/sda2 sono le due partizioni).
Per il comando `blkid` e sull'uuid vedere [qui](./uuid.md)
## Partizionare un disco con fdisk
Il programma più comune per partizionare un disco utilizzando la shell è `fdisk`. Il comando fdisk chiederà di specificare come argomento il nome del disco fisso da partizionare:
```bash
fdisk /dev/hdb
```
Nell'elenco che segue sono riportati i comandi di utilizzo più comune:
```bash
m: visualizza l'help
p: visualizza la tabella corrente delle partizioni
d: cancella una partizione
n: crea una nuova partizione
w: scrive la tabella delle partizioni sul disco
t: imposta il tipo di filesystem previsto per la partizione
a: abilita/disabilita il flag che rende la partizione avviabile (boot flag)
l: visualizza l'elenco dei tipi di filesystem utilizzabili
q: chiude fdisk senza modificare il disco
Create a new label
g create a new empty GPT partition table
G create a new empty SGI (IRIX) partition table
o create a new empty DOS partition table
s create a new empty Sun partition table
```
fdisk supporta diversi schemi di partizionamento. `MBR` e `GPT` sono i due standard più popolari. GPT è uno standard più recente che consente molti vantaggi rispetto all'MBR.
I punti principali da considerare quando si sceglie quale standard di partizionamento usare:
- Utilizzare MBR per avviare il disco in modalità BIOS legacy;
- Utilizzare GPT per avviare il disco in modalità UEFI;
- Lo standard MBR supporta la creazione di una partizione del disco fino a 2 TiB. Altrimenti usare GPT;
- MBR ha un limite di 4 partizioni primarie, GPT fino a 128 partizioni
Premere `g` per creare una nuova tabella delle partizioni GPT:
L'output sarà simile al seguente:
```bash
Created a new GPT disklabel (GUID: 034596B2-1998-B241-BD8A-029063BDB87E).
```
Il prossimo passo sarà creare le nuove partizioni.
Premere `n` per creare una nuova partizione.
Verrà richiesto di inserire il numero di partizione. Premere [Invio] per utilizzare il valore predefinito (1):
```bash
Partition number (1-128, default 1): 1
```
Successivamente, il comando chiederà di specificare il primo settore. Generalmente si consiglia sempre di utilizzare i valori predefiniti. Premere [Invio] per utilizzare il valore predefinito (2048):
```bash
First sector (2048-500118158, default 2048):
```
Ora è necessario inserire l'ultimo settore. È possibile utilizzare un valore assoluto oppure un valore relativo al settore iniziale, utilizzando il simbolo + seguito dalla dimensione della partizione. La dimensione può essere specificata in kilobyte (K), megabytes (M), gigabytes (G), terabytes (T) o petabytes (P).
Ad esempio, per creare una partizione di 100 GB, digitare `+100G` e premere [Invio]:
```bash
Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-500118158, default 500118158): +100G
Created a new partition 1 of type 'Linux filesystem' and of size 100 GiB.
```
Per impostazione predefinita, il tipo di partizione è impostato su *filesystem Linux*, che dovrebbe andare bene per la maggior parte dei casi. Se si desidera modificare il tipo, premere `l` per ottenere un elenco di tipi di partizione, quindi premere `t` per modificare il tipo.
Infine premere `w` per scrivere le modifiche.
## Formattazione della periferica
Smontare la chiavetta USB:
```bash
sudo umount /dev/sda
```
### NTFS
Smontata la chiavetta dal sistema, digitare:
```bash
mkfs.ntfs /dev/sda -v
```
### EXT4
```bash
mkfs.ext4 /dev/sda -v
```
Un esempio:
```bash
sudo mkfs.ext4 -L "DAVIDE4GB" /dev/sda -v
mke2fs 1.46.6 (1-Feb-2023)
fs_types for mke2fs.conf resolution: 'ext4'
/dev/sda contains a ext4 file system
last mounted on Sun Mar 19 12:18:08 2023
Proceed anyway? (y,N) y
Filesystem label=DAVIDE4GB
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
237104 inodes, 947456 blocks
47372 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=970981376
29 block groups
32768 blocks per group, 32768 fragments per group
8176 inodes per group
Filesystem UUID: 62fd2424-ae9d-45f8-84d9-5a3b63020661
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736
Allocating group tables: done
Writing inode tables: done
Creating journal (16384 blocks): done
Writing superblocks and filesystem accounting information: done
```
dove `-L` specifica il nome del filesystem, così che sia identificabile più facilmente. L'opzione `-v` indica *verbose*.
## Verificare la Formattazione
```bash
sudo fsck /dev/sda
sudo fsck /dev/sda
fsck da util-linux 2.38.1
e2fsck 1.46.6 (1-Feb-2023)
/dev/sda is mounted.
e2fsck: Cannot continue, aborting.
```
Oppure col comando:
```bash
sudo file -sL /dev/sda
```
Ora che le partizioni sono state create, il passaggio successivo consiste nel formattare le partizioni e montarle.
## Collegamenti
- [https://www.chimerarevo.com/guide/linux-formattare-pendrive-usb-terminale-411029/](https://www.chimerarevo.com/guide/linux-formattare-pendrive-usb-terminale-411029/)
- [https://phoenixnap.com/kb/linux-format-usb](https://phoenixnap.com/kb/linux-format-usb)
- [https://wiki.archlinux.org/title/File_systems](https://wiki.archlinux.org/title/File_systems)
- [https://linuxhandbook.com/mkfs-command/](https://linuxhandbook.com/mkfs-command/)
- [https://www.thegeekdiary.com/mkfs-ext4-command-examples-in-linux/](https://www.thegeekdiary.com/mkfs-ext4-command-examples-in-linux/)
- [https://guide.debianizzati.org/index.php/Guida_alla_formattazione_dei_dischi_con_fdisk](https://guide.debianizzati.org/index.php/Guida_alla_formattazione_dei_dischi_con_fdisk)
- [https://guide.debianizzati.org/index.php/Guida_ai_comandi_da_terminale_-_Gestione_del_File_System](https://guide.debianizzati.org/index.php/Guida_ai_comandi_da_terminale_-_Gestione_del_File_System)
- [https://noviello.it/come-creare-partizioni-con-fdisk-su-linux/](https://noviello.it/come-creare-partizioni-con-fdisk-su-linux/)

87
linux/filesystem/fstab.md Normal file
View File

@@ -0,0 +1,87 @@
# fstab
Il file di configurazione `/etc/fstab` contiene le informazioni necessarie al montaggio delle periferiche di memorizzazione del sistema.
Tale file viene letto all'avvio del sistema per determinare quali opzioni utilizzare per montare una specifica periferica o una partizione.
![fstab](./asset/fstab/fstab.jpg)
Per visualizzare il contenuto del file, digitare:
```bash
cat /etc/fstab
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
# <file system> <mount point> <type> <options> <dump> <pass>
# /dev/sda1
UUID=12102C02102CEB83 /media/windows ntfs silent,umask=0,locale=it_IT.utf8 0 0
# /dev/sda2
UUID=cee15eca-5b2e-48ad-9735-eae5ac14bc90 none swap sw 0 0
# /dev/sda3
UUID=98E0-6D24 /media/dati vfat defaults,utf8,umask=007,uid=0,gid=46,auto,rw,nouser 0 0
# /dev/sda4
UUID=0aa86c61-0df9-4f1a-8b0b-34abbee6b769 / ext3 nouser,defaults,errors=remount-ro,atime,auto,rw,dev,exec,suid 0 0
/dev/sr0 /media/cdrom0 udf,iso9660 user,noauto 0 0
```
Le periferiche vengono identificate dal proprio *Universally Unified IDentifier* o [UUID](./uuid.md). Quest'ultimo è un particolare codice identificativo, virtualmente univoco, che viene assegnato dal programma di generazione del filesystem, quando la partizione viene creata o formattata.
## Parametri
| Campo | Descrizione
|----|----|
file system | indica il dispositivo
mount point | indica la directory (o mount point) dalla quale sarà possibile accedere al contenuto del dispositivo (per la swap non è richiesto il mount point)
type | tipo di file system
options | opzioni di accesso al dispositivo (per maggiori informazioni consultare la tabella successiva)
dump | attiva/disattiva il backup del filesystem (comando dump)
pass | attiva/disattiva il controllo di coerenza del disco (comando fsck) i valori possibili sono 0, 1 e 2. In genere si dovrebbe usare 1 per il filesystem di root, 2 per tutti gli altri filesystem montati normalmente e 0 per i filesystem che non sono montati di default.
### Opzioni
| Opzioni | Descrizione
|----|----|
auto | la partizione sarà montata all'avvio del sistema, oppure con il comando mount -a
noauto | la partizione può essere montata solo manualmente
defaults | assegna le impostazioni di default: per ext4 sono "rw,suid,dev,exec,auto,nouser,async"
exec | abilita l'esecuzione dei programmi presenti sulla partizione
noexec | inibisce l'esecuzione programmi presenti sulla partizione
relatime | aggiorna nell'inode solo i tempi di accesso al file system
noatime | non aggiorna l'inode con i tempi di accesso al file system
nodiratime | non aggiorna l'inode delle directory coi tempi di accesso al file system
ro | il mount della partizione può avvenire in sola lettura
rw | il mount della partizione può avvenire in lettura e scrittura
sync | operazioni di scrittura/lettura della partizione sincrone
async | operazioni di scrittura/lettura della partizione asincrone
suid | consente le operazioni di suid e sgid (esecuzione dei programmi con maggiori privilegi)
nosuid | inibisce le operazioni di suid e sgid
user | consente a tutti gli utenti di montare la partizione, con le opzioni di default:noexec,nosuid,nodev
users | permette agli utenti appartenenti al gruppo users di montare il filesystem
nouser | limita solo a root la possibilità di effettuare il mount del file system
owner | permette il mount al solo proprietario del punto di mount
nofail | da usarsi per dispositivi esterni (chiavette, dischi, fotocamere, ecc.) per evitare di avere messaggi di errore al boot
dev | interpreta le periferiche a blocchi o periferiche speciali all'interno del filesystem
nodev | impedisce l'interpretazione di periferiche a blocchi o periferiche speciali all'interno del filesystem
uid | imposta l'ID utente che verrà utilizzato per accedere al file system
gid | imposta l'ID del gruppo che verrà utilizzato per accedere al file system
x-gvfs-show | controlla se il file system viene visualizzato nell'interfaccia utente
umask | rappresenta la negazione dei permessi. In origine tutti i file e le directory hanno il permesso 0777. La maschera li riduce. Ad esempio, una maschera 0111 riduce i permessi da 0777 a 0666. In pratica, suggerisce ai programmi avviati successivamente quali permessi negare al momento della creazione di nuovi file e directory. Differisce da chmod sia perché quest'ultimo modifica i permessi successivamente alla creazione dei file o directory, sia perché i permessi forniti con chmod sono quelli effettivi e non quelli negati.
Per verificare di aver scritto tutto correttamente, provare il comando:
```bash
mount /punto/di/mount/in/fstab
```
Se non vengono restituiti errori, l'operazione è andata a buon fine.
## Collegamenti
- [http://linuxguide.altervista.org/fstab.html](http://linuxguide.altervista.org/fstab.html)
- [https://wiki.ubuntu-it.org/AmministrazioneSistema/Fstab](https://wiki.ubuntu-it.org/AmministrazioneSistema/Fstab)
- [https://www.andreaminini.com/linux/maschera-permessi-linux-umask](https://www.andreaminini.com/linux/maschera-permessi-linux-umask)
- [https://it.wikipedia.org/wiki/Umask](https://it.wikipedia.org/wiki/Umask)

40
linux/filesystem/infohw.md Normal file
View File

@@ -0,0 +1,40 @@
# Informazioni sul sistema
Ci sono molti comandi per controllare le informazioni sull’hardware di un sistema GNU/Linux.
| COMANDO | ESECUZIONE |
|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| lscpu | lscpu riporta informazioni sulla CPU e sulle unità di elaborazione. Non ha ulteriori opzioni o funzionalità |
| lshw | Riporta informazioni dettagliate e brevi su più unità hardware diverse come CPU, memoria, disco, controller USB, adattatori di rete ecc. |
| lshw -short | Come il comando precedente, ma con un output più conciso |
| hwinfo | Riporta informazioni dettagliate e brevi su più componenti hardware diversi e più di quanto lshw può riportare |
| lspci | Lo strumento lspci viene utilizzato per generare informazioni relative a tutti i controller PCI sul sistema più i dispositivi ad essi collegati |
| lsscsi | Elenca i dispositivi scsi/sata come dischi rigidi e unità ottiche |
| lsusb | Questo comando mostra i controller USB e i dettagli sui dispositivi ad essi collegati |
| usb-devices | Informazioni estese sui dispositivi usb |
| dmidecode -t memory | Informazioni sulla memoria |
| dmidecode -t system | Informazioni sul sistema |
| dmidecode -t bios | Informazioni sul BIOS |
| dmidecode -t processore | Informazioni sul processore |
| cat /etc/os-release | Informazioni sulla versione del sistema operativo |
| iwconfig | Serve per identificare periferiche di rete wireless |
| xrandr --query | Il comando xrandr è uno strumento utile per il riconoscimento del monitor integrato e/o connesso al proprio computer |
| inxi | Lo strumento inxi permette di reperire rapidamente informazioni sia sull'hardware (CPU, RAM, dischi rigidi ecc.) sia sul sistema installato (kernel, server grafico, Desktop, repository ecc.) |
| inxi -b | Mostra le informazioni di base sul sistema |
| inxi -F | Mostra le informazioni complete sul sistema |
| inxi -M | Mostra le informazioni relative a marca e modello della scheda madre |
| inxi -C | Mostra le informazioni sulle CPU |
| inxi -B | Mostra le informazioni relative alla batteria |
| uname -a | Informazioni sul SO |
| neofeth | Varie informazioni sul sistema |
| free -m | Informazioni sulla RAM |
| lsb_release -a | Informazioni sulla versione del SO |
| hostnamectl | Varie informazioni sul sistema |
## Collegamenti
- [https://trgtkls.org/linux-comandi-per-avere-informazioni-sul-sistema/](https://trgtkls.org/linux-comandi-per-avere-informazioni-sul-sistema/)
- [https://wiki.ubuntu-it.org/Hardware/Periferiche/IdentificarePeriferiche](https://wiki.ubuntu-it.org/Hardware/Periferiche/IdentificarePeriferiche)
- [https://www.guidetti-informatica.net/2021/09/10-comandi-per-raccogliere-informazioni-di-sistema-e-hardware-in-linux/](https://www.guidetti-informatica.net/2021/09/10-comandi-per-raccogliere-informazioni-di-sistema-e-hardware-in-linux/)
- [https://www.redhat.com/sysadmin/linux-system-info-commands](https://www.redhat.com/sysadmin/linux-system-info-commands)
- [https://linuxize.com/post/how-to-check-linux-version/](https://linuxize.com/post/how-to-check-linux-version/)

43
linux/filesystem/megabit_megabyte.md Normal file
View File

@@ -0,0 +1,43 @@
# Megabit
Quando si fa riferimento alla capacità di un collegamento dati e, quindi, alla velocità massima per il trasferimento dei dati, come unità di misura si utilizzano i
Megabit per secondo o Mbps (oppure Mb/s o Mbit/s).
Megabit e MegaByte sono due unità di misura completamente diverse. Il Megabit è una delle unità di misura del trasferimento dei dati o della velocità di download.
Il MegaByte e i suoi multipli, invece, sono usati per indicare la quantità di dati scaricati.
Questi ultimi vengono spesso usati, inoltre, anche per indicare la quantità di dati (o di informazioni) che un dispositivo può riuscire a contenere. Ne sono classici esempi, le chiavette USB o gli hard disk esterni.
Il Megabit per secondo è un multiplo del bit e corrisponde alla trasmissione di 1.000.000 di bit al secondo. A seconda della capacità del collegamento con cui si ha a che fare si
possono però usare altri multipli del bit: kbps (1.000 bit al secondo) o Gbps (1.000.000.000 bit al secondo).
I Gigabit per secondo o Gbps si utilizzano per riferirsi alla capacità delle più moderne connessioni in fibra FTTH (Fiber-to-the-Home)
## Differenza tra Megabit e Megabyte
Il Megabyte è un'unità di misura dell'informazione o della quantità di dati, uno dei vari multipli del byte.
Mentre per misurare la capacità del link si usano kbps, Mbps e Gbps, quando ad esempio si scarica un file con il browser, la velocità di download è espressa in byte per secondo (KB/s o MB/s).
Ciò è corretto perché appunto, in questo caso, si misura l'informazione trasferita nell'unità di tempo con riferimento - ad esempio - al peso di un file.
Per codificare un singolo carattere alfanumerico si utilizzano 8 bit. Il byte, che esprime una sequenza di 8 bit, è quindi
storicamente diventato l'elemento base nelle architetture dei computer e l'unità di misura delle capacità di memoria.
Dal momento che il byte è formato da una sequenza di 8 bit, questo può assumere 256 possibili valori (ovvero 28). La famosa tabella dei caratteri
ASCII è formata proprio da 256 voci, ciascuna corrispondente a uno dei caratteri che è possibile formare con una diversi combinazione degli 8 bit che compongono il byte.
Per passare dai bit ai byte, quindi, basta semplicemente dividere per 8.
Una connessione con capacità di 20 Mbps può trasferire fino 2,5 MB/s (20 diviso 8) ovvero 2.500 KB/s; una connessione da 100 Mbps fino a 12,5 MB/s.
I Megabyte al secondo (MB/s) danno immediatamente un'idea della quantità di informazione che è possibile trasferire in un secondo: se si potessero usare tutti i 100 Mbps
di un link in fibra, si potrebbe prelevare dalla rete un documento di 12,5 Megabyte in un solo secondo; con un collegamento in fibra FTTH
a 1 Gbps, un file da 125 Megabyte in un appena in secondo.
La distinzione tra Megabyte Mb è MegaByte MB sta tutta nella lettera b, che è minuscola se si parla di megabit al secondo (Mbps) e maiuscola se si parla di Megabyte (MBps).
## Collegamenti
- [https://www.ilsoftware.it/articoli.asp?tag=Differenza-tra-Megabit-e-Megabyte-come-non-cadere-in-errore_16910](https://www.ilsoftware.it/articoli.asp?tag=Differenza-tra-Megabit-e-Megabyte-come-non-cadere-in-errore_16910)
- [https://selectra.net/internet/guida/tecnologia/mbps-megabyte](https://selectra.net/internet/guida/tecnologia/mbps-megabyte)

132
linux/filesystem/mount.md Normal file
View File

@@ -0,0 +1,132 @@
# mount
Sui sistemi operativi GNU/Linux e UNIX, è possibile utilizzare il comando `mount` per montare file-system e dispositivi rimovibili.
Il *montaggio* (mounting) è un processo attraverso il quale un file-system si rende disponibile al sistema; dopo il montaggio i file saranno accessibili sotto il punto di mount.
La directory su cui è montato il file-system può non essere vuota, ma deve esistere.
Su molti sistemi ci sono file-system che devono essere montati automaticamente all'avvio. Questi sono specificati nel file `/etc/fstab`.
## Elencare i file-system montati
Se utilizzato senza alcun argomento, il comando mount visualizzerà tutti i file-system attualmente montati sul sistema:
```bash
mount
```
Ogni riga contiene informazioni sul nome del dispositivo, la directory in cui è montato , il tipo di file-system e le opzioni di mount nel seguente formato:
```bash
device_name on directory type filesystem_type (options)
```
Per visualizzare solo determinati file-system utilizzare l'opzione `-t`.
Ad esempio, per stampare solo le partizioni ext4:
```bash
mount -t ext4
/dev/mapper/luks-487ce502-4541-488c-b07f-ea2ac4e91b9f on / type ext4 (rw,noatime,stripe=32)
```
Altri modi per elencare i file-system montati:
```bash
cat /proc/mounts
df -aTh
File system Tipo Dim. Usati Dispon. Uso% Montato su
sysfs sysfs 0 0 0 - /sys
proc proc 0 0 0 - /proc
udev devtmpfs 6,8G 0 6,8G 0% /dev
devpts devpts 0 0 0 - /dev/pts
tmpfs tmpfs 1,4G 2,2M 1,4G 1% /run
/dev/dm-0 ext4 426G 109G 296G 27% /
securityfs securityfs 0 0 0 - /sys/kernel/security
tmpfs tmpfs 6,8G 6,6M 6,8G 1% /dev/shm
tmpfs tmpfs 5,0M 16K 5,0M 1% /run/lock
cgroup2 cgroup2 0 0 0 - /sys/fs/cgroup
pstore pstore 0 0 0 - /sys/fs/pstore
bpf bpf 0 0 0 - /sys/fs/bpf
systemd-1 - - - - - /proc/sys/fs/binfmt_misc
mqueue mqueue 0 0 0 - /dev/mqueue
hugetlbfs hugetlbfs 0 0 0 - /dev/hugepages
debugfs debugfs 0 0 0 - /sys/kernel/debug
tracefs tracefs 0 0 0 - /sys/kernel/tracing
configfs configfs 0 0 0 - /sys/kernel/config
fusectl fusectl 0 0 0 - /sys/fs/fuse/connections
ramfs ramfs 0 0 0 - /run/credentials/systemd-sysusers.service
ramfs ramfs 0 0 0 - /run/credentials/systemd-tmpfiles-setup-dev.service
ramfs ramfs 0 0 0 - /run/credentials/systemd-tmpfiles-setup.service
ramfs ramfs 0 0 0 - /run/credentials/systemd-sysctl.service
binfmt_misc binfmt_misc 0 0 0 - /proc/sys/fs/binfmt_misc
tmpfs tmpfs 1,4G 2,6M 1,4G 1% /run/user/1000
```
dove con l'opzione `-a` tutti i file-system saranno visibili e con `-T` ne sarà indicato il tipo.
## Montare un file-system
Per montare un fyle-system in una determinata posizione (punto di *montaggio*), utilizzare il comando mount nel seguente formato:
```bash
mount [OPTION...] DEVICE_NAME DIRECTORY
```
Ad esempio, per montare il fyle-system /dev/sdb1 nella directory /mnt/media:
```bash
sudo mount /dev/sdb1 /mnt/media
```
Di solito quando si monta un dispositivo con un fyle-system comune, come ext4, il comando rileverà automaticamente il tipo di fyle-system.
Tuttavia, alcuni fyle-system non sono riconosciuti e devono essere specificati in modo esplicito con l'opzione `-t`:
```bash
mount -t TYPE DEVICE_NAME DIRECTORY
```
Se non si deve scrivere nulla sul file-system è meglio usare l'opzione `-r` (read) per avere un file-system *in sola lettura*;
in questo modo il kernel interromperà qualsiasi tentativo di scrittura.
### Montare un'unità USB
Per montare manualmente un dispositivo USB, attenersi alla seguente procedura:
- creare il punto di montaggio:
```bash
sudo mkdir -p /media/usb
```
- montare la periferica:
```bash
sudo mount /dev/sdd1 /media/usb
```
## Smontaggio di un fyle-system
Per scollegare un fyle-system montato, utilizzare il comando `umount` seguito dalla directory in cui è stato montato o dal nome del dispositivo:
```bash
umount DIRECTORY
umount DEVICE_NAME
```
Se il fyle-system è in uso, il comando umount non riuscirà a smontarlo.
Utilizzare l'opzione `-l` per smontare un fyle-system occupato non appena diventa libero:
```bash
umount -l DIRECTORY
```
## Collegamenti
- [https://noviello.it/come-montare-mount-e-smontare-unmount-file-system-su-linux/](https://noviello.it/come-montare-mount-e-smontare-unmount-file-system-su-linux/)
- [https://linuxhandbook.com/list-mounted-drives/](https://linuxhandbook.com/list-mounted-drives/)
- [http://www.pluto.it/sites/default/files/ildp/guide/lfh/x1111.html](http://www.pluto.it/sites/default/files/ildp/guide/lfh/x1111.html)

213
linux/filesystem/smartctl.md Normal file
View File

@@ -0,0 +1,213 @@
# Smartctl
Gli `smartmontools` permettono di usare la funzionalità SMART di tutti i moderni HD grazie alla quale è possibile diagnosticare malfunzionamenti.
## Installazione
```bash
sudo apt install smartmontools
```
## Informazioni
Per visualizzare alcune informazioni generiche sul HD:
```bash
sudo smartctl -i /dev/nvme0
smartctl 7.3 2022-02-28 r5338 [x86_64-linux-6.1.0-6-amd64] (local build)
Copyright (C) 2002-22, Bruce Allen, Christian Franke, www.smartmontools.org
=== START OF INFORMATION SECTION ===
Model Number: Samsung SSD 980 500GB
Serial Number: S64DNL0TA11496W
Firmware Version: 2B4QFXO7
PCI Vendor/Subsystem ID: 0x144d
IEEE OUI Identifier: 0x002538
Total NVM Capacity: 500.107.862.016 [500 GB]
Unallocated NVM Capacity: 0
Controller ID: 5
NVMe Version: 1.4
Number of Namespaces: 1
Namespace 1 Size/Capacity: 500.107.862.016 [500 GB]
Namespace 1 Utilization: 275.385.454.592 [275 GB]
Namespace 1 Formatted LBA Size: 512
Namespace 1 IEEE EUI-64: 002538 da21a0c231
Local Time is: Sat Mar 25 18:41:22 2023 CET
sudo smartctl -i /dev/sda1
smartctl 7.3 2022-02-28 r5338 [x86_64-linux-6.1.0-6-amd64] (local build)
Copyright (C) 2002-22, Bruce Allen, Christian Franke, www.smartmontools.org
=== START OF INFORMATION SECTION ===
Vendor: Intenso
Product: Speed Line
Revision: 8.01
Compliance: SPC-4
User Capacity: 251.658.240.000 bytes [251 GB]
Logical block size: 512 bytes
Logical Unit id: 0x4945450005080f000x200049454505080f
Serial number:
Device type: disk
Local Time is: Sat Mar 25 18:44:18 2023 CET
SMART support is: Available - device has SMART capability.
SMART support is: Enabled
Temperature Warning: Disabled or Not Supported
```
Oltre alle informazioni generiche, dalle ultime due righe si capisce che l'HD supporta la tecnologia SMART e che il supporto è attivato. Se non fosse attivato basterebbe digitare questo comando:
```bash
sudo smartctl -s on /dev/hda
```
per attivare il supporto SMART.
Per controllare lo stato di salute attuale:
```bash
sudo smartctl -H /dev/hda
smartctl version 5.34 [i686-pc-linux-gnu] Copyright (C) 2002-5 Bruce Allen
Home page is https://www.smartmontools.org/
=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
```
L'ultima riga dice che la salute sembra buona e nessuno dei parametri interni controllati da SMART ha superato il livello di guardia.
> Se il precedente comando non riporta PASSED smontaire immediatamente tutte le partizioni presenti su quell'HD ed effettuate un backup dei dati
## Maggiori informazioni
```bash
smartctl -a /dev/sda1
```
L'output, abbastanza lungo (`-a` sta per "all"), è diviso in quattro sezioni. Il primo blocco rappresenta le informazioni generiche sull'HD (le stesse ottenute prima con `-i`),
la seconda sezione riporta le informazioni sul supporto SMART. La terza sezione elenca i parametri interni monitorati da SMART e se hanno mai superato il livello di guardia:
```bash
SMART Attributes Data Structure revision number: 16
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE
1 Raw_Read_Error_Rate 0x000b 200 200 051 Pre-fail Always - 0
3 Spin_Up_Time 0x0007 099 091 021 Pre-fail Always - 4108
4 Start_Stop_Count 0x0032 098 098 040 Old_age Always - 2590
5 Reallocated_Sector_Ct 0x0033 200 200 140 Pre-fail Always - 0
7 Seek_Error_Rate 0x000b 200 200 051 Pre-fail Always - 0
9 Power_On_Hours 0x0032 092 092 000 Old_age Always - 6494
10 Spin_Retry_Count 0x0013 100 100 051 Pre-fail Always - 0
11 Calibration_Retry_Count 0x0013 100 100 051 Pre-fail Always - 0
12 Power_Cycle_Count 0x0032 098 098 000 Old_age Always - 2435
196 Reallocated_Event_Count 0x0032 200 200 000 Old_age Always - 0
197 Current_Pending_Sector 0x0012 200 200 000 Old_age Always - 0
198 Offline_Uncorrectable 0x0012 200 200 000 Old_age Always - 0
199 UDMA_CRC_Error_Count 0x000a 200 200 000 Old_age Always - 19
200 Multi_Zone_Error_Rate 0x0009 200 200 051 Pre-fail Offline - 0
```
I parametri indicati come `Pre-fail` sono quelli che superano la soglia di guardia nelle 24 ore che precedono la rottura dell'HD,
mentre quelli `Old_age` sono i parametri che superano la soglia di guardia quando ormai l'HD è vecchio e non è considerato più affidabile dal costruttore.
Nell'esempio si vede che nessun parametro ha mai superato la soglia di guardia.
## Effettuare test
È possibile effettuare dei test più o meno approfonditi sul disco. Alcuni test si possono effettuare con l'HD montato e funzionante, ed il test stesso avrà un impatto minimo o nullo
sulle prestazioni del sistema.
Per effettuare un test:
```bash
sudo smartctl -t tipo_test /dev/hda
```
dove *tipo_test* può essere:
- short: effettua un test sul disco di durata inferiore a 10 minuti, può essere eseguito durante il normale funzionamento e non ha alcun impatto sulle prestazioni.
Questo test controlla le performance meccaniche ed elettriche del disco, oltre che le performance in lettura;
- long: effettua un test di durata da 40 minuti ad un ora (a seconda del disco). Può essere effettuato durante il normale funzionamento del disco e non ha impatto sulle prestazioni.
Questo test è una versione più estesa dello short test;
- conveyance: effettua un test di alcuni minuti atto a scoprire difetti dovuti ad incurie nel trasporto dell'HD. Può essere eseguito durante il normale funzionamento dell'HD.
I risultati di questi test vengono riportati nella parte finale dell'output di `smartctl -a /dev/sda1`.
```bash
SMART Error Log Version: 1
No Errors Logged
SMART Self-test log structure revision number 1
Num Test_Description Status Remaining LifeTime(hours) LBA_of_first_error
# 1 Short offline Completed without error 00% 952 -
# 2 Conveyance offline Completed without error 00% 951 -
# 3 Short offline Completed without error 00% 951 -
# 4 Short offline Completed without error 00% 875 -
```
Nell'esempio si può vedere che sono stati effettuati 4 test, di cui tre di tipo short e uno di tipo conveyance. Nessuno di loro ha dato esito positivo (cioè non sono stati rilevati malfunzionamenti).
### Testare la reale dimensione di un dispositivo
```bash
sudo apt install f3
sudo f3probe --desrtuctive --time-ops /dev/sdX
```
Ad esempio:
```bash
sudo f3probe --destructive --time-ops /dev/sda
F3 probe 8.0
Copyright (C) 2010 Digirati Internet LTDA.
This is free software; see the source for copying conditions.
WARNING: Probing normally takes from a few seconds to 15 minutes, but
it can take longer. Please be patient.
Good news: The device `/dev/sda' is the real thing
Device geometry:
*Usable* size: 234.38 GB (491520000 blocks)
Announced size: 234.38 GB (491520000 blocks)
Module: 256.00 GB (2^38 Bytes)
Approximate cache size: 0.00 Byte (0 blocks), need-reset=no
Physical block size: 512.00 Byte (2^9 Bytes)
Probe time: 3'23"
Operation: total time / count = avg time
Read: 1.27s / 4818 = 265us
Write: 3'21" / 4192321 = 48us
Reset: 0us / 1 = 0us
```
### Testare la velocità del disco
Il comando `hdparm` può essere utilizzato per misurare le prestazioni del disco rigido, inclusa la velocità di lettura e scrittura reale e la velocità della cache.
Ad esempio, per misurare le prestazioni del disco rigido, è possibile utilizzare il seguente comando:
```bash
hdparm -t /dev/sda
sudo hdparm -t /dev/nvme0n1
/dev/nvme0n1:
Timing buffered disk reads: 3390 MB in 3.00 seconds = 1129.60 MB/sec
```
Con l'opzione `-T` viene testata anche la cache:
```bash
sudo hdparm -Tt /dev/nvme0n1
/dev/nvme0n1:
Timing cached reads: 19464 MB in 2.00 seconds = 9748.45 MB/sec
Timing buffered disk reads: 3446 MB in 3.00 seconds = 1148.21 MB/sec
```
## Collegamenti
- [https://guide.debianizzati.org/index.php/Gestire_gli_HD:_stato_di_salute,_badblocks_e_ripristino_dati](https://guide.debianizzati.org/index.php/Gestire_gli_HD:_stato_di_salute,_badblocks_e_ripristino_dati)
- [https://github.com/AltraMayor/f3](https://github.com/AltraMayor/f3)

39
linux/filesystem/uuid.md Normal file
View File

@@ -0,0 +1,39 @@
# UUID
L' UUID è un identificatore univoco universale (Universally Unique IDentifier), consistente in una sequenza di 128 bit, espressi usualmente in forma esadecimale.
Gli UUID sono utilizzati comunemente per identificare le partizioni di un supporto di memoria di massa.
## Ottenere l'uuid
Esistono diversi modi:
```bash
ls -l /dev/disk/by-uuid/
totale 0
lrwxrwxrwx 1 root root 15 19 mar 12.16 44d72477-5d0f-4d0d-a54b-f721a7e5a320 -> ../../nvme0n1p2
lrwxrwxrwx 1 root root 15 19 mar 12.16 487ce502-4541-488c-b07f-ea2ac4e91b9f -> ../../nvme0n1p1
lrwxrwxrwx 1 root root 10 19 mar 12.16 cd370d97-dd7c-41d1-9b53-1504c89f64fd -> ../../dm-1
lrwxrwxrwx 1 root root 10 19 mar 12.16 ce884a78-4404-4ea9-b6e7-d543bfb38a41 -> ../../dm-0
```
Oppure tramite il comando `blkid`.
Infine tramite `lsblk` con l'opzione `-f` è possibile visualizzare l'uuid e altre informazioni:
```bash
lsblk -f
NAME FSTYPE FSVER LABEL UUID FSAVAIL FSUSE% MOUNTPOINTS
nvme0n1
├─nvme0n1p1 crypto_LUKS 1 487ce502-4541-488c-b07f-ea2ac4e91b9f
│ └─luks-487ce502-4541-488c-b07f-ea2ac4e91b9f ext4 1.0 ce884a78-4404-4ea9-b6e7-d543bfb38a41 295,6G 25% /
└─nvme0n1p2 crypto_LUKS 1 44d72477-5d0f-4d0d-a54b-f721a7e5a320
└─luks-44d72477-5d0f-4d0d-a54b-f721a7e5a320 swap 1 cd370d97-dd7c-41d1-9b53-1504c89f64fd [SWAP]
```
## Collegamenti
- [https://guide.debianizzati.org/index.php/UUID](https://guide.debianizzati.org/index.php/UUID)
- [https://linuxhandbook.com/get-uuid-disk/](https://linuxhandbook.com/get-uuid-disk/)