Administrarea spațiului de stocare (all)

Înainte de laborator

Comandă Descriere scurtă
lsblk comandă folosită pentru a afisă informații despre device-urile existente în sistem
parted comandă folosită pentru a obține informații despre partițiile din sistem
fdisk comandă folosită pentru a realiza diverse operații asupra partițiilor
gdisk comandă asemănătoare cu fdisk, dar folosește tabela de partiții GPT
df comandă utilă pentru a verifica spațiul de stocare total și liber de pe un dispozitiv sau o partiție
du comandă folosită pentru a afla cât spațiu ocupă pe disc un director sau fișier
mount comandă folosită pentru a monta un sistem de fișiere
umount comandă folosită pentru a demonta un sistem de fișiere
mkfs.ext4 comandă folosită pentru a formata un sistem de fișiere de tip ext4

Obiective

  • Înțelegerea noțiunii de spațiu de stocare
  • Înțelegerea diferenței dintre spațiu de stocare și memoria volatilă
  • Cunoașterea diferenței dintre diferite tehnologii de stocare (HDD vs SSD)
  • Ce este o partiție și la ce e utilă partiționarea
  • Înțelegerea sistemului de fișiere din Linux
  • Dobândirea de abilități de lucru cu sistemul de fișiere și partițiile
  • Înțelegerea nevoii de backup

Folosire Git pentru laborator

Pe parcursul laboratoarelor, pentru descărcarea fișierelor necesare laboratorului, vom folosi Git. Git este un sistem de controlul versiunii și e folosit pentru versionarea codului în proiectele software mari. Celor interesați să aprofundeze conceptele din spatele comenzii git, precum și utilizări avansate, le recomandăm cursul practic online de pe gitimmersion.

Informațiile despre laboratorul de USO se găsesc în acest repository Git.

Pentru a pregăti infrastructura de laborator rulați comenzile de mai jos într-un terminal. Deschideți un terminal folosind combinația de taste Ctrl+Alt+t. În listarea de mai jos student@uso:~$ este promptul unde introduceți comenzile, pe acela nu-l tastați.

student@uso:~$ cd ~
student@uso:~$ git clone https://github.com/systems-cs-pub-ro/uso-lab.git

Cam atât cu pregătirea laboratorului. Acum haideți să ne apucăm de treabă! :-)

Concepte

Pănă în acest moment ați folosit sistemul de operare Linux pentru a realiza diverse operații: ați creat fișiere și directoare, utilizatori și grupuri, ați creat și rulat scripturi, ați realizat diverse operații și procesări, etc. Toate informațiile de care vă folosiți pentru a realiza activități în sistem trebuie să fie stocate undeva, persistent sau temporar. Astfel, stocarea este un element central în operațiile cu sistemul de calcul.

Spațiul de stocare de pe orice sistem trebuie să ofere:

  • eficiență (performanță ridicată)
  • coerență (să nu se piardă/corupă datele)

În Linux, spațiul de stocare (disk-ul) este administrat prin partiționare și sistemul de fișiere.

Pe scurt, spațiul de stocare disponibil este împărțit în unul sau mai multe partiții, iar pentru a putea fi folosită, fiecare partiție trebuie să aibă asociat un sistem de fișiere. Procesul de alocare a unui sistem de fișiere pe o partiție se numește formatare (mount).

Sistemul de fisiere

În Linux, există mai multe tipuri de sisteme de fișiere: ext4, ext3, ext2, ZFS, XFS. Acestea specifică modul în care datele sunt stocate și ulterior accesate de pe disk. Sistemul de fișiere a fost discutat și în cadrul Laboratorului 1.

Partiționarea

Informațiile despre partiții sunt ținute în tabela de partiții (partition table) ce se află în general la începutul disk-ului. O tabelă de partiții conține informații cum ar fi: adresa de unde începe partiția pe disc, ce dimensiune are, tip, etc. Tabela poate să aibă una din următoarele două scheme:

  • Master Boot Record (MBR)
  • GUID Partition Table (GPT)

MBR-ul este mai folosită, insă a început să fie înlocuit de către GPT din cauza limitărilor acestuia, cum ar fi:

  • Dimensiunea maximă a unei partiții este de 2TB
  • Necesitatea unei partiții extinse pentru a crea mai mult de patru partiții

Tabelele de partiție pot fi create și editate folosind tool-uri de partiționare cum ar fi fdisk.

Tipuri de spații de stocare

După cum știm, datele folosite de un sistem de calcul trebuie să fie stocate undeva și accesate ulterior. Cel mai rapid mediu de stocare a datelor prin operații de scriere/citire sunt cele accesate în mod direct de procesor (memoria RAM, memoria cache). Principalul dezavantaj al acestora este volatilitatea (memoria volatilă nu este persistentă, astfel datele se pierd odată ce sistemul de calcul este repornit sau nu mai este alimentat).

Pentru a preîntâmpina această problemă au fost adăugate dispozitivele de stocare ce oferă perisitența datelor și un spațiu de stocare mult mai mare. În zilele noastre există două tipuri de discuri pe sistemele de calcul:

  • Hard Disk Drive (HDD)
    • tehnologie cunoscută și testată pe parcurul unei perioade îndelungate
    • mai ieftină
    • conține componente mecanice care se pot deteriora în timp
    • scrierea/citirea necesita operații mecanice, ceea ce limitează viteza
  • Solid State Drive (SSD)
    • performanța mai bună
    • fară vibrații și zgomote
    • energetic mai economic

Dispozitivele de stocare au și ele unele dezavantaje:

  • viteza de operare
    • din cauza aceasta, datele trec prin memoria RAM înainte de a ajunge la procesor
  • organizarea datelor
    • nu permit adresare liniară

Demo

Acum că ați aflat cum funcționează spațiul de stocare, trebuie să învățăm și cum să îl folosim.

Device-uri

Pentru a afișa informații despre device-urile existente în sistem putem folosi comanda lsblk sau fdisk -l.

student@uso:~$ lsblk -o KNAME,TYPE,SIZE,MODEL
KNAME  TYPE   SIZE MODEL
loop0  loop    13M 
loop1  loop  87,9M 
[...]
sda    disk    16G VBOX HARDDISK   
sda1   part    16G 
sr0    rom   1024M CD-ROM 

Device-urile se găsesc în directorul /dev/. Dacă afișăm câteva device-uri din /dev/ putem observa ce tip de fișiere sunt.

student@uso:~$ ls -l /dev/sda*
brw-rw---- 1 root disk 8, 0 nov  8 00:25 /dev/sda
brw-rw---- 1 root disk 8, 1 nov  8 00:25 /dev/sda1

Caracterul b vine de la Block file și reprezintă fișiere ce corespund device-urilor de stocare. În exemplul anterior, fișierul /dev/sda corespunde unui dispozitiv de stocare, iar /dev/sda1 reprezintă prima partiție de pe acest dispozitiv.

Fișierele din /dev/ nu corespund neapărat unui dispozitiv fizic, pot exista și dispozitive virtuale.

Partiții

Pentru a obține informații despre partițiile din sistem, folosim comanda parted (comanda necesită drepturi de root).

student@uso:~$ sudo parted -l
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sda: 17,2GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags: 

Number  Start   End     Size    Type     File system  Flags
 1      1049kB  17,2GB  17,2GB  primary  ext4         boot

Câmpul Partition Table ne arată că pe acest sistem se folosește msdos - tabela de partiții MBR (cea mai frecvent utilizată pentru Linux și Windows).

Din output-ul de mai sus, vedem că dispozitivul /dev/sda conține o partiție cu index-ul 1, ce este formatată cu sistemul de fișiere ext4. Fișierul din /dev/ corespunzător partiției este /dev/sda1.

Verificare dispozitive de stocare

Pentru a obține informații detaliate despre dispozitivele de stocare putem folosi comanda fdisk. Această comandă oferă informații precum: dimensiunea unui sector, numărul total de sectoare, numărul de sectoare libere, tipul tabelei de partiții existentă pe dispozitiv.

student@uso:~$ sudo fdisk -l
[...]
Disk /dev/sda: 16 GiB, 17179869184 bytes, 33554432 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: dos
Disk identifier: 0xdf4f561b

Device     Boot Start      End  Sectors Size Id Type
/dev/sda1  *     2048 33552383 33550336  16G 83 Linux
[...]

Dacă dorim să afișăm informații doar despre un anumit device, îl putem specifica ca parametru:

student@uso:~$ sudo fdisk -l /dev/sda1
Disk /dev/sda1: 16 GiB, 17177772032 bytes, 33550336 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

Comanda fdisk va merge în cazul majorității sistemelor, iar în cazul nostru va merge pentru calculatoarele din sala EG106. Se poate totuși să aveți partiții ce folosesc GPT, cum este cazul stațiilor din sala EG306. În acest caz trebuie să folosiți comanda gdisk.

student@uso-eg306:~$ sudo fdisk -l /dev/sda

WARNING: GPT (GUID Partition Table) detected on '/dev/sda'! The util fdisk doesn't support GPT. Use GNU Parted.


Disk /dev/sda: 500.1 GB, 500107862016 bytes
255 heads, 63 sectors/track, 60801 cylinders, total 976773168 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk identifier: 0xc90ab212

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1               1   976773167   488386583+  ee  GPT
Partition 1 does not start on physical sector boundary.
student@uso-eg306:~$ sudo gdisk -l /dev/sda
GPT fdisk (gdisk) version 0.8.8

Partition table scan:
  MBR: protective
  BSD: not present
  APM: not present
  GPT: present

Found valid GPT with protective MBR; using GPT.
Disk /dev/sda: 976773168 sectors, 465.8 GiB
Logical sector size: 512 bytes
Disk identifier (GUID): ED4BC435-E352-403E-898B-09B7A9BA2F2E
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 976773134
Partitions will be aligned on 2048-sector boundaries
Total free space is 139800557 sectors (66.7 GiB)

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048       400001023   190.7 GiB   8300  
   2       400001024       800002047   190.7 GiB   8300  
   3       800002048       816003071   7.6 GiB     8200  
   4       816003072       836974591   10.0 GiB    8300  Linux filesystem

Cel mai ușor mod de a verifica spațiul de stocare total și liber de pe un dispozitiv sau o partiție este folosind comanda df. Pentru a face rezultatul mai ușor de citit pentru noi, vom folosi argumentul -h (human-readable).

student@uso:~$ df -h /
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        16G  7,4G  7,6G  50% /

Pentru a afla informații despre cât spațiu ocupă pe disc un director sau fișier folosim comanda du. Din nou vom folosi argumentul -h. Putem folosi și argumentul -s pentru a primi doar totalul pentru fiecare director primit ca argument.

student@uso:~/uso.git/labs$ du -h 03-user/
48K	03-user/wiki
8,0K	03-user/support/nice-to-know/executable
4,0K	03-user/support/nice-to-know/music/ac_dc
8,0K	03-user/support/nice-to-know/music
32K	03-user/support/nice-to-know
36K	03-user/support
88K	03-user/

student@uso:~/uso.git/labs$ du -hs 03-user/
88K	03-user/

Sisteme de fișiere

Pentru a vedea cu ce sisteme de fișiere sunt formatate dispozitivele de stocare din sistem folosim comanda mount.

student@uso:~$ mount
[...]
sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime)
proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)
udev on /dev type devtmpfs (rw,nosuid,relatime,size=990392k,nr_inodes=247598,mode=755)
devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000)
tmpfs on /run type tmpfs (rw,nosuid,noexec,relatime,size=204132k,mode=755)
/dev/sda1 on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)
[...]

Comanda mount afișează doar sistemele de fișiere care sunt montate. Pentru a afla sistemul de fișiere cu care este formatat un dispozitiv, putem folosi următoarea comandă:

student@uso:~$ sudo blkid /dev/sda1
/dev/sda1: UUID="a14d0991-a3d8-48d6-ac8c-327d1a524501" TYPE="ext4" PARTUUID="df4f561b-01"

Montarea și demontarea sistemelor de fișiere

Un sistem de fișiere nu poate fi folosit decât dacă este montat. Comanda cu ajutorul căreia putem face asta este mount. Fără niciun argument ne va spune ce sisteme de fișiere sunt montate și în ce directoare sunt montate.

student@uso:~$ mount
[...]
devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000)
tmpfs on /run type tmpfs (rw,nosuid,noexec,relatime,size=204132k,mode=755)
/dev/sda1 on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)
securityfs on /sys/kernel/security type securityfs (rw,nosuid,nodev,noexec,relatime)
[...]

Comanda returnează, pe fiecare linie:

  • fișierul de tip bloc asociat dispozitivului de stocare
  • punctul din ierarhia de fișiere unde este montat
  • tipul sistemului de fișiere și flag-urile cu care a fost montat.

Să luăm ca exemplu linia:

/dev/sda1 on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)
  • /dev/sda1 este fișierul corespunzător dispozitivului de stocare
  • / este punctul în care este montat (chiar în rădăcina sistemului de fișiere)
  • ext4 este tipul sistemului de fișiere
  • (rw,relatime,errors=remount-ro,data=ordered) sunt flag-urile cu care a fost montat (read-write, iar în caz de eroare va fi remontat read-only).

Pentru a se putea monta un sistem de fișiere trebuie să specificăm tipul acestuia, dispozitivul de stocare ce îl conține și directorul în care să fie montat.

student@uso:~$ mkdir my-mnt
student@uso:~$ ls my-mnt
student@uso:~$ sudo mkfs.ext4 /dev/sda2
student@uso:~$ sudo mount -t ext4 /dev/sda2 my-mnt
student@uso:~$ ls my-mnt
lost+found

Dacă partiția /dev/sda2 nu există pe sistem, aceasta trebuie creată folosind comanda sudo fdisk /dev/sda.

Partiția /dev/sda2 nu conținea niciun sistem de fișiere. Folosind comanda sudo mkfs.ext4 /dev/sda2 am creat un sistem de fișiere de tip ext4 pe partiția /dev/sda2 (sau am formatat partiția).

Operația opusă montării este demontarea, care se realizează cu ajutorul comenzii umount. Acesteia nu trebuie să îi specificăm decât directorul unde este montat sistemul de fișier ce se dorește a fi demontat sau fișierul bloc.

student@uso:~$ sudo umount my-mnt
student@uso:~$ ls my-mnt

Montarea și demontarea sistemelor de fișiere este o acțiune privilegiată. Dacă dorim să montăm/demontăm un sistem de fișiere ca un utilizator neprivilegiat, trebuie sa prefixăm comanda cu sudo.

Recapitulare

1. Creați o arhivă zip și una tar ce conține toate datele din directorul ~/uso.git/labs/07-storage.

2. Scrieți un script ce crează un fișier de dimensiunea file_size și conținut file_type, unde file-size și file-type sunt primiți ca parametru și reprezintă dimensiunea fișierului creat (ex: 11MB, 32GB, etc), respectiv ce va conține acesta (eg: zerouri, caractere aleatoare, etc). (hint: dd)

Basics

Afișare informații despre partiții

1. Să se afișeze la consolă numărul de partiții de pe sistem, numele partițiilor, dimensiunea acestora și tipul sistemului de fișiere cu care sunt formatate.

2. Să se creeze un script care să afișeze informațiile de la punctul 1.

3. Modificați scriptul anterior astfel încât să accepte ca parametru un string ce specifică un tip de sistem de fișiere (ex: ext3, ext4) și să afișeze toate partițiile ce sunt formatate cu tipul respectiv de fișiere. Dacă niciun parametru nu este specificat, se vor afișa doar informațiile de la punctul 1.

Montarea sistemului propriu de fișiere

1. Avem nevoie de un sistem de fișiere propriu pe care să ținem temele de la USO. Vrem să ne alegem singuri dimensiunea și tipul său, dar și locul unde aceasta să fie montată.

Folosiți comenzile necesare pentru a crea un fișier cu dimensiunea de 100MB, plin cu zero-uri (octeți de zero). Apoi avem nevoie să facem un sistem de fișiere de tipul ext3 peste acest fișier nou (hint: dd).

Un fișier poate fi formatat exact ca și cum ar fi o partiție. Pentru aceasta folosiți comanda mkfs.ext3 urmată de calea către fișier. Adică ceva de genul

sudo mkfs.ext3 /path/fo/file/to/be/formatted

Creați directorul /mnt/myfs și montați noul sistem de fisiere în el.

Pentru verificare folosiți comanda df -hT. Să descifrăm parametrii:

  • df afișează partițiile montate în acel moment de timp
  • -h e folosit pentru human-readable size a partițiilor
  • -T e folosit pentru a afișa încă o coloană cu tipul sistemului de fișiere (e.g. ext3, ext4, nfs etc.)

O altă comandă de verificare este mount fără nici un alt parametru. Încercați să descifrați output-ul ei (sau căutați pe google :-P)

Need to know

Informații despre discuri și partiții

Exerciții

  1. Listați device-urile de tip block ce identifică un dispozitiv de tip disk în sistem. (hint: sdX)
  2. Afișați identificatorii unici (UUID) pentru discurile și partițiile aflate în sistem. (hint: blkid, tags)

Montare/Demontare

  1. Montați fișierul ~/uso-lab/08-storage/support/need-to-know/image.iso la calea /mnt/my_image/ (hint: mount -o loop). Asigurați-vă că directorul my_image există.
  2. Cu ajutorul comenzii mount inspectați dacă montarea s-a efectuat cu succes.
  3. Demontați imaginea. (hint: umount)

Nice to know

Adăugarea unui HDD în cadrul unei mașini virtuale

Ne dorim să efectuăm operațiile de partiționare, formatare și montare într-un caz real. Deoarece operațiile amintite mai sus pot duce la pierderea informațiilor utile de pe un disk vom lucra cu o mașina virtuală disponibilă aici. Pentru a face import mașinii virtuale în VirtualBox urmăriți pașii de aici.

Mașina virtuală se găsește și pe sistemul vostru în directorul /mnt/unfrozen. Dacă acesta nu este montat, rulați următoarea comandă:

student@uso:~$ sudo mount /dev/sda7 /mnt/unfrozen

În cazul în care vă apare eroarea Could not start the machine … because the following physical network interfaces were not found: vboxnet0 (adapter 1) You can either change the machine's network settings or stop the machine., urmați pașii de mai jos:

  1. Accesați VirtualBox FileHost Network Manager.
  2. Apăsați butonul Create.
  3. Va apărea opțiunea vboxnet0, alegeți-o.
  4. Reporniți mașina virtuală.

Vom adăuga un hard disk virtual mașinii virtuale. Mai întâi trebuie să ne asigurăm că mașina virtuală este oprită.

Pentru a adăuga un HDD virtual accesăm setările mașinii virtuale Settings > Storage > Add new storage attachement > Add Hard disk > Create new disk.

Selectăm VDI (VirtualBox Disk Image) > Fixed size. Vom genera un HDD cu dimensiunea totală de 2GB > Create.

Observăm că HDD-ul pe care l-am creat a fost atașat cu succes mașinii virtuale.

Pornim mașina virtuală. Verificăm dacă HDD-ul adăugat anterior are asociat un dispozitiv de tip block la în directorul /dev/:

    student@uso:~$ ls -l /dev/sd*
    brw-rw---- 1 root disk 8,  0 nov 12 10:02 /dev/sda
    brw-rw---- 1 root disk 8,  1 nov 12 10:02 /dev/sda1
    brw-rw---- 1 root disk 8, 16 nov 12 10:02 /dev/sdb

  Noul HDD va apărea în directorul ''/dev/'' sub forma unui fișier cu denumirea ''sdX'' unde X identifică unic prin forma unei litere un disk.

În exemplul de mai sus, HDD-ul pe care l-am adăugat este identificat în directorul /dev/ de intrarea sdb .

Exerciții

  1. Adăugați un HDD urmărind tutorialul de mai sus.
  2. Adăugați încă un HDD cu dimensiunea de 2.5GB.

Partiționare (fdisk)

După ce am atașat HDD-urile va trebui să le partiționăm. Vom folosi utilitarul fdisk.

student@uso:~$ ls -lh /dev/sdb
brw-rw---- 1 root disk 8, 16 nov 12 10:02 /dev/sdb

Comanda fdisk sdb pornește utilitarul fdisk în modul interactiv. Pentru a lista toate comenzile disponibile la un moment dat folosim comanda m - menu.

student@uso:~$ sudo fdisk /dev/sdb
Command (m for help): m
 
Help:
 
  DOS (MBR)
   a   toggle a bootable flag
   b   edit nested BSD disklabel
   c   toggle the dos compatibility flag
 
  Generic
   d   delete a partition
   F   list free unpartitioned space
   l   list known partition types
   n   add a new partition
   p   print the partition table
   t   change a partition type
   v   verify the partition table
   i   print information about a partition
[...]
  Save & Exit
   w   write table to disk and exit
   q   quit without saving changes
[...]

Pentru a crea o partiție primară de dimensiune 200MB vom introduce următoarele comenzi în modul interactiv:

  • n - adăugare partiție nouă;
  • p - partiție primară;
  • 1 - numărul partiției;
  • First sector - selectăm valoarea default apăsând tasta enter.
  • Last sector - +200M
Command (m for help): n
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-4194303, default 2048): 
Last sector, +sectors or +size{K,M,G,T,P} (2048-4194303, default 4194303): +200M
 
Created a new partition 1 of type 'Linux' and of size 200 MiB.

Pentru a scrie modificările făcute în sesiunea curentă a utilitarului fdisk folosim comanda w - write.

Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.

Comanda are ca efect alterarea tabele de partiții a disk-ului curent.

Observăm că a fost adăugat un fișier ce identifică partiția generată în directorul /dev/:

student@uso:~$ ls -l /dev/sdb*
brw-rw---- 1 root disk 8, 16 nov 12 10:23 /dev/sdb
brw-rw---- 1 root disk 8, 17 nov 12 10:23 /dev/sdb1

Exerciții

  1. Adăugați încă două partiții folosind aceiași parametri de mai sus. (hint: se va modifica doar numărul partiției). Nu uitați să folosiți comanda w - write la final.

După ce ați rezolvat exercițiul de mai sus, ar trebui să obțineți următorul output:

student@uso:~$ sudo fdisk -l /dev/sdb
Disk /dev/sdb: 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: dos
Disk identifier: 0xe901124e
 
Device     Boot  Start     End Sectors  Size Id Type
/dev/sdb1         2048  411647  409600  200M 83 Linux
/dev/sdb2       411648  821247  409600  200M 83 Linux
/dev/sdb3       821248 1230847  409600  200M 83 Linux
 
student@uso:~$ ls -lh /dev/sdb*
brw-rw---- 1 root disk 8, 16 nov 12 10:30 /dev/sdb
brw-rw---- 1 root disk 8, 17 nov 12 10:30 /dev/sdb1
brw-rw---- 1 root disk 8, 18 nov 12 10:30 /dev/sdb2
brw-rw---- 1 root disk 8, 19 nov 12 10:30 /dev/sdb3

Spațiul rămas îl vom transforma într-o partiție extinsă.

student@uso:~$ sudo fdisk /dev/sdb
Command (m for help): n
Partition type
   p   primary (3 primary, 0 extended, 1 free)
   e   extended (container for logical partitions)
Select (default e): e
 
Selected partition 4
First sector (1230848-4194303, default 1230848): 
Last sector, +sectors or +size{K,M,G,T,P} (1230848-4194303, default 4194303): 
 
Created a new partition 4 of type 'Extended' and of size 1,4 GiB.
 
Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.
 
student@uso:~$ sudo fdisk -l /dev/sdb
Disk /dev/sdb: 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: dos
Disk identifier: 0xe901124e
 
Device     Boot   Start     End Sectors  Size Id Type
/dev/sdb1          2048  411647  409600  200M 83 Linux
/dev/sdb2        411648  821247  409600  200M 83 Linux
/dev/sdb3        821248 1230847  409600  200M 83 Linux
/dev/sdb4       1230848 4194303 2963456  1,4G  5 Extended

În cadrul partiției extinse putem crea oricâte partiții logice. Vom crea o partiție logică cu dimensiunea de 200MB.

student@uso:~$ sudo fdisk  /dev/sdb
 
Welcome to fdisk (util-linux 2.31.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
 
 
Command (m for help): n
All primary partitions are in use.
Adding logical partition 5
First sector (1232896-4194303, default 1232896): 
Last sector, +sectors or +size{K,M,G,T,P} (1232896-4194303, default 4194303): +200M
 
Created a new partition 5 of type 'Linux' and of size 200 MiB.
 
Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.
 
student@uso:~$ sudo fdisk -l /dev/sdb
Disk /dev/sdb: 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: dos
Disk identifier: 0xe901124e
 
Device     Boot   Start     End Sectors  Size Id Type
/dev/sdb1          2048  411647  409600  200M 83 Linux
/dev/sdb2        411648  821247  409600  200M 83 Linux
/dev/sdb3        821248 1230847  409600  200M 83 Linux
/dev/sdb4       1230848 4194303 2963456  1,4G  5 Extended
/dev/sdb5       1232896 1642495  409600  200M 83 Linux

Verificăm că au fost create fișierele corespunzătoare fiecărei partiții generate în directorul /dev/:

student@uso:~$ ls -lh /dev/sdb*
brw-rw---- 1 root disk 8, 16 nov 12 10:40 /dev/sdb
brw-rw---- 1 root disk 8, 17 nov 12 10:40 /dev/sdb1
brw-rw---- 1 root disk 8, 18 nov 12 10:40 /dev/sdb2
brw-rw---- 1 root disk 8, 19 nov 12 10:40 /dev/sdb3
brw-rw---- 1 root disk 8, 20 nov 12 10:40 /dev/sdb4
brw-rw---- 1 root disk 8, 21 nov 12 10:40 /dev/sdb5

Exerciții

  1. Partiționați HDD-ul cu dimensiunea de 2.0GB după modelul prezentat mai sus.
  2. Partiționați HDD-ul cu dimensiunea de 2.5GB după modelul următor:
    • Partiția 1 - Primară 1024MB
    • Partiția 2 - Primară 500MB
    • Partiția 3 - Primară 500MB
    • Partiția 4 - Extinsă 500MB
    • Partiția 5 - Logică (Inclusă în partiția 4) 300MB

Formatare (mkfs)

După ce am partiționat un HDD dorim să instalăm un sistem de fișiere în cadrul unei partiții. Pentru a instala sistemul de fișiere ext4 pe prima partiția identificată de fișierul de la calea /dev/sdb1 folosim următoarea comandă.

student@uso:~$ sudo mkfs.ext4 /dev/sdb1 
mke2fs 1.44.1 (24-Mar-2018)
Creating filesystem with 204800 1k blocks and 51200 inodes
Filesystem UUID: 637f30fb-6ed0-4309-b3bd-c613e2623c60
Superblock backups stored on blocks: 
	8193, 24577, 40961, 57345, 73729
 
Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (4096 blocks): done
Writing superblocks and filesystem accounting information: done

Observăm că partiției i s-a asociat un identificator unic al sistemului de fișiere (Filesystem UUID). Acesta poate fi văzut cu ajutorul comenzii blkid:

student@uso:~$ sudo blkid /dev/sdb*
/dev/sdb: PTUUID="e901124e" PTTYPE="dos"
/dev/sdb1: UUID="637f30fb-6ed0-4309-b3bd-c613e2623c60" TYPE="ext4" PARTUUID="e901124e-01"
/dev/sdb2: PARTUUID="e901124e-02"
/dev/sdb3: PARTUUID="e901124e-03"
/dev/sdb4: PTTYPE="dos" PARTUUID="e901124e-04"
/dev/sdb5: PARTUUID="e901124e-05"

Exerciții

  1. Instalați sistemul de fișiere ext4 pe partițiile identificate de fișierele sdb1, sdb2, sdb3, sdb5. Aveți grijă să omiteți partiția extinsă sdb4.
  2. Pe HDD-ul cu dimensiunea de 2.5GB instalați cel puțiun două sisteme de fișiere diferite.

Montare/Demontare

Pentru a avea acces la oricare dintre sistemele de fișiere instalate anterior, va trebui să îl montăm în cadrul sistemului de fișiere curent. Montarea se poate realiza în două modalități:

  • Temporar - cu ajutorul mount;
  • Permanent - prin configurarea fstab.

În cele ce urmează vom descrie pașii necesari pentru a monta temporar un sistem de fișiere.

Vom monta temporar prima partiție creată la calea /mnt/first_partition. Va trebui să ne asigurăm ca directorul first_partition există.

student@uso:~$ sudo mkdir /mnt/first_partition
student@uso:~$ ls -l /mnt/
total 4
drwxr-xr-x 2 root root 4096 nov 12 11:11 first_partition
 
student@uso:~$ sudo mount /dev/sdb1 /mnt/first_partition/

Observăm că a apărut directorul lost+found în /mnt/first_partition:

student@uso:~$ ls -l /mnt/first_partition/
total 12
drwx------ 2 root root 12288 nov 12 10:47 lost+found

De asemenea, utilitarul mount ne arată că operația a fost realizată cu succes:

student@uso:~$ mount | grep /dev/sdb1
/dev/sdb1 on /mnt/first_partition type ext4 (rw,relatime,data=ordered)

Pentru a demonta sistemul de fișiere pe care l-am montat anterior folosim următoarea comandă:

student@uso:~$ umount /dev/sdb1
student@uso:~$ mount | grep /dev/sdb1

Exerciții

  1. Montați fiecare dintre partițiile create anterior. Creați pentru fiecare partiție o intrare în /mnt/.
  2. Creați câte un fișier în fiecare dintre sistemele de fișiere montate anterior.
  3. Introduceți un stick USB în sistem. Urmăriți mesajele kernelului cu ajutorul dmesg pentru a identifica fișierul block asociat în directorul /dev. Montați stick-ul în /mnt.
  4. Repartiționați stick-ul usb și formatați fiecare partiție.

Montare permanentă (fstab)

Am văzut anterior cum putem să montăm temporar un sistem de fișiere în cadrul unui sistem de opare Linux. În mod implicit, ne dorim ca partițiile unui HDD să fie montate permanent. Pentru a realiza această operație ne vom folosi de fstab (file system table).

fstab este un fișier de configurare care poate fi găsit la calea /etc/fstab.

student@uso:~$ cat /etc/fstab
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
# / was on /dev/sda1 during installation
UUID=a14d0991-a3d8-48d6-ac8c-327d1a524501 /               ext4    errors=remount-ro 0       1
/swapfile                                 none            swap    sw              0       0

Fiecare linie conține 6 câmpuri cu următoarea semnificație:

  1. Identificator - UUID-ul file-system-ului sau calea către fișierul care conține un filesystem;
  2. Mount point - calea unde va fi montat sistemul de fișiere (ex. /mnt/first_partition);
  3. Tip - tipul sistemului de fișiere (ex. ext4)
  4. Opțiuni - mai multe detalii aici
  5. Dump - flag ce determină dacă este necesar backup;
  6. Pass - flag ce determină dacă se va efectua o verificare a sistemului de fișiere la start-up.

Exerciții

  1. Identificați UUID-ul sistemului de fișiere pentru partiția /dev/sdb1 (hint: blkid);
  2. Introduceți o intrare în fișierul de configurare fstab pentru a monta permanent această partiție în /mnt/first_partition. Asigurați-vă ca există directorul first_partition.

Backup

Ne dorim să avem o copie de backup pentru datele importante din cadrul sistemului curent. Vom folosi utilitarul rsync pentru a îndeplini această sarcină.

Cu ajutorul comenzii rsync putem face o copie backup atât local, cât și la distanță. De exemplu, dacă dorim să facem backup întregului conținut al directorului dir1 în cadrul directorului dir2 putem folosi următorea comandă:

rsync -a dir1/ dir2

Mai multe detalii despre cum poate fi folosit utilitarul rsyinc găsiți aici

Presupunem că toate datele utile disponibile în sistem se află în cadrul directorului /home/student/Documents

Exerciții

  1. Realizați o copie backup a directorului /home/student/Documents în directorul /home/student/backups. Asigurați-vă că directorul backups există.
  2. Urmărind articolul de aici faceți un backup la distanță pe fep.grid.pub.ro. Credențialele sunt aceleași cu cele de pe site-ul de cursuri acs.curs.pub.ro.

Get a life

1. Montare disk mașină virtuală VirtualBox Montați unul dintre disk-urile (.vdi) create anterior în cadrul mașinii virtuale fără a porni mașina virtuală. (hint: aici)

2. Montare sistem de fișiere cu criptare Montați un sistem de fișiere folosind eCryptfs. (hint: aici)

3. Extindere partiție swap Extindeți partiția de swap prin intermediului unui fișier de pe disk. (hint: dd, chown, mkswap, swapon, fstab)

4. Creare filesystem într-un fișier Creați un filesystem într-un fișier. (hint: dd, mkfs, mount)

Sumar. Cuvinte cheie

  • Dispozitive de stocare externe: HDD, SSD
  • Partiționare, formatare, sistemul de fișiere
  • Tipuri de tabele de partiții: MBR, GPT
  • Afișare informații despre dispozitivele de stocare și partiții: lsblk, parted, fdisk, gdisk
  • Montare și demontare partiții: mount, umount
uso/laboratoare/new/08-storage/all.txt · Last modified: 2019/11/17 19:11 by cristiana.stan
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0