Gestione Dischi su Linux

# Vista ad albero: dischi, partizioni, mount, dimensioni. IL comando.
lsblk
lsblk -f                 # aggiunge FSTYPE, LABEL, UUID, mountpoint
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS,MODEL

# Tabella partizioni di un disco (e tipo MBR/GPT)
sudo fdisk -l /dev/sda
sudo parted /dev/sda print

# Tutti i block device con UUID, tipo, etichetta
sudo blkid

# Spazio LIBERO/usato sui filesystem montati (-h = leggibile dagli umani)
df -hT

# Dettagli hardware del disco (rotante? SSD? modello? seriale?)
sudo hdparm -I /dev/sda
cat /sys/block/sda/queue/rotational   # 1 = HDD, 0 = SSD/NVMe

sudo fdisk /dev/sdb       # apri il disco (NON una partizione: sdb, non sdb1)

# dentro al prompt "Command (m for help):"
g        # crea una nuova tabella GPT vuota (g=GPT, o=MBR/dos)
n        # nuova partizione
         # numero partizione: Invio (default 1)
         # primo settore: Invio (default, già allineato a 1 MiB)
+100G    # ultimo settore: +100G = 100 GiB. Invio secco = tutto il disco
p        # print: controlla quello che hai disegnato
t        # cambia tipo (es. 8e per LVM); default Linux fs va benissimo
w        # WRITE: scrivi su disco ed esci. Da qui non si torna indietro.
         # (q invece esce SENZA salvare se hai cambiato idea)

# Crea tabella GPT e una partizione che prende tutto il disco
sudo parted -s /dev/sdb mklabel gpt
sudo parted -s /dev/sdb mkpart primary ext4 1MiB 100%

# Una ESP da 512 MiB + il resto per il sistema
sudo parted -s /dev/sdb mklabel gpt \
  mkpart ESP fat32 1MiB 513MiB \
  set 1 esp on \
  mkpart root ext4 513MiB 100%

# Verifica l'allineamento (deve dire "aligned")
sudo parted /dev/sdb align-check optimal 1
sudo parted /dev/sdb print

# Azzera e ricrea: ESP 512M (EF00) + LVM sul resto (8E00)
sudo sgdisk --zap-all /dev/sdb                      # cancella MBR e GPT
sudo sgdisk -n1:0:+512M -t1:EF00 -c1:"EFI" /dev/sdb
sudo sgdisk -n2:0:0     -t2:8E00 -c2:"LVM" /dev/sdb

# Copia lo schema di partizione da un disco a un altro (utile per RAID)
sudo sgdisk /dev/sda -R /dev/sdb    # replica sda → sdb
sudo sgdisk -G /dev/sdb             # rigenera i GUID (altrimenti duplicati!)

# Fai rileggere al kernel la nuova tabella senza riavviare
sudo partprobe /dev/sdb

# ext4 con una etichetta (la label aiuta a riconoscere il disco)
sudo mkfs.ext4 -L dati /dev/sdb1

# XFS (idem)
sudo mkfs.xfs -L dati /dev/sdb1

# Btrfs
sudo mkfs.btrfs -L dati /dev/sdb1

# FAT32 per una ESP / chiavetta
sudo mkfs.vfat -F32 -n BOOT /dev/sdb1

# exFAT per un disco esterno grande
sudo mkfs.exfat -n SCAMBIO /dev/sdb1

# Area di swap (poi si attiva con swapon)
sudo mkswap -L swap /dev/sdb2 && sudo swapon /dev/sdb2

# Info e parametri di un ext4
sudo tune2fs -l /dev/sdb1
sudo e2label /dev/sdb1 nuovaetichetta   # cambia label ext
sudo xfs_admin -L nuovaetichetta /dev/sdb1 # label XFS

# Controllo coerenza (SOLO su filesystem NON montato!)
sudo fsck -f /dev/sdb1        # ext: -f forza anche se "pulito"
sudo xfs_repair /dev/sdb1     # XFS NON usa fsck, ha il suo tool
sudo btrfs check /dev/sdb1    # Btrfs

sudo mkdir -p /mnt/dati
sudo mount /dev/sdb1 /mnt/dati          # monta
sudo mount -o ro /dev/sdb1 /mnt/dati    # sola lettura (ispezione sicura)
df -hT /mnt/dati                        # conferma: tipo e spazio

