Snapshots maken en gebruiken in BTRFS. "Failover" systeem gebaseerd op Ubuntu en btrfs btrfs commando's

Als nerd heb ik nog steeds de gewoonte om constant met het systeem te experimenteren: herbouwen, niet-stabiele RC-kernels installeren, experimentele update-takken aanzetten. Vaak zou ik zelfs zeggen dat ik het systeem te vaak kapot maak (mijn persoonlijk record, 2 weken zonder opnieuw te installeren).

Wat bedoel ik? Als iets extreem slecht werkt, bijvoorbeeld LibreOffice en Compiz die vaak crashen en graag vastlopen, probeer ik ofwel het systeem opnieuw te configureren, maar dit is lang genoeg en saai.

Waar leid ik eigenlijk naar toe.

Als iemand, zoals ik, graag met het systeem experimenteert en het beu is om het elke keer te herstellen, dan is hier een optie voor jou hoe ik dit probleem voor mezelf heb opgelost. Ik ga onder de kat.

How-to of gewone fiets.

Item 1: LiveCD

Post factum gaan we ervan uit dat de schijf is verdeeld in 2 partities: / boot geformatteerd in ext4 en / geformatteerd in btrfs.
De MBR bevat grub 2 op schijf.
Daarom het eerste punt:
Vanuit persoonlijke gewoonten en overwegingen is het veel gemakkelijker om het systeem te herstellen vanaf de grafische interface dan om het zwarte scherm te bewonderen en soms zonder toegang tot internet, commando's te onthouden en te schrijven. Nee, ik denk niet dat de console slecht is, ik hou van de console, maar op de een of andere manier, maar vanuit de grafische interface is het leuker.

Actie één

Het idee is niet nieuw, ik geef toe dat het ergens op Habré verscheen, maar ik heb de link niet gevonden, dus mijn excuses aan de bron van de publicatie.
Kopieer de afbeelding van de gewenste Live distra naar de / boot map
sudo cp /media/timofey/boot/grub/ISO/Linux/Ubuntu/ubuntu-12.10-desktop-amd64.iso /boot/ubuntu-12.10-desktop-amd64.iso
/ boot is verplaatst naar een aparte partitie, niet omdat het op deze manier beter is, maar omdat om mij onbekende redenen LiveCD's die van onder grub 2 naar btrfs zijn geschreven, niet worden geladen.
Nu repareren we de standaard grub 2-instellingen, zodat we de afbeelding niet verliezen wanneer we grub "a.
sudo nano /etc/grub.d/40_custom

En we voegen daar iets als dit in, na de opmerkingen:
menuentry "Ubuntu 12.10 amd64" (set isofile = / ubuntu-12.10-desktop-amd64.iso loopback loop $ isofile linux (loop) / casper / vmlinuz boot = casper iso-scan / bestandsnaam = $ isofile noeject noprompt - initrd (loop ) /casper/initrd.lz)

Eigenlijk was het geconfigureerd in de afbeelding en gelijkenis (officiële wiki ubuntu):
/ Grub2 / ISOBoot
Nu "bijna" het belangrijkste, we genereren de config opnieuw:

Sudo update-grub

Dat is het, nu kunnen we na opnieuw opstarten, terwijl we de shift-toets ingedrukt houden, een minisysteem starten met internet en een grafische interface, ongeacht de status van het hoofdsysteem.

Punt 2: Foto's:

Ik denk dat iedereen die al lang bekend is met Linux in ieder geval heeft gehoord over btrfs, misschien heeft zelfs dat al zijn eigen mening verzonnen. Bij het installeren van ubuntu op een partitie met btrfs, is de standaard erg verstandig, het mechanisme van subpartities wordt gebruikt en er worden 2 subpartities gemaakt: @ en home (die ik respectievelijk / en / home vervang, bij het opnieuw installeren van het systeem grammaticaal zullen we geen configs verliezen. Maar daar gaat het nu niet om. Hoe maakt u gebruik van deze zorg voor eindgebruikers? Erg makkelijk.

Een beetje achtergrond:
Aanvankelijk was het de bedoeling om het script via rc.local uit te voeren, maar het werd niet uitgevoerd, daarna werd het dagelijks via cron geïmplementeerd, later versloeg ik rc.local en tot de hel uitgeschakeld snapshots in cron.

Scriptcode:

#! / bin / bash #Dit script voor het automatisch maken van snapshots bij het opstarten #Version 1.2.9 set -e DATA = "$ (date +% g% m% d% k% M% S)" VOLUME = / dev / sda1 [ ! -d "/ tmp / $ DATA /"] && sudo mkdir "/ tmp / $ DATA /" mount $ VOLUME "/ tmp / $ DATA /" && ([! -d "/ tmp / $ DATA / snapshots /"] && sudo mkdir "/ tmp / $ DATA / snapshots /" mkdir "/ tmp / $ DATA / snapshots / $ DATA /" && cd "/ tmp / $ DATA /" btrfs subvolume snapshot ./@. "/ snapshots / $ DATA / @ _ $ (DATA) / "btrfs subvolume snapshot ./@home." / Snapshots / $ DATA / @ home _ $ (DATA) / "[! -F ./snapshots/snapshots.log] && touch ./snapshots / snapshots.log chmod 777 ./snapshots/snapshots.log echo on_startup _ $ (datum +% X_% x) >> ./snapshots/snapshots.log umount -l "/ tmp / $ DATA /" && sudo rmdir "/ tmp / $ DATA / ")

Het bevindt zich op / etc / btrfs_snapshot_onstartup
Voeg het toe aan /etc/rc.local en geef uitvoeringsrechten aan beide bestanden via sudo chmod + x "pad naar bestand"
Het loggen van de uitvoering in het bestand. / Snapshots / snapshots.log werkt mogelijk niet, dan moet u het handmatig maken onder de rechten van root. Na opnieuw opstarten krijgt hij zelf de nodige rechten.

We kunnen op elk moment de status van de systeemsnapshots bekijken door te typen:
cat /var/log/snapshots.log

Alle snapshots worden toegevoegd aan de systeemsectie in de snapshots-map, waar een map wordt gemaakt voor elke succesvolle systeemstart.
Sommigen zullen misschien beweren dat het niet loont om snapshots te maken bij de lancering. Het rechtvaardigt in geen geval dat ik in een dag een heleboel wijzigingen aan het systeem kan aanbrengen en het honderd keer opnieuw kan opstarten, en in alternatieve gevallen kan ik niet terugkeren naar het moment van een succesvolle lancering (werkelijk), maar slechts één dag geleden .

Optie, handmatig starten:
#! / bin / bash #Dit script voor het automatisch maken van snapshot #Version 1.2.8 set -e DATA = $ (datum +% g% m% d% k% M% S) ########### ####################### [! -d / tmp / $ DATA /] && sudo mkdir / tmp / $ DATA / sudo mount / dev / sda2 / tmp / $ DATA / && (################## # ################################################# [! -d / tmp / $ DATA / snapshots /] && mkdir / tmp / $ DATA / snapshots / mkdir / tmp / $ DATA / snapshots / $ DATA / cd / tmp / $ DATA / sudo btrfs subvolume snapshot ./@. / snapshots / $ DATA / @ _ $ (DATA) / sudo btrfs subvolume snapshot ./@home ./snapshots/$DATA/@home_$(DATA)/ ############### ################################################# # ## sudo chmod 777 ./snapshots/snapshots.log sudo echo this.hands _ $ (datum +% X_% x) >> ./snapshots/snapshots.log sudo cat ./snapshots/snapshots.log sleep 1 sudo umount - l / tmp / $ DATA / && sudo rmdir / tmp / $ DATA / ################################# # ################################# sudo btrfs bestandssysteem df / #informatie over fs) read exit 0

Punt 3: Herstel

Dat is waar ze voor probeerden, het systeem vermoordden, wat te doen?
We starten op vanaf de LiveCD, mounten de systeempartitie in een voor ons handige map.
Verberg of verwijder vervolgens, indien nodig, de standaard @- en home-subwollen.
en vervang de ontbrekende momentopname door de vereiste momentopname.
In de meeste gevallen is het vervangen van @ voldoende.
nazarpc

Met snapshots kun je niet alleen teruggaan naar een bepaalde status van het systeem, maar ook het gewenste bestand of de gewenste configuratie eruit halen, wat ook enige vrijheid geeft bij het verwijderen van bestanden van onbekende oorsprong.

Punt 4: Reiniging

Snapshots nemen niet veel ruimte in beslag, maar na verloop van tijd kunnen ze een grote hoeveelheid afval op de schijf verzamelen. Hier is een script om snapshotmappen automatisch op te schonen. Hiermee worden alle systeemsnapshots verwijderd

#! / bin / bash #Versie 0.0.9 set -e DATA = $ (datum +% g% m% d% k% M% S) [! -d "/ tmp / $ DATA"] && sudo mkdir "/ tmp / $ DATA" sudo mount / dev / sda1 "/ tmp / $ DATA" && (cd "/ tmp / $ DATA / snapshots /" voor i in * / * do sudo btrfs subvolume delete "$ i" gedaan voor i in * do sudo rmdir -v "$ i" gedaan echo opschonen _ $ (datum +% g% m% d% k% M% S)> "./ snapshots .log "sudo cp" ./snapshots.log "" /var/log/snapshots.log "sudo umount -l" / tmp / $ DATA "&& sudo rmdir" / tmp / $ DATA ") read exit 0

Resultaat

We hebben een relatief fouttolerant systeem gemaakt waarin we de mogelijkheid hebben om het systeem na een storing snel te herstellen. Tegelijkertijd een minimum aan tijd en moeite besteden aan het bouwen van een beveiligingssysteem.

Mijn eigen gedachten hierover

Ik denk dat een dergelijke oplossing waarschijnlijk niet nuttig zal zijn in grote IT-structuren, maar het zou ideaal moeten zijn voor klein thuisgebruik.

Het zou ook cool zijn om het opschoningsscript af te maken, zodat het alle oudere snapshots wist, bijvoorbeeld weken, en niet alle beschikbare, heb ik eerlijk gezegd, maar het werkte niet voor mij. Dan zou het ook kunnen worden aangestuurd, bijvoorbeeld standaard in cron, om eenmaal per dag te draaien, en dan opgenomen in het officiële installatiescript op btrfs, ik denk dat met kleine aanpassingen dit een vrij universele oplossing is op basis van de standaardfuncties van btrf's.

Ja, ik ken lvm, maar ik heb geen extra abstractielaag van de hardware nodig, en het is niet comme il faut om foto's naar een apart gedeelte te nemen.

UPD 1:
Met dank aan gebruikers

Overstappen naar een nieuw bestandssysteem is altijd een moeilijke taak. We vertrouwen al op het oude, beproefde bestandssysteem. Het heeft misschien zelfs enkele beperkingen in functionaliteit en prestaties, maar het heeft ons nooit in de steek gelaten. Nieuwe bestandssystemen bieden een zeer groot aantal functies, maar de vraag rijst: zijn ze te vertrouwen?

Een zo'n bestandssysteem is Btrfs. Dit is een relatief nieuw bestandssysteem dat in 2007 verscheen en is ontwikkeld door Oracle. Het biedt een zeer breed scala aan nieuwe functies en is daarom zeer interessant voor gebruikers, maar er gaan nog steeds geruchten op het internet dat dit bestandssysteem nog niet geschikt is voor permanent gebruik. In dit artikel proberen we erachter te komen welke mogelijkheden Btrfs ons biedt, en ook of het nu echt al gebruikt kan worden.

Zoals ik al zei, werd Btrfs in 2007 door Oracle ontwikkeld. Er is geen enkele decodering van de naam, sommigen zeggen dat het B-tree FS betekent, anderen Better Fs. Net als in andere bestandssystemen worden alle gegevens op specifieke adressen op schijf opgeslagen. Deze adressen worden opgeslagen in metadata. En hier beginnen de verschillen. Alle metadata is georganiseerd als b-trees. Dit geeft geweldige prestaties bij het werken met het bestandssysteem en stelt u ook in staat een onbeperkt aantal bestanden toe te voegen.

Maar zelfs dat is niet alles. Wanneer u het bestand overschrijft, worden de gegevens niet overschreven, maar wordt alleen het gewijzigde deel naar een nieuwe locatie gekopieerd. Vervolgens worden de metagegevens eenvoudig bijgewerkt. Hierdoor kunt u snapshots van het bestandssysteem maken die geen schijfruimte in beslag nemen totdat er veel wijzigingen zijn aangebracht. Als het oude blok niet langer nodig is omdat het geen deel uitmaakt van een snapshot, wordt het automatisch verwijderd.

Door zijn structuur heeft Btrfs enorme mogelijkheden, het kan bijvoorbeeld moderne zeer grote opslagmedia aan. De maximale bestandssysteemgrootte is 16 Exabytes. Dit is allemaal mogelijk dankzij het juiste gebruik van schijfruimte. Andere bestandssystemen gebruiken de hele harde schijf, van begin tot eind, om hun structuur te schrijven.

Btrfs doet het anders. Elke schijf, ongeacht de grootte, is verdeeld in blokken van 1 GB voor gegevens en 256 MB voor metagegevens. Deze blokken worden vervolgens verzameld in groepen, die elk op verschillende apparaten kunnen worden opgeslagen. Het aantal van dergelijke blokken in een groep kan afhangen van het RAID-niveau voor de groep. De volumemanager is al geïntegreerd in het bestandssysteem, dus er is geen extra software nodig.

Gegevensbescherming en compressie worden ook ondersteund op bestandssysteemniveau, dus ook hier hebt u geen extra programma's nodig. Het btrfs-bestandssysteem ondersteunt ook het spiegelen van gegevens op meerdere media. Andere kenmerken van btrfs die het vermelden waard zijn, zijn:

• Ondersteuning voor snapshots van het bestandssysteem, alleen-lezen of schrijven;
• Controlesommen voor gegevens en metagegevens met behulp van het crc32-algoritme. Op deze manier kan eventuele schade aan het blok zeer snel worden gesignaleerd;
• Compressie met Zlib en Lzo;
• Het bestandssysteem is geoptimaliseerd om met SSD te werken, detecteert automatisch SSD en begint zich anders te gedragen;
• Achtergrondproces voor foutdetectie en -correctie, evenals realtime defragmentatie en deduplicatie;
• Conversie van ext4 en ext3 en terug wordt ondersteund.

Dit is allemaal erg goed, maar kan dit bestandssysteem al worden gebruikt? Laten we het hiermee proberen uit te zoeken.

Is Btrfs klaar voor gebruik?

Er bestaan ​​nog steeds veel misvattingen rond Btrfs. Veel hiervan komen voort uit echte problemen die zich in de begindagen van de bestandssysteemontwikkeling voordeden. Maar mensen die naar deze informatie kijken, kijken niet naar de datum. Ja Btrfs was inderdaad onstabiel en onstabiel. Er waren veel problemen met gegevensverlies en veel gebruikers schreven erover, maar dat was in 2010.

Het belangrijkste onderdeel van een bestandssysteem is het opslagformaat op schijf. Maar het formaat van het Btrfs-bestandssysteem is al gerepareerd, het gebeurde in 2012 en het verandert niet meer tenzij het absoluut noodzakelijk is. Dit op zich is voldoende om de stabiliteit van btrfs te erkennen.

Maar waarom wordt Btrfs door velen als onstabiel beschouwd? Hier zijn verschillende redenen voor. Ten eerste is het de angst van gebruikers voor nieuwe technologieën. Dit was niet alleen in Linux, maar ook in Microsoft, toen ze overstapten naar NTFS, en in Apple. Maar er is een paradox hier, het XFS-bestandssysteem heeft 20 jaar stabiele ontwikkeling doorgemaakt, maar ext4, dat in 2006 is ontwikkeld vanuit de ext3-vork, wordt als het meest stabiele bestandssysteem beschouwd. Het is zelfs een jaar ouder dan Btrfs.

De tweede reden is actieve ontwikkeling, hoewel het gegevensopslagformaat is bevroren, wordt de belangrijkste codebase nog steeds actief ontwikkeld en is er nog veel ruimte voor verbetering van de prestaties en het introduceren van nieuwe functies.

Maar er is al veel bewijs dat het bestandssysteem klaar is. Dit bestandssysteem wordt gebruikt op de servers van Facebook, waar het bedrijf zijn gevoelige gegevens opslaat. En dat is op zich een belangrijke factor. Bedrijven als Facebook, SuSE, RedHat, Oracle, Intel en anderen werken aan het verbeteren van het bestandssysteem. Dit bestandssysteem is sinds release 12 de standaard in SUSE Linux Enterprise. Al deze factoren samen bewijzen dat het bestandssysteem vrij gebruiksklaar is. En gezien de functionaliteit en features van btrfs kan het al gebruikt worden.

Btrfs gebruiken

We hebben uitgezocht waarom het de moeite waard is om Btrfs te gebruiken en of het überhaupt de moeite waard is. Nu wil ik je een beetje oefening laten zien, zodat je dit bestandssysteem in actie kunt zien. Ik zal voorbeelden geven op basis van Ubuntu. Laten we eerst de tools voor het beheer van het bestandssysteem installeren:

sudo apt install btrfs-tools

Een btrfs-bestandssysteem maken

Eerst moet je een bestandssysteem maken. Laten we zeggen dat we twee harde schijven / dev / sdb en / dev / sdc hebben, we willen er een enkel bestandssysteem op maken met data mirroring. Om dit te doen, voert u gewoon uit:

sudo mkfs.btrfs / dev / sdb / dev / sdc

Standaard gebruikt het RAID0 voor data (geen duplicatie, en RAID1 voor metadata (duplicatie naar één schijf). Bij gebruik van één schijf worden metadata ook gedupliceerd, als u dit gedrag wilt uitschakelen, kunt u de -m single optie gebruiken:

sudo mkfs.btrfs -m single / dev / sdb

Maar door dit te doen, vergroot u het risico op gegevensverlies, want als de metagegevens verloren gaan, gaan de gegevens ook verloren.

U kunt informatie over het nieuw gemaakte bestandssysteem bekijken met de opdracht:

sudo btrfs bestandssysteem show / dev / sdb

Of over alle gemounte bestandssystemen:

sudo btrfs bestandssysteem show

Btrf's monteren

Gebruik het gebruikelijke commando om te mounten:

sudo mount / dev / sdb / mnt

Je kunt elk van de schijven mounten, het heeft hetzelfde effect. De regel in / etc / fstab ziet er als volgt uit:

/ dev / sdb / mnt btrfs standaard 0 1

Nu kijken we naar de informatie over de bezette ruimte op de schijven:

sudo btrfs bestandssysteem df / mnt

Compressie in btrfs

Om compressie in te schakelen, voegt u gewoon de compressieoptie toe aan mount. Het kan het lzo- of zlib-algoritme worden doorgegeven:

sudo mount -o compress = lzo / dev / sdb / mnt
$ sudo mount -o compress = zlib / dev / sdb / mnt

Btrfs-herstel

Gebruik de herstelbevestigingsoptie om beschadigde Btrfs te herstellen:

sudo mount -o recovery / dev / sdb / mnt

Verandering van maat

U kunt de grootte van het volume in realtime wijzigen door de opdracht resize te gebruiken:

sudo btrfs bestandssysteem formaat wijzigen -2g / mnt

Verklein de grootte met 2 gigabyte. Dan verhogen we het met 1 Gigabyte:

sudo btrfs bestandssysteem formaat wijzigen + 1g / mnt

Subvolumes maken

U kunt met Btrfs logische partities, subvolumes, binnen de hoofdpartitie maken. Ze kunnen in het hoofdgedeelte worden gemonteerd:

sudo btrfs subvolume create / mnt / sv1
$ sudo btrfs subvolume create / mnt / sv2
$ sudo btrfs subvolumelijst / mnt

Subvolumes monteren

U kunt een subvolume koppelen aan de id die is verkregen met de laatste opdracht:

sudo umount / dev / sdb

sudo mount -o subvolid = 258 / dev / sdb / mnt

Of u kunt de naam gebruiken:

sudo mount -o subvol = sv1 / dev / sdb / mnt

Subvolumes verwijderen

Voeg eerst de btrfs-root toe in plaats van het subvolume:

sudo umount / mnt

sudo mount / dev / sdb / mnt /

Om een ​​subvolume te verwijderen, kunt u het aankoppelpad gebruiken, bijvoorbeeld:

sudo btrfs subvolume delete / mnt / sv1 /

Momentopname maken

Met het Btrfs-bestandssysteem kunt u snapshots van wijzigingen maken. Hiervoor wordt het snapshot-commando gebruikt. Laten we bijvoorbeeld een bestand maken en vervolgens een momentopname maken:

touch / mnt / sv1 / test1 / mnt / sv1 / test2

Maak een momentopname:

sudo btrfs subvolume snapshot / mnt / sv1 / mnt / sv1_snapshot

Origineel: BTRFS-snapshots maken en gebruiken - Zelfstudie
Auteur: Igor Ljubuncic
Datum van publicatie: 25 februari 2012
Vertaling: A. Krivoshey
Datum van overdracht: april 2012

BTRFS is een relatief nieuw op ZFS gebaseerd bestandssysteem van Sun dat de afgelopen 25 jaar de meeste innovaties naar Unix heeft gebracht, voordat het werd overgenomen door Oracle. BTRFS wordt nog steeds als onstabiel beschouwd en daarom niet geschikt voor productietoepassingen. Dit bestandssysteem heeft echter veel handige functies die het ontdekken waard zijn. Een daarvan is het maken van snapshots van het systeem.
Laat me verduidelijken. Snapshots zijn snapshots van de staat van uw systeem. In zekere zin, als u een bestand kopieert en een back-up maakt, maakt u daarmee een momentopname ervan op het moment van kopiëren. Dit kan overal en altijd. Denk aan een bestandssysteem dat in feite meerdere kopieën van uw bestanden binnen zijn structuur kan beheren, en waarmee u ze kunt gebruiken zoals u dat wilt. Klinkt interessant, we gaan het onderzoeken.

BTRFS introductie

Voordat we dieper gaan graven, wil ik in het kort de mogelijkheden van dit bestandssysteem schetsen. BTRFS zou alle bewerkingen van het schijf- en bestandsbeheersysteem moeten afhandelen waarvoor normaal gesproken extra hulpprogramma's nodig zijn. BTRFS biedt defragmentatie, taakverdeling, verkleinen, uitbreiden, hot-swapping, RAID, snapshots, compressie, klonen en nog veel meer, allemaal ingebouwd in het stuurprogramma van het bestandssysteem. Met andere bestandssystemen hebt u waarschijnlijk een aantal andere stuurprogramma's en aangepaste hulpprogramma's nodig om al dit soort bewerkingen te beheren, zoals een bestandssysteemdefragmentatie, RAID- en LVM-stuurprogramma's, enzovoort.
Ingebouwde functionaliteit betekent prestaties en gebruiksgemak. BTRFS is op dit moment echter nog niet volledig bruikbaar vanwege instabiliteit en prestatievermindering in vergelijking met andere bestandssystemen zoals Ext4. Maar het heeft een enorm potentieel, dus het kan niet worden genegeerd, maar moet worden bestudeerd.
In deze zelfstudie laat ik u zien hoe u Snapshot-kopieën kunt beheren. Dit is een supersnelle functie waarmee u een back-up kunt maken van belangrijke bestanden voordat u er wijzigingen in aanbrengt en ze indien nodig kunt herstellen. In zekere zin is dit vergelijkbaar met Windows Systeemherstel plus een rollback-stuurprogramma op bestandssysteemniveau. Overigens vind je in dit artikel naast snapshots ook wat nuttige informatie over het dagelijkse werk met het BTRFS bestandssysteem. Testen gedaan op Fedora 16 Verne met een KDE-bureaublad.

Hoe BTRFS te beheren

U kunt BTRFS gebruiken voor het root-bestandssysteem, met uitzondering van / boot, dat moet worden geformatteerd met een traditioneel journaling-bestandssysteem. Voor de eenvoud werken we in deze tutorial met een apart apparaat / dev / sdb1, geformatteerd met BTRFS en indien nodig gebruikt. In de praktijk kan dit / home of / data zijn, of iets anders.

Dus wat gaan we doen?

We nemen / dev / sdb1 en mounten het. Dan zullen we verschillende subsecties maken. Beschouw subsecties als virtuele wortelbomen, aangezien elk een afzonderlijke, onafhankelijke boomachtige gegevensstructuur is, zelfs als de gegevens hetzelfde zijn.
Hieronder staat de volgorde van de commando's die hiervoor nodig zijn. Schrik niet, we leggen je uit hoe ze werken.

$ btrfs subvolume create / mnt / data $ btrfs subvolume create / mnt / data / orig $ echo "Dedoimedo is l33t"> / mnt / data / orig / file $ btrfs subvolume snapshot / mnt / data / orig / mnt / data / backup

/ dev / sdb1 is gemount op / mnt. We maken een subsectie met de naam data. Daarin maken we een andere subsectie met de naam orig. En al binnenin zullen onze bestanden worden gemaakt. Vanuit het oogpunt van de gebruiker zien de subsecties eruit als gewone mappen. Met andere woorden, data en data/origin zijn directories.
Vervolgens maken we een tekstbestand bij de oorsprong genaamd bestand dat wat tekst bevat. Ten slotte maken we een momentopname van de originele subsleutel en noemen deze back-up. We hebben nu een identieke kopie van de orig-subsleutel. Hier is het bewijs:

Bovendien gebruiken we om te controleren het commando btrfs-subvolumelijst om alle subsecties te bekijken:

$ btrfs subvolumelijst

Merk op dat elke subsectie een ander ID-nummer heeft. Zoals we binnenkort zullen zien, is dit belangrijk.

Standaard weergave

Momenteel geeft / mnt standaard zowel origineel als back-up weer (all in data). Wij kunnen dat veranderen. Weet je nog dat ik het eerder had over virtuele wortelboomstructuren? Met BTRFS kunt u de virtuele hoofdmap wijzigen in een van de subsleutels.
Het gebruik van subsecties en snapshots betekent dus eenvoudigweg schakelen tussen verschillende gegevenshiërarchieën. U hoeft geen bestanden te verwijderen, te overschrijven of iets anders te doen. Je schakelt gewoon over naar een andere subsectie. We zullen nu zien hoe dit wordt gedaan.
Team btrfs subvolume set-default ID is alles wat we nodig hebben. We stellen de standaardweergave in op een andere subsleutel, ontkoppelen vervolgens het apparaat en koppelen het opnieuw. Het is belangrijk!
Als u nu werkt met een bestandssysteem dat niet kan worden ontkoppeld omdat het in gebruik is, bijvoorbeeld / usr of / enz., moet u uw computer opnieuw opstarten om de wijzigingen door te voeren. Een andere subsectie wordt nu weergegeven in de gegeven directorystructuur. De gebruiker zal het verschil niet merken, maar de gegevens in de mappen zullen veranderen.
Om echt te zien hoe dit werkt, zullen we het bestand in back-up bewerken. Vervang de tekst Dedoimedo is l33t door Dedoimedo is NOT l33t.

$ echo "Dedoimedo is NIET l33t"> / mnt / data / back-up / bestand

Oké, we kennen de ID's van alle subsecties. Daarom zullen we de ID koppelen als de standaardweergave. Dit betekent dat zodra u opnieuw mount / mnt, we hier een bestand met deze inhoud zullen zien.

$ btrfs subvolume set-default 257 / mnt $ umount / mnt $ mount / dev / sdb1 / mnt

Laten we nu alles terugzetten:

Dit kan zo vaak worden gedaan als nodig is:

Hierboven hebben we de weergave gewijzigd tussen 257 en 260, dat wil zeggen tussen origineel en back-up, waardoor we de inhoud van het gewijzigde bestand konden bekijken. We hebben de gebruiker zojuist verschillende subsecties laten zien.
Als gevolg hiervan, als we zowel de originele als de back-up in de gegevensmap willen zien, moeten we de standaardweergave van de subsectie op het hoogste niveau herstellen, dat wil zeggen gegevens. Merk op dat alle gegevens worden weergegeven in de map / mnt, aangezien we deze als koppelpunt hebben geselecteerd. U kunt in plaats daarvan echter elke andere map gebruiken.

Gevolgtrekking

De BTRFS-snapshotfunctie is netjes en eenvoudig te gebruiken. Natuurlijk moet je voorzichtig zijn om de juiste gegevensboom te gebruiken en niets te verwarren. Maar nu ken je de basis BTRFS-commando's al en kun je zelfverzekerder handelen. In de toekomst zullen we Snapper testen, een BTRFS-frontend die beschikbaar is in openSUSE en waarmee u dezelfde functionaliteit kunt implementeren met een grafische gebruikersinterface voor degenen die niet van de opdrachtregel houden.

Niemand van ons is immuun voor fouten. Soms leidt het syndroom van scheve armen tot zeer trieste gevolgen. Soms is het erg moeilijk om weerstand te bieden en geen "anti-wetenschappelijke" experimenten met het systeem uit te voeren of een script/toepassing uit te voeren die is gedownload van een niet-geverifieerde bron. Dit is waar verschillende sandbox-tools en geavanceerde bestandssysteemmogelijkheden te hulp komen.

Invoering

* nix-systems zijn altijd relatief goed bestand geweest tegen verkeerd geschreven applicaties (in dat geval natuurlijk, als ze niet onder de superuser zijn gestart). Soms is er echter de wens om met het systeem te experimenteren - te stoeien met configuraties, waarvan sommige van vitaal belang kunnen zijn, een verdacht script uit te voeren, een programma te installeren dat is verkregen van een niet-vertrouwde bron ... Malvari. Dit artikel beschrijft een aantal manieren om de gevolgen van ongedwongen fouten te vermijden door terug te gaan naar een eerder gemaakt retourpunt (Btrfs-snapshots), een verdacht programma uit te voeren in een beperkte omgeving en je paranoia (Arkose en chroot) te vermaken.

Chroot

Chroot bestaat al heel lang. Het heeft een enorm voordeel ten opzichte van andere tools - het werkt overal, zelfs op zeer oude distributies. Al deze nieuwerwetse zandbakken zijn niets meer dan de verdere ontwikkeling ervan. Maar er zijn ook nadelen. Er is bijvoorbeeld geen manier om netwerken te beperken, root kan er met enige moeite uit komen, en het belangrijkste is dat het vrij moeilijk te configureren is. Desondanks is het voor sommige doeleinden, zoals het installeren van pakketten vanaf de bron, ideaal.

Er zijn ten minste drie manieren om een ​​chroot-omgeving te creëren:

1. U definieert alle toepassingen en bibliotheken die u nodig hebt om het programma zelf uit te voeren. Dit is de meest flexibele methode, maar ook de meest verwarrende.
2. De chroot-omgeving wordt dynamisch gegenereerd. Ooit was er een project Isolate, dat dit deed, maar nu is het om onbekende redenen in de vergetelheid geraakt.
3. Het basissysteem in een gespecificeerde map implementeren en ernaar rooten is wat ik zal beschrijven.

Grub en Btrfs

Hoogstwaarschijnlijk zal Grub bij het opstarten vanaf een Btrfs-partitie zweren dat schaarse bestanden onaanvaardbaar zijn en u vragen om een ​​willekeurige toets in te drukken. Om te voorkomen dat dit bericht verschijnt, opent u het bestand /etc/grub.d/00.header in uw favoriete teksteditor en geeft u daar commentaar op de volgende regel:

Als [-n "\ $ (have_grubenv)"]; dan als [-z "\ $ (boot_once)"]; vervolgens save_env recordfail; vij; fi

Eigenlijk is de recordfail-variabele nodig om een ​​cyclische reboot te voorkomen, waarvoor deze bij het opstarten wordt gespannen en vervolgens, bij succesvol laden, op 0 wordt gezet. Hoewel het ongewenst is om commentaar te geven op de code die verantwoordelijk is voor deze procedure, ik denk dat je op een desktopsysteem zonder kunt.

Ognelis in de zandbak - dit zegt de titel

Laten we eerst het debootstrap-pakket installeren, dat voor dit doel wordt gebruikt.

$ sudo apt-get install debootstrap

Laten we vervolgens een map voor de chroot maken en daar het basis-kwantale systeem implementeren. Over het algemeen kan het overal worden gemaakt, maar de traditionele locatie is / var / chroot. Aangezien de meeste van de volgende commando's root-rechten vereisen, is het logisch om over te schakelen naar het superuser-account:

$ sudo su - # mkdir / var / chroot && cd / var / chroot # debootstrap quantal ./quantal-chr1 http://mirror.yandex.ru/ubuntu

Laten we eens kijken naar de laatste opdracht. Het zet de release van de Quantal ubuntu in een aparte quantal-chr1-directory (je weet maar nooit, als je plotseling een andere chroot nodig hebt) van de dichtstbijzijnde mirror. Nadat de implementatie is voltooid, moet u de directory procfs, sysfs en (indien nodig) /dev aan deze substructuur toewijzen. Als chroot alleen voor teksttoepassingen wordt gebruikt totdat opnieuw wordt opgestart, zouden de volgende opdrachten voldoende moeten zijn:

# mount --bind / proc / var / chroot / quantal-chr1 / proc # mount --bind / sys / var / chroot / quantal-chr1 / sys # mount --bind / dev / var / chroot / quantal-chr1 / dev

Als je wilt dat deze substructuur werkt na een herstart, voeg dan de juiste regels toe aan / etc / fstab. Welnu, om sommige grafische toepassingen te laten werken, moet u ook de mappen / tmp en / var / run / dbus weergeven. Daarna kun je al de volgende opdracht invoeren, die in feite de chroot doet:

# chroot / var / chroot / quantal-chr1 /

En je zit er al in opgesloten. Om chroot niet te verwarren met een echt systeem, raad ik aan om de shell-prompt te wijzigen. Laten we bijvoorbeeld Skype in chroot installeren en uitvoeren. Om dit te doen, moet u het schroot-pakket op het hostsysteem installeren, wat het gemakkelijker maakt om programma's in een chroot-omgeving uit te voeren:

Implementeren om het basissysteem te chrooten met behulp van debootstrap # apt-get install schroot

Voeg vervolgens een item toe aan het bestand /etc/schroot/schroot.conf. In mijn geval heb ik het volgende toegevoegd:

/etc/schroot/schroot.conf description = Quantal Skype directory = / var / chroot / quantal-chr1 prioriteit = 3 gebruikers = rom groepen = rom root-groups = root, rom

We sturen / dev, / proc, / sys, / tmp en / var / run / dbus door - zie hierboven hoe je dit kunt doen. Voeg de skype-gebruiker en -groep toe aan de chroot - in dit geval is het wenselijk dat de uid en gid samenvallen met de uid / gid van de hoofdgebruiker van het echte systeem (in mijn geval rom), waarvoor we het volgende typen commando's:

# schroot -c quantal-skype -u root # addgroup --gid 1000 skype # adduser --disabled-password --force --uid 1000 --gid 1000 skype

Daarna plaatsen we de vers gedownloade Skype - opnieuw in chroot - en voldoen aan de afhankelijkheden ervan:

# dpkg --force-all -i skype-ubuntu-precise_4.1.0.20-1_i386.deb # apt-get -f install # exit

Op het hoofdsysteem staan ​​we verbindingen met de X-server toe vanaf localhost en gaan we als gewone gebruiker naar chroot:

$ xhost + localhost $ cd / && schroot -c quantal-skype -u rom / bin / bash

Stel de DISPLAY-variabele in (die u in het hoofdsysteem moet bekijken) en start Skype:

$ export DISPLAY = ": 0.0" $ skype --dbpath = / home / skype / .Skype &

Skype is succesvol geïnstalleerd en gestart in een chroot-omgeving.

Je zou een script kunnen schrijven om het opstarten te vergemakkelijken, maar dat kan je ook zelf doen.

Arkose gebruiken

Arkose werkt op een vergelijkbare manier als sandboxing in Windows, zoals Sandboxie. In de praktijk is het een handige wikkelaar voor LXC containers. Maar zoals u weet, zijn gemak en flexibiliteit soms onverenigbaar - het afstemmen van de gemaakte containers is moeilijk. Van de voordelen merk ik een intuïtieve interface op (als je de GUI gebruikt - starten vanaf de opdrachtregel is echter ook heel eenvoudig), van de minnen - standaard vereist het behoorlijk veel vrije ruimte op de harde schijf en er zijn enkele mogelijke oplossingen; maar als je Arkose gebruikt als een extra wrapper voor potentiële malware-injectie (browser) of zelfs maar experimenteert met een interessante applicatie, kan het geen kwaad.

Seccomp en seccomp-bpf

Seccomp is een weinig bekend mechanisme, geïntroduceerd in de 2.6.12-kernel, waarmee een proces een eenrichtingsovergang kan maken naar een "veilige" status, waar slechts vier systeemaanroepen beschikbaar zullen zijn - exit (), sigreturn (), lezen () en schrijven (), en de laatste twee zijn alleen beschikbaar voor bestanden die al open zijn. Als het proces een andere syscoll probeert aan te roepen, wordt het onmiddellijk afgebroken.

Uiteraard is deze oplossing niet erg flexibel. In dit opzicht verscheen seccomp-bpf in de 3.5-kernel, die het gebruik van BPF-regels mogelijk maakt om te verfijnen welke systeemaanroepen (en hun argumenten) zijn toegestaan ​​en welke niet. Seccomp-bpf wordt gebruikt in Google Chrome, Chrome OS en wordt ook teruggekoppeld naar Ubuntu 12.04.

Voordat u Arkose gebruikt, moet u het installeren. De procedure is standaard:

$ sudo apt-get install arkose-gui

Zowel de grafische interface (arkose-gui) als het opdrachtregelprogramma (arkose) worden geïnstalleerd. De grafische interface is zo eenvoudig dat ik er geen zin in heb om het te beschrijven, het is beter om meteen te gaan oefenen.

Handmatig aanmaken
alleen-lezen momentopname
ta in btrfs

Ik zal de opdrachtregelopties overwegen:

• -n (geen, direct, gefilterd) - sandbox-netwerktoewijzing. De geen en directe opties spreken voor zich, gefilterd creëert zijn eigen interface voor elke sandbox. In de praktijk is het beter om geen of direct te gebruiken, omdat het lang duurt om gefilterd te configureren.
• -d (geen, systeem, sessie, beide) - Sandbox-toegang tot D-Bus-bussen.
• -s size - stelt de opslaggrootte in megabytes in. De standaard is 2000 MB voor ext4 of de helft van het geheugen voor tmpfs. Nadat het programma dat in de sandbox is gestart, is voltooid, wordt de opslag vernietigd.
• -t is het type opslagbestandssysteem. Standaard wordt ext4 gebruikt.
• --root directory - Specificeert de directory die als root moet worden gesandboxed.
• --root-type (koe, bind) - hoe de wortel weer te geven. Als u cow gebruikt, gaan alle wijzigingen na het sluiten van de sandbox verloren en als u bindt, worden ze opgeslagen.
• --base-path - Specificeert de opslaglocatie voor de sandbox. Standaard is dit ~ / .arkose.
• --bind directory en --cow directory - geeft de directory weer in koemodus of direct. Het gebruik van deze of gene optie hangt natuurlijk af van het type root-display - het heeft geen zin om de --cow optie te gebruiken in een directory die al copy-on-write is.
• -h - gebruik de echte thuismap. Hetzelfde als --bind $ HOME.
• -p - Maakt het gebruik van PulseAudio mogelijk.

Laten we bijvoorbeeld Firefox starten:

$ sudo arkose -n direct -p firefox

Deze opdracht start Firefox met toegang tot internet en PulseAudio. Aangezien voor elke nieuw aangemaakte container standaard zijn eigen homedirectory wordt aangemaakt, zal het firelis-profiel ook nieuw zijn, zonder geïnstalleerde add-ons, als je die hebt.

"Maar wacht! Waarom sudo?" - een redelijke vraag kan rijzen. Het feit is dat sommige voorbereidende bewerkingen alleen beschikbaar zijn als root. Ik haast me echter om u gerust te stellen - het programma dat wordt gestart, werkt met de rechten van de huidige gebruiker.

Gebruiker toevoegen om Skype in chroot te starten

BTRFS in één oogopslag

Het komt voor dat na het installeren van updates het systeem crasht. Dit is waar tools vergelijkbaar met Windows Systeemherstel van pas komen. Ik verklaar met trots - we hebben ze! En een van die tools is Btrfs. Een van de voordelen van het nieuwe bestandssysteem van Oracle zijn de volgende:

• Kopiëren op schrijven (Copy-on-Write). Deze technologie wordt gebruikt om snapshots te maken - snapshots van de toestand van het systeem. Bij het maken van een momentopname kopieert de FS-driver de metadata erin en begint de daadwerkelijke opname te bewaken. Als het wordt gevonden, worden de originele gegevensblokken in de snapshot geplaatst en worden er nieuwe op hun plaats geschreven.
• Dynamische inodetoewijzing. In tegenstelling tot oude-generatie bestandssystemen, heeft Btrfs geen limiet op het aantal bestanden.
• Compressie van bestanden.
• De mogelijkheid om bestandssystemen op verschillende fysieke media te plaatsen. In feite is dit dezelfde RAID, alleen op een hoger niveau. Op het moment van schrijven worden RAID 0, RAID 1 en RAID 10 ondersteund, terwijl ondersteuning voor RAID 5 zich in de beginfase van ontwikkeling bevindt.

Momentopnamen maken en verwijderen

De opdracht btrfs wordt gebruikt om bewerkingen uit te voeren op een nieuwe generatie bestandssystemen, zoals het maken van snapshots, het defragmenteren van een volume en vele andere. De syntaxis is in het algemeen de volgende:

Btrfs<команда> <аргументы>

Wat kan er precies op Btrfs? Hieronder staan ​​​​de opdrachten die ik interessant vond.

• btrfs subvol maken [<путь>/]<имя>- creëert een subvolume (zie kader). Als er geen pad is opgegeven, maakt u het in de huidige map.
• btrfs subvol verwijderen<имя>- respectievelijk, verwijdert het subvolume.
• btrfs subvol vind-nieuw<путь> <поколение>- een lijst van de laatst gewijzigde bestanden in het opgegeven pad, te beginnen met de opgegeven generatie. Helaas is er tot nu toe geen manier om de huidige generatie van een bestand op een eenvoudige manier te achterhalen, dus het gebruik van dit commando kan gepaard gaan met dansen met een tamboerijn.
• btrfs subvol snapshot [-r]<подтом> <путь к снапшоту>- het hoogtepunt van het programma. Maakt een momentopname van het opgegeven subvolume met het opgegeven pad ernaartoe. De -r optie maakt het onmogelijk om naar snapshots te schrijven.
• btrfs subvol lijst<путь>- toont een lijst met subvolumes en snapshots langs het opgegeven pad.
• btrfs filesys df - ruimtegebruik voor het opgegeven koppelpunt.
• btrfs filesys formaat wijzigen [+/-]<новый размер> <путь>- ja, Btrfs heeft de mogelijkheid om het formaat aan te passen op een "live" systeem, en niet alleen te vergroten, maar ook te verkleinen! Met de argumenten denk ik dat alles min of meer duidelijk is, maar naast het specificeren van de grootte, kun je het max-argument gebruiken, dat de FS uitbreidt tot de maximaal mogelijke grootte.

De rest van de commando's, hoewel interessant, hebben alleen betrekking op het onderwerp van het artikel voor zover, en we zullen ze niet in overweging nemen. Dus om een ​​momentopname van een subvolume met de huidige datum te maken, bijvoorbeeld de hoofdmap, typen we de volgende opdracht:

$ sudo btrfs subvol snap -r / / snapshot-2013-01-16

$ sudo btrfs subvol del / snapshot-2013-01-16

Btrfs-subvolumes

Het Btrfs-subvolume kan op twee manieren werken: als directory en als VFS-object - iets dat kan worden aangekoppeld. Als u bijvoorbeeld Ubuntu installeert, worden er twee subvolumes gemaakt, @ en @home. De eerste bevat systeembestanden, de tweede bevat gebruikersgegevens. Dit is vergelijkbaar met het partitioneren van een schijf in partities, alleen als voorheen één partitie in de regel slechts één VFS-object kon bevatten, kunnen er nu op één partitie meerdere objecten tegelijk zijn en kunnen ze worden genest.

Automatisering

Ik heb niet veel zin in het maken van snapshots met pennen - je kunt het gewoon vergeten. Drie automatiseringsscenario's stellen zich voor:

• schrijf een script en plaats het in rc.local;
• schrijf een script en plaats het in cron;
• gebruik de opdracht btrfs autosnap.

Helaas is de laatste methode in Ubuntu 12.10 om de een of andere reden niet beschikbaar, dus er is praktisch geen keuze als zodanig. Persoonlijk gaf ik er de voorkeur aan om een ​​script voor de kroon te schrijven, maar laten we eerst een subvolume maken waarin onze snapshots worden opgeslagen. Waarvoor? In ieder geval om de hoofdmap niet te vervuilen.

# mkdir / mnt / sda11 # mount / dev / sda11 / mnt / sda11 # btrfs subvol create / mnt / sda11 / @ snapshots # umount / mnt / sda11

Laten we eens kijken wat deze commando's doen. Aangezien de eigenlijke root van de FS momenteel niet beschikbaar is (in plaats daarvan wordt het @ subvolume gebruikt als de root in ubuntu), moeten we deze mounten met handvatten. In mijn geval bevindt het zich op / dev / sda11. Met de derde opdracht maken we een @snapshots-subvolume - dus als we het of de echte root niet aankoppelen, is de inhoud niet beschikbaar. En nu het script zelf:

Autosnap.sh #! / Bin / bash set -e VOLUME = / dev / sda11 TMP_PATH = / tmp / snapshots MOUNT_OPTS = " [e-mail beveiligd]"# Huidige datum en tijd - vereist voor het genereren van de namen van mappen met snapshots NU =" $ (datum +% Y% m% d% H% M) "NOW_SEC =" $ (datum +% s) "if [$ # -ne 1]; then # Als het script zonder argumenten wordt uitgevoerd, stelt u de standaardwaarde een dag geleden in OLDER_SEC = "$ (date --date" 1 dag geleden "+% s)" else # Als we een argument hebben, overwegen we het is een datum in elk formaat dat het date-commando begrijpt, met al het volgende OLDER_SEC = "$ (date --date" $ 1 "+% s)" fi # Trek de vereiste datum af van de huidige datum en converteer deze naar minuten OUDER = $ (($ NOW_SEC- $ OLDER_SEC)) OLDER_MIN = $ (($ OLDER / 60)) [! -D "$ (TMP_PATH) /"] && mkdir "$ (TMP_PATH) /" [-z "` grep " $ (TMP_PATH)" / proc / mounts` "] && mount" $ (VOLUME) "" $ (TMP_PATH) / "-o" $ (MOUNT_OPTS) "&& (# Mount mkdir" $ (TMP_PATH) / $ (NU) / "# Maak snapshots btrfs subvol snap / "$ (TMP_PATH) / $ (NOW) / rootsnap"> / dev / null 2> & 1 btrfs subvol snap / home "$ (TMP_PATH) / $ (NOW) / homesnap"> / dev / null 2> & 1) && (# Zoeken naar mappen met snapshots ouder dan de opgegeven datum voor f in `find" $ (TMP_PATH) "-mindepth 1 - maxdepth 1 -type d -cmin + "$ OLDER_MIN" -print0 | xargs -0`; do btrfs subvol del "$ (f) / rootsnap"> / dev / null 2> & 1 && btrfs subvol del "$ (f) / homesnap"> / dev / null 2> & 1 && # en verwijder snapshots en mappen met hen rmdir "$ f" klaar) umount -l "$ (TMP_PATH)" && rmdir "$ (TMP_PATH)"

Dit script kan overal worden geplaatst waar het handig is (ik plaats dergelijke dingen persoonlijk liever in / usr / local / bin, maar dit is een kwestie van smaak), en voer het uit vanuit de crown of vanuit rc.local. Standaard roteert het script snapshots die ouder zijn dan één dag, maar u kunt elke gewenste hoeveelheid specificeren in het formaat van de datumopdracht - het belangrijkste is, vergeet niet om ze tussen aanhalingstekens te zetten.

Een ISO-image gebruiken

Om niet elke keer de schijf met de opgenomen ubuntu eruit te halen als er vitale bestanden beschadigd zijn, is het mogelijk om een ​​item toe te voegen om op te starten vanaf een ISO-image in het Grub-menu, wat ik voorstel te doen. Om dit te doen, heb je een niet-Btrfs-partitie nodig (omdat om onbekende redenen de standaard initramfs van de Ubuntu isoska de afbeelding niet willen zien als deze op de partitie met de beschreven FS staat) en directe handen. Voeg de volgende regels toe aan het bestand /etc/grub.d/40_custom:

Menu-item "Ubuntu 12.10 i386 iso" (insmod part_msdos insmod fat # Stel de root in van waar we de ISO-set root = "hd0, msdos7" krijgen # Het pad naar de afbeelding ten opzichte van de bovenstaande rootset isofile = / ubuntu-12.10-desktop -i386.iso # Monteer als een loopback-apparaat rechtstreeks in de Grub loopback-lus $ isofile linux (loop) / casper / vmlinuz boot = casper iso-scan / bestandsnaam = $ isofile noeject noprompt - initrd (loop) /casper/initrd.lz )

en voer de opdracht uit om de hoofdconfiguratie van Grub bij te werken:

$ sudo update-grub

Nu, zelfs in het geval van ernstige schade aan het systeem - tenzij natuurlijk de bootloader en zijn bestanden worden aangetast - kun je altijd opstarten vanaf de ISO-image en de beschadigde bestanden wijzigen of teruggaan naar de vorige staat van het systeem.

INFO

Als je als root in een chroot-omgeving werkt, is er een mogelijkheid om daar weg te komen. Een manier is om de systeemaanroep mknod () te gebruiken en vervolgens de echte root te mounten. Het installeren van de grsecurity-patchset lost dit probleem op.

Btrfs-opdrachten zijn standaard en afgekort. Het commando "btrfs subvolume snapshot" kan bijvoorbeeld worden geschreven als "btrfs su sn".

Stel dat je het systeem hebt laten vallen en dat je het moet herstellen vanaf de Btrfs-snapshot. Om dit te doen, start u op vanaf deze ISO-image, koppelt u de partitie waarop u het systeem hebt laten vallen - precies de partitie, geen ondertitel! - en voer de volgende commando's in (uiteraard aangepast voor uw snapshots en partities):

# cd / mnt / sda11 # mv @ @_badroot # mv @ snapshots / 201302011434 / rootsnap @

Doe indien nodig hetzelfde met @home en start opnieuw op. Als alles goed is gegaan, kun je @_badroot verwijderen:

$ sudo btrfs subvol del @_badroot

Gevolgtrekking

In *nix-systemen zijn er veel manieren om jezelf te beschermen tegen mislukte experimenten of om de gevolgen ervan te verzachten. Ik heb er een aantal bekeken. Het is echter vermeldenswaard dat al deze methoden vooral bedoeld zijn voor experimentatoren die graag dieper in het systeem graven. Ze zijn niet geschikt om malware op te vangen - ze zijn eenvoudig genoeg te detecteren, hoewel ze zeker een zeker beveiligingsniveau bieden.

Btrfs(soms uitgesproken als butter fs) is een nieuw gratis bestandssysteem dat wordt ondersteund door Oracle. Gedistribueerd onder de GPL-licentie. Ondanks het feit dat de ontwikkeling ervan nog verre van voltooid is, werd het bestandssysteem op 9 januari 2009 geïntegreerd in de Linux-kernel en is het beschikbaar in Debian Squueze.

Hoewel Btrfs was opgenomen in de 2.6.29-kernel, stellen de ontwikkelaars dat "vanaf kernel 2.6.31 we alleen van plan zijn om vanaf nu een compatibel schijfwisselformaat te maken." Ontwikkelaars willen nog steeds de gebruikers- / beheertools verbeteren om ze gebruiksvriendelijker te maken. Zie de link in de sectie voor meer informatie over Btrfs.

Ext2 / 3/4 kan worden omgezet naar Btrfs (maar niet omgekeerd).

Toestand

Debian Squeeze en nieuwere versies ondersteunen Btrfs.

FAQ

Welk pakket bevat de btrfs-hulpprogramma's?

btrfs-tools (in DebianSqueeze en hoger)

Zie ook: Btrfs wiki FAQ

Voorbeelden van opdrachten voor het werken met btrfs

Aanmaken van bestandssysteem:

mkfs.btrfs

Beheer van volumes, subvolumes, snapshots; de integriteit van het bestandssysteem controleren:

btrfsctl

Scannen op btrfs-bestandssystemen:

btrfsctl -a btrfsctl -A / dev / sda2

Maak snapshots en subvolumes:

mount -t btrfs -o subvol =. / dev / sda2 / mnt btrfsctl -s new_subvol_name / mnt btrfsctl -s snapshot_of_default / mnt / default btrfsctl -s snapshot_of_new_subvol / mnt / new_subvol_name btrfsctl -s mpsnapsnap_of_snt

De omvangbomen van het bestandssysteem controleren:

btrfsck

Metadata weergeven in tekstvorm:

debug-tree debug-tree / dev / sda2> & big_output_file

Toon btrfs-bestandssystemen op harde schijf:

btrfs-show / dev / sda *

Defragmentatie (standaard niet vereist):

# btrfs bestandssysteem defragmenteren / mnt of # btrfs bestandssysteem defragmenteren /mnt/file.iso

Een ext3-bestandssysteem converteren naar btrfs

Het ext3-bestandssysteem kan worden omgezet in btrfs en behandeld worden als een nieuw bestandssysteem. Bovendien zal de status van het originele ext3-bestandssysteem later beschikbaar zijn.

# Voer fsck altijd eerst% uit # fsck.ext3 -f / dev / xxx # Converteer vanuit Ext3-> Btrfs% # btrfs-convert / dev / xxx # Mount het resulterende Btrfs-bestandssysteem% # mount -t btrfs / dev / xxx / btrfs # Mount de ext3 snapshot% # mount -t btrfs -o subvol = ext2_saved / dev / xxx / ext2_saved # Loopback mount het afbeeldingsbestand% # mount -t ext3 -o loop, ro / ext2_saved / image / ext3

De status van het originele bestandssysteem is nu zichtbaar in de /ext3-directory.

Demontage gebeurt in omgekeerde volgorde:

% # umount / ext3% # umount / ext2_saved% # umount / btrfs

U kunt teruggaan naar het ext3-bestandssysteem en uw wijzigingen kwijtraken:

% # btrfs-convert -r / dev / xxx

Of je kunt op btrfs blijven en de opgeslagen ext3-bestandssysteemafbeelding verwijderen:

% # rm / ext2_saved / afbeelding

Opmerking: het nieuwe bestandssysteem heeft soms een zeer grote metadata-omvang na conversie.

Grootte van metadata bekijken:

# btrfs bestandssysteem df / mnt / data1tb /

Normaliseer hun grootte:

btrfs fi saldo / mnt / btrfs

Lees meer: ​​Conversie van ext3 (Engels) en Converteren van ext3fs naar btrfs (Russisch)

De grootte van het bestandssysteem en de partities wijzigen

Voor btrfs is het formaat van het bestandssysteem online beschikbaar (on-the-fly). Eerst moet je de gewenste partitie mounten:

# mount -t btrfs / dev / xxx / mnt

2GB toevoegen:

# btrfs bestandssysteem formaat wijzigen + 2G / mnt of # btrfsctl -r + 2g / mnt

Verlaagd met 4GB:

# btrfs bestandssysteem formaat wijzigen -4g / mnt of # btrfsctl -r -4g / mnt

Grootte instellen op 20 GB bestandssysteem:

# btrfsctl -r 20g / mnt of # btrfs bestandssysteem formaat wijzigen 20g / mnt

Alle vrije ruimte gebruiken:

# btrfs bestandssysteem resize max / mnt of # btrfsctl -r max / mnt

De bovenstaande opdrachten zijn alleen geldig voor het bestandssysteem. Om de grootte van een partitie te wijzigen, moet u andere hulpprogramma's gebruiken, bijvoorbeeld fdisk. Laten we een voorbeeld bekijken om een ​​partitie met 4 GB te verkleinen. Mount en verklein de partitie:

# mount -t btrfs / dev / xxx / mnt # btrfsctl -r -4g / mnt

Laten we nu de partitie ontkoppelen en fdisk gebruiken:

# umount / mnt fdisk / dev / xxx # waarbij dev / xxx de harde schijf is met de partitie die we nodig hebben