sudo umount /mnt/dati                    # smonta

# "target is busy" allo smontaggio: chi lo tiene aperto?
sudo lsof +f -- /mnt/dati
sudo fuser -vm /mnt/dati
sudo umount -l /mnt/dati                 # lazy: smonta appena si libera

lsblk -f                          # mostra UUID e LABEL accanto a ogni device
sudo blkid /dev/sdb1               # UUID + TYPE di una partizione
ls -l /dev/disk/by-id/             # nomi stabili per-modello+seriale
ls -l /dev/disk/by-uuid/           # symlink UUID → /dev/sdXN

# <device>              <mountpoint>  <tipo> <opzioni>            <dump> <pass>
UUID=1a2b-...   /            ext4   defaults              0      1
UUID=9f8e-...   /home        xfs    defaults,noatime      0      2
UUID=AB12-CD34  /boot/efi    vfat   umask=0077            0      1
UUID=4c5d-...   none         swap   sw                    0      0
# Disco dati esterno: monta solo se presente, non bloccare il boot
UUID=7e8f-...   /mnt/backup  ext4   defaults,nofail,x-systemd.device-timeout=10  0  2

# 1. Trasforma due dischi in Physical Volume
sudo pvcreate /dev/sdb /dev/sdc

# 2. Raggruppali in un Volume Group chiamato "dati"
sudo vgcreate dati /dev/sdb /dev/sdc

# 3. Crea un Logical Volume da 200G dentro al VG
sudo lvcreate -L 200G -n archivio dati
#   ...oppure prenditi tutto lo spazio libero:
sudo lvcreate -l 100%FREE -n archivio dati

# 4. Formatta il LV (compare come /dev/dati/archivio)
sudo mkfs.ext4 /dev/dati/archivio

# 5. Monta
sudo mount /dev/dati/archivio /mnt/archivio

# 6. Guarda cosa hai costruito
sudo pvs ; sudo vgs ; sudo lvs     # riepiloghi rapidi
sudo lvdisplay dati/archivio        # dettagli completi

# Aggiungi un nuovo disco al pool esistente
sudo pvcreate /dev/sdd
sudo vgextend dati /dev/sdd

# Allarga il volume di 50G E il filesystem dentro, in un colpo solo
sudo lvextend -L +50G -r /dev/dati/archivio
#   -r = ridimensiona anche il filesystem (resize2fs/xfs_growfs auto)
#   -l +100%FREE per prendersi tutto lo spazio rimasto nel VG

# A mano, se preferisci il controllo (ext4):
sudo lvextend -L +50G /dev/dati/archivio
sudo resize2fs /dev/dati/archivio   # XFS: xfs_growfs /mnt/archivio

# Crea un RAID 1 (mirror) con due dischi
sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 \
   /dev/sdb /dev/sdc

# RAID 5 con tre dischi
sudo mdadm --create /dev/md0 --level=5 --raid-devices=3 \
   /dev/sd{b,c,d}

# Guarda la sincronizzazione iniziale (ci mette ore su dischi grandi)
cat /proc/mdstat
sudo mdadm --detail /dev/md0

# Ora trattalo come un disco normale: formatta e monta
sudo mkfs.ext4 /dev/md0
sudo mount /dev/md0 /mnt/raid

# RENDI PERSISTENTE l'array (altrimenti sparisce al reboot!)
sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
sudo update-initramfs -u      # Debian/Ubuntu

# Marca il disco come guasto e rimuovilo dall'array
sudo mdadm /dev/md0 --fail /dev/sdc --remove /dev/sdc

# Spegni, sostituisci fisicamente il disco, riaccendi.
# Copia lo schema partizioni dal disco buono (se partizionato), poi:
sudo mdadm /dev/md0 --add /dev/sdc

# Il rebuild parte da solo. Monitora:
watch cat /proc/mdstat

# Formatta la partizione come volume LUKS2 (CANCELLA tutto)
sudo cryptsetup luksFormat --type luks2 /dev/sdb1
#   chiede di scrivere YES e una passphrase robusta

# Apri il volume: appare come /dev/mapper/cassaforte
sudo cryptsetup open /dev/sdb1 cassaforte

# Ora è un device normale: formattalo e montalo
sudo mkfs.ext4 /dev/mapper/cassaforte
sudo mount /dev/mapper/cassaforte /mnt/cassaforte

# Chiudi (smonta prima!)
sudo umount /mnt/cassaforte
sudo cryptsetup close cassaforte

sudo apt install open-iscsi          # Debian/Ubuntu

# 1. Scopri quali target offre il portale (l'IP del NAS)
sudo iscsiadm -m discovery -t sendtargets -p 192.168.1.50

# 2. Collegati (login) al target trovato
sudo iscsiadm -m node \
   -T iqn.2026-06.org.esempio:storage1 \
   -p 192.168.1.50 --login

# 3. Ora è un disco locale! Trovalo:
lsblk                                  # comparirà un nuovo /dev/sdX
dmesg | tail                           # dice quale lettera ha preso

# 4. Da qui è storage normale: partizioni, mkfs, mount.
#    Rendi il login automatico al boot:
sudo iscsiadm -m node -T iqn.2026-06...:storage1 \
   -p 192.168.1.50 --op update -n node.startup -v automatic

# Disconnessione
sudo iscsiadm -m node -T iqn.2026-06...:storage1 --logout

sudo apt install targetcli-fb && sudo targetcli

# dentro la shell targetcli (è ad albero, tipo filesystem):
# 1. Crea un backstore: un disco vero o un file-immagine
/backstores/block create disco1 /dev/sdc
#   oppure un file: /backstores/fileio create disco1 /srv/lun1.img 100G

# 2. Crea il target (genera un IQN)
/iscsi create iqn.2026-06.org.esempio:storage1

# 3. Esponi il backstore come LUN
/iscsi/iqn.2026-06.org.esempio:storage1/tpg1/luns create /backstores/block/disco1

# 4. Autorizza l'initiator (l'IQN del client, in /etc/iscsi/initiatorname.iscsi)
/iscsi/iqn.2026-06.org.esempio:storage1/tpg1/acls create iqn.2026-06.org.client:pc1

exit                                # salva automaticamente la config
sudo systemctl enable --now target   # ripristina al boot

sudo apt install multipath-tools
sudo systemctl enable --now multipathd
sudo multipath -ll                  # mostra i path raggruppati

sudo apt install smartmontools

# Verdetto rapido: PASSED o FAILING
sudo smartctl -H /dev/sda

# Report completo: attributi, ore di vita, settori riallocati...
sudo smartctl -a /dev/sda
sudo smartctl -a /dev/nvme0           # NVMe: usa /dev/nvme0, non p1

# Lancia un test (in background, il disco resta usabile)
sudo smartctl -t short /dev/sda      # ~2 minuti
sudo smartctl -t long  /dev/sda      # ore, scansiona tutta la superficie
sudo smartctl -l selftest /dev/sda   # risultati dei test

# 1) Hai finito gli INODE, non i byte (milioni di file minuscoli)
df -i                                 # guarda la colonna IUse%: se è 100%, ecco il problema

# 2) Un file cancellato ma ancora APERTO da un processo
#    (il log che hai "rm"-ato ma il servizio lo tiene aperto)
sudo lsof | grep deleted             # trova i file fantasma
#    Soluzione: riavvia/ricarica il processo che li tiene

# Trova chi occupa spazio davvero
sudo du -xh / | sort -rh | head -20
ncdu /                               # navigatore interattivo, comodissimo

dmesg -T | grep -iE "error|i/o|remount|ext4|xfs"   # cosa è successo
sudo smartctl -a /dev/sda            # il disco sta morendo?

# Se il disco è sano (raro): smonta e ripara, poi rimonta
sudo umount /dev/sda1
sudo fsck -f /dev/sda1              # ext;  XFS: xfs_repair
sudo mount /dev/sda1 /mnt/punto

# Clona un disco intero su un altro (status=progress mostra l'avanzamento)
sudo dd if=/dev/sda of=/dev/sdb bs=64M status=progress conv=fsync

# Meglio di dd per dischi con settori danneggiati (continua oltre gli errori)
sudo ddrescue /dev/sda /dev/sdb rescue.log

# Azzerare l'inizio di un disco (firma partizioni) per "ripartire pulito"
sudo wipefs -a /dev/sdb              # rimuove le firme fs/partizioni (pulito)