{"id":98090,"date":"2020-10-24T02:42:38","date_gmt":"2020-10-24T00:42:38","guid":{"rendered":"https:\/\/prohoster.info\/blog\/administrirovanie\/ustojchivoe-hranenie-dannyh-i-fajlovye-api-linux"},"modified":"2020-11-18T00:58:48","modified_gmt":"2020-11-17T22:58:48","slug":"ustojchivoe-hranenie-dannyh-i-fajlovye-api-linux","status":"publish","type":"post","link":"https:\/\/prohoster.info\/sl\/blog\/administrirovanie\/ustojchivoe-hranenie-dannyh-i-fajlovye-api-linux","title":{"rendered":"Vzdr\u017eljivo shranjevanje podatkov in datote\u010dni API-ji za Linux","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Pri raziskovanju vzdr\u017eljivosti shranjevanja podatkov v obla\u010dnih sistemih sem se odlo\u010dil preizkusiti samega sebe, da se prepri\u010dam, da razumem osnovne stvari. Jaz sem za\u010del z branjem specifikacije NVMe<\/a><\/noindex> , da bi se poglobil v to, katere garancije glede vzdr\u017eljivega shranjevanja podatkov (tj. garancije, da bodo podatki dostopni po sistemskem okvari) nam nudijo diski NVMe. Ugotovil sem naslednje klju\u010dne to\u010dke: treba je \u0161teti podatke za po\u0161kodovane od trenutka, ko je izdana ukaz za zapis podatkov, do trenutka, ko se kon\u010da njihov zapis na nosilec informacij. Vendar pa se v ve\u010dini programov za zapis podatkov mirno uporabljajo sistemski klici.<\/p>\n

V tem gradivu raziskujem mehanizme vzdr\u017eljivega shranjevanja podatkov, ki jih nudijo datote\u010dni API-ji za Linux. Zdi se, da bi moralo biti to preprosto: program izvede ukaz write()<\/code>, in po tem, ko se ta ukaz zaklju\u010di, bi morali biti podatki zanesljivo shranjeni na disku. Vendar write()<\/code> samo kopira podatke aplikacije v predpomnilnik jedra, ki se nahaja v pomnilniku. Da bi prisilili sistem k zapisovanju podatkov na disk, je potrebno uporabiti nekatere dodatne mehanizme.<\/p>\n

\"Vzdr\u017eljivo<\/a><\/noindex><\/p>\n

Na splo\u0161no to gradivo predstavlja zbirko opomb o tem, kar sem se nau\u010dil o meni zanimivem podro\u010dju. \u010ce zelo kratko povem najpomembnej\u0161e, je potrebno za organizacijo vzdr\u017eljivega shranjevanja podatkov uporabiti ukaz fdatasync()<\/code> ali odpirati datoteke z zastavico O_DSYNC<\/code>. \u010ce vas zanima podrobno, kaj se dogaja s podatki na poti od programske kode do diska, si oglejte to<\/a><\/noindex> \u010dlanek.
\n<\/a><\/noindex><\/p>\n

Posebnosti uporabe funkcije write()<\/h2>\n

\nSistemski klic write()<\/code> je definiran v standardu IEEE POSIX<\/a><\/noindex> kot poskus zapisa podatkov v datote\u010dni opisnik. Po uspe\u0161ni izvedbi write()<\/code> operacije bi morale vrniti tiste bajte, ki so bili pred tem zapisani, tudi v primeru, da se podatkom dostopa iz drugih procesov ali niti (tukaj je<\/a><\/noindex> ustrezni del standarda POSIX). Tukaj<\/a><\/noindex>, v razdelu, posve\u0107enom interakciji tokova s obi\u010dnim operacijama s datotekama, postoji napomena koja govori da ako svaki od dva toka poziva te funkcije, svaki poziv treba vidjeti ili sve ozna\u010dene posljedice koje proistje\u010du iz izvr\u0161enja drugog poziva, ili uop\u0107e nijednu posljedicu. To omogu\u0107uje zaklju\u010dak da sve operacije ulaza\/izlaza s datotekama trebaju zadr\u017eati zaklju\u010davanje resursa s kojim rade.<\/p>\n

Zna\u010di li to da je operacija write()<\/code> atomarna? Tehni\u010dki gledano \u2014 da. Operacije \u010ditanja podataka trebaju vra\u0107ati ili sve ili ni\u0161ta od onoga \u0161to je bilo zapisano pomo\u0107u write()<\/code>. No, operacija write()<\/code>, prema standardu, ne mora nu\u017eno zavr\u0161iti zapisivanjem svega \u0161to je ponu\u0111eno za zapisivanje. Dozvoljeno joj je da izvr\u0161i zapisivanje samo dijela podataka. Na primjer, mogu\u0107a su dva toka, svaki od kojih pridru\u017euje 1024 bajta datoteci opisanoj istim datote\u010dnim deskriptorom. S aspekta standarda, prihvatljiv rezultat bi bio kada svaka od operacija zapisivanja mo\u017ee pridru\u017eiti datoteci samo po jedan bajt. Te operacije \u0107e ostati atomske, ali nakon \u0161to zavr\u0161e, podaci zapisani njima u datoteku bit \u0107e pomije\u0161ani. Evo<\/a><\/noindex> vrlo zanimljive diskusije o ovoj temi na Stack Overflow.<\/p>\n

Funkcije fsync() i fdatasync()<\/h2>\n

\nNajjednostavniji na\u010din za ispu\u0161tanje podataka na disk je poziv funkcije fsync()<\/a><\/noindex>. Ova funkcija tra\u017ei od operativnog sustava da prenese sve modificirane blokove iz predmemorije na disk. Tu su uklju\u010deni i svi metapodaci datoteke (vrijeme pristupa, vrijeme izmjene datoteke i tako dalje). Smatram da je potreba za tim metapodacima rijetka, stoga, ako znate da vam nisu va\u017eni, mo\u017eete koristiti funkciju fdatasync()<\/code>. U pom\u0107i<\/a><\/noindex> o fdatasync()<\/code> stoji da tijekom rada ove funkcije dolazi do spremanja na disk onog obujma metapodataka koji je \"neophodan za ispravno izvo\u0111enje sljede\u0107ih operacija \u010ditanja podataka\". A to je upravo ono \u0161to brine ve\u0107inu aplikacija.<\/p>\n

Jedan od problema koji ovdje mo\u017ee nastati je to da ti mehanizmi ne jam\u010de da \u0107e se datoteka mo\u0107i otkriti nakon mogu\u0107eg kvara. Konkretno, kada se stvara nova datoteka, potrebno je pozvati fsync()<\/code> za mapu, koja ga sadr\u017ei. Ina\u010de, nakon kvara mo\u017ee se dogoditi da taj fajl ne postoji. Razlog tome je u tome \u0161to u UNIX-u, zbog kori\u0161\u0107enja tvrdih linkova, fajl mo\u017ee postojati u vi\u0161e mapa. Stoga prilikom poziva fsync()<\/code> fajl nema na\u010dina da sazna iz koje ta\u010dno mape tako\u0111e treba prebaciti na disk (tukaj<\/a><\/noindex> o tome se mo\u017ee vi\u0161e pro\u010ditati). \u010cini se da datote\u010dni sistem ext4 mo\u017ee automatski<\/a><\/noindex> primenjivati fsync()<\/code> na direktorijume koji sadr\u017ee odgovaraju\u0107e fajlove, ali u slu\u010daju drugih datote\u010dnih sistema to mo\u017eda nije slu\u010daj.<\/p>\n

Omekani mehanizam mo\u017ee biti razli\u010dito implementiran u razli\u010ditim datote\u010dnim sistemima. Koristio sam blktrace<\/a><\/noindex> da bih saznao koje se diskovne operacije koriste u datote\u010dnim sistemima ext4 i XFS. Obe izbacuju standardne komande za upis na disk i za sadr\u017eaj fajlova i za dnevnik datote\u010dnog sistema, prebacuju ke\u0161 i zavr\u0161avaju rad, izvr\u0161avaju\u0107i FUA-upis (Force Unit Access, upis podataka direktno na disk, presko\u010div\u0161i ke\u0161) u dnevnik. Verovatno to rade upravo da bi potvrdili \u010dinjenicu izvr\u0161enja operacije. Na diskovima koji ne podr\u017eavaju FUA, to izaziva dva prebacivanja ke\u0161a. Moji eksperimenti su pokazali da fdatasync()<\/code> pomalo br\u017ee fsync()<\/code>. Alat blktrace<\/code> ukazuje na to da fdatasync()<\/code> obi\u010dno pi\u0161e na disk manje podataka (u ext4 fsync()<\/code> zapisuje 20 KiB, a fdatasync()<\/code> \u2014 16 KiB). Pored toga, otkrio sam da je XFS malo br\u017ei od ext4. A ovde je uz pomo\u0107 blktrace<\/code> uspeo da sazna da fdatasync()<\/code> prebacuje na disk manje podataka (4 KiB u XFS).<\/p>\n

Nejasne situacije koje nastaju prilikom kori\u0161\u0107enja fsync()<\/h2>\n

\nMogu se setiti tri nejasne situacije koje se ti\u010du fsync()<\/code>, s kojima sam se susreo u praksi.<\/p>\n

Prvi takav slu\u010daj dogodio se 2008. godine. Tada je interfejs Firefox 3 \u201ezabrzavao\u201c kada je vr\u0161ena upisivanje na disk velikog broja fajlova. Problem je bio u tome \u0161to je u implementaciji interfejsa za skladi\u0161tenje podataka o svom stanju kori\u0161\u0107ena baza podataka SQLite. Nakon svake promene koja se dogodila u interfejsu, pozivana je funkcija fsync()<\/code>, \u0161to je davalo dobre garancije stabilnog skladi\u0161tenja podataka. U upotrebljenom datote\u010dnom sistemu ext3 funkcija fsync()<\/code> sistemaga barcha \"iflos\" sahifalarni diskka qaytarardi, faqat tegishli faylga aloqador bo'lganlarini emas. Bu shuni anglatadiki, Firefox-da tugmani bosish diskda megabayt ma'lumotlarni yozishni boshlashi mumkin edi, bu esa ko'p soniyalarni olishi mumkin. Muammoni hal qilish, men tushunganimdek, tega<\/a><\/noindex> ma'lumotni asinxron fon vazifalariga ko'chirishda edi. Bu Firefox dastlab ma'lumotlarni saqlashda yanada qattiq talablarni qabul qilganligini anglatadi, buning esa aslida zaruriyati yo'q edi, va ext3 fayl tizimining xususiyatlari bu muammoni yanada kuchaytirgan.<\/p>\n

Ikkinchi muammo 2009 yilda yuz berdi. Shunda, tizimning muvaffaqiyatsizligi sababli, ext4 fayl tizimidan foydalanuvchilar ko'p yangi yaratilgan fayllarning nol uzunlikka ega ekanini ko'rishdi, eski ext3 fayl tizimi bilan bunday holat yuz bermadi. Oldingi bo'limda men ext3 diskga juda ko'p ma'lumotlarni qaytarganligini aytgan edim, bu esa ishlashni sekinlashtirardi. fsync()<\/code>Muammolarni yaxshilash uchun ext4da diskka faqat ma'lum faylga aloqador \"iflos\" sahifalar qaytariladi. Boshqa fayllar ma'lumotlari ext3ga nisbatan ancha uzoq vaqt davomida xotirada qoladi. Bu ish samaradorligini oshirish uchun amalga oshirildi (odatda ma'lumotlar bunday holatda 30 soniya qoladi, buni dirty_expire_centisecs<\/a><\/noindex>; tukaj<\/a><\/noindex> bilan o'zgartirish mumkin). Bu esa ma'lumotlar kattaroq hajmda bir necha marta yo'qolishi mumkinligini anglatadi. Ushbu muammoni hal qilish uchun fsync()<\/code> ma'lumotlarni doimiy saqlash va ularni muvaffaqiyatsizliklardan maksimal darajada himoya qilish zarur bo'lgan dasturlarda qo'llaniladi. Ushbu fsync()<\/code> ext4da farq qiladi ext3ga qaraganda. Bunday yondashuvning kamchiligi shundaki, bu kabi yondashuv, avvalgi kabi, ba'zi operatsiyalarni sekinlashtiradi, masalan, dasturlarni o'rnatish. Buni batafsil ko'ring ovde<\/a><\/noindex> in ovde<\/a><\/noindex>.<\/p>\n

Uchinchi muammo, fsync()<\/code>, 2018 yilda yuz berdi. Shunda, PostgreSQL loyihasi doirasida, agar fsync()<\/code> xato yuzaga kelsa, u \"iflos\" sahifalarni \"toza\" deb belgilashini aniqladi. Natijada keyingi chaqiruvlar fsync()<\/code> ni\u010d s takimi stranmi ne delajo. Zaradi tega se spremenjene strani shranjujejo v pomnilniku in nikoli ne zapi\u0161ejo na disk. To je prava katastrofa, saj bo aplikacija mislila, da so nekateri podatki zapisani na disk, v resnici pa ne bodo. Tak\u0161ne napake fsync()<\/code> redko pridejo do izraza, aplikacija v tak\u0161nih situacijah skoraj nima mo\u017enosti za re\u0161evanje te\u017eave. Danes, ko to pride do izraza, PostgreSQL in druge aplikacije nenadoma prenehajo delovati. Tukaj<\/a><\/noindex>, v \u010dlanku \u201eAli se aplikacije lahko obnovijo po napakah fsync?\u201c, je ta problem podrobno raziskan. Trenutno je najbolj\u0161a re\u0161itev tega problema uporaba Direct I\/O s parametrom O_SYNC<\/code> ali s parametrom O_DSYNC<\/code>. S takim pristopom bo sistem poro\u010dal o napakah, ki se lahko pojavijo pri izvajanju specifi\u010dnih zapisovalnih operacij, a ta pristop zahteva, da aplikacija sama upravlja z oblogami. Podrobnosti o tem preberite ovde<\/a><\/noindex> in ovde<\/a><\/noindex>.<\/p>\n

Odprite datoteke z uporabo parametrov O_SYNC in O_DSYNC<\/h2>\n

\nVrnimo se k razpravi o mehanizmih Linuxa, ki zagotavljajo zanesljivo shranjevanje podatkov. To pomeni uporabo parametra O_SYNC<\/code> ali parametra O_DSYNC<\/code> pri odpiranju datotek z uporabo sistemskega klica open()<\/a><\/noindex>. S takim pristopom se vsaka zapisovalna operacija izvaja tako, kot da po vsaki ukaz write()<\/code> sistemu daje, ustrezno, ukaze fsync()<\/code> in fdatasync()<\/code>. U specifikacije POSIX<\/a><\/noindex> to se imenuje \u201eSynchronized I\/O File Integrity Completion\u201c in \u201eData Integrity Completion\u201c. Glavna prednost tak\u0161nega pristopa je, da je za zagotavljanje celovitosti podatkov potrebno izvesti le en sistemski klic, ne pa dveh (na primer - write()<\/code> in fdatasync()<\/code>). Glavna slabost tega pristopa pa je, da bodo vse zapisovalne operacije, ki uporabljajo ustrezen opis datoteke, sinhronizirane, kar lahko omeji mo\u017enosti strukturiranja kode aplikacije.<\/p>\n

Uporaba Direct I\/O s parametrom O_DIRECT<\/h2>\n

\nSistemski klic open()<\/code> podpira parameter O_DIRECT<\/code>, ki je zasnovan tako, da zaobide predpomnilnik operacijskega sistema in izvaja vhodno-izhodne operacije, ki neposredno komunicirajo z diskom. To v mnogih primerih pomeni, da se zapisni ukazi, ki jih izda program, neposredno pretvarjajo v ukaze, usmerjene na delo z diskom. A na splo\u0161no ta mehanizem ni zamenjava funkcij fsync()<\/code> ili fdatasync()<\/code>. Gre za to, da sam disk lahko odlo\u017eiti ili ke\u0161irati<\/a><\/noindex> odgovaraju\u0107e komande za zapis podataka. I, \u0161to je jo\u0161 gore, u nekim posebnim slu\u010dajevima operacije ulaza-izlaza, izvr\u0161ene kori\u0161\u0107enjem zastavice O_DIRECT<\/code>, se prenose<\/a><\/noindex> u tradicionalne baferisane operacije. Najlak\u0161e je re\u0161iti ovaj problem koriste\u0107i dodatnu zastavicu prilikom otvaranja fajlova O_DSYNC<\/code>, \u0161to \u0107e zna\u010diti da \u0107e nakon svake operacije zapisa uslediti poziv fdatasync()<\/code>.<\/p>\n

Ispostavilo se da je u XFS fajl sistemu nedavno dodat \"brzi put\" za O_DIRECT|O_DSYNC<\/code>-zapis podataka. Ako prepisuju blok koriste\u0107i O_DIRECT|O_DSYNC<\/code>, onda \u0107e XFS, umesto ispu\u0161tanja ke\u0161a, izvr\u0161iti FUA-zapis komandnog poziva ako ure\u0111aj to podr\u017eava. To sam potvrdio koriste\u0107i alat blktrace<\/code> u Linuxu 5.4\/Ubuntu 20.04. Ovaj pristup bi trebao biti efikasniji, jer se pri njegovoj primeni na disk upisuje minimalna koli\u010dina podataka i koristi se jedna operacija, a ne dve (upis i ispu\u0161tanje ke\u0161a). Na\u0161ao sam link na zakrpu<\/a><\/noindex> jezgra iz 2018. godine, u kojem je implementiran ovaj mehanizam. Tu se vodi rasprava koja se ti\u010de primene ove optimizacije i u drugim fajl sistemima, ali koliko ja znam, XFS je za sada jedini fajl sistem koji to podr\u017eava.<\/p>\n

Funkcija sync_file_range()<\/h2>\n

\nU Linuxu postoji sistemski poziv sync_file_range()<\/a><\/noindex>, koji omogu\u0107ava ispu\u0161tanje na disk samo dela fajla, a ne celog fajla. Ovaj poziv inicira asinhrono ispu\u0161tanje podataka i ne \u010deka njegovo zavr\u0161avanje. Me\u0111utim, u uputstvu za sync_file_range()<\/code> se navodi da je ova komanda \"veoma opasna\". Njena upotreba se ne preporu\u010duje. Osobine i opasnosti sync_file_range()<\/code> veoma dobro su opisane u ovom<\/a><\/noindex> materijalu. Konkretno, o\u010digledno je da ovaj poziv koristi RocksDB za upravljanje vremenom kada jezgro ispu\u0161ta \"prljave\" podatke na disk. Ali pritom se koristi i fdatasync()<\/code>. U kodu<\/a><\/noindex> RocksDB postoje zanimljivi komentari o ovoj temi. Na primer, \u010dini se da poziv sync_file_range()<\/code> prilikom kori\u0161\u0107enja ZFS ne dovodi do ispu\u0161tanja podataka na disk. Iskustvo mi sugerira da kod koji se retko koristi mo\u017ee sadr\u017eati gre\u0161ke. Zbog toga bih preporu\u010dio da se ovaj sistemski poziv ne koristi bez velike potrebe.<\/p>\n

Sistemski pozivi koji poma\u017eu u obezbe\u0111ivanju trajnog skladi\u0161tenja podataka<\/h2>\n

\nPri\u0161el sem do zaklju\u010dka, da je za izvajanje vhodno\/izhodnih operacij, ki zagotavljajo trajno shranjevanje podatkov, mogo\u010de uporabiti tri pristope. Vsi zahtevajo klic funkcije fsync()<\/code> za direktorij, v katerem je bila ustvarjena datoteka. Tukaj so ti pristopi:<\/p>\n

    \n
  1. Klic funkcije fdatasync()<\/code> ili fsync()<\/code> po funkciji write()<\/code> (bolje je uporabiti fdatasync()<\/code>).<\/li>\n
  2. Delo s pripomo\u010dkom za datoteke, odprtim s zastavico O_DSYNC<\/code> ili O_SYNC<\/code> (bolje \u2014 z zastavico O_DSYNC<\/code>).<\/li>\n
  3. Uporaba ukaza pwritev2()<\/code> z zastavico RWF_DSYNC<\/code> ili RWF_SYNC<\/code> (prednostno \u2014 z zastavico RWF_DSYNC<\/code>).<\/li>\n<\/ol>\n

    <\/p>\n

    Opombe o zmogljivosti<\/h2>\n

    \nNisem se ukvarjal s temeljitim merjenjem zmogljivosti razli\u010dnih mehanizmov, ki sem jih raziskal. Opazne razlike v hitrosti njihovega delovanja so precej majhne. To pomeni, da bi se lahko motil, in da bi v drugih pogojih lahko isti mehanizmi pokazali druga\u010dne rezultate. Najprej bom govoril o tem, kar mo\u010dneje vpliva na zmogljivost, nato pa o tistem, kar na zmogljivost vpliva manj.<\/p>\n

      \n
    1. Prepisovanje podatkov datoteke je hitrej\u0161e kot dodajanje podatkov k datoteki (prihranek v zmogljivosti je lahko od 2 do 100%). Dodajanje podatkov datoteki zahteva dodatne spremembe v metapodatkih datoteke, celo po sistemskem klicu fallocate()<\/code>, a obseg tega u\u010dinka se lahko spreminja. Priporo\u010dam, da za zagotovitev najbolj\u0161e zmogljivosti, pokli\u010dete fallocate()<\/code> za predhodno dodelitev potrebnega prostora. Nato je treba ta prostor izrecno napolniti z ni\u010dlami in poklicati fsync()<\/code>. S tem bodo ustrezni bloki v datote\u010dnem sistemu ozna\u010deni kot 'dodeljeni', ne kot 'nedodeljeni'. To prina\u0161a majhno (pribli\u017eno 2%) izbolj\u0161anje zmogljivosti. Poleg tega lahko nekateri diski upo\u010dasnijo prvo operacijo dostopa do bloka v primerjavi z drugimi. To pomeni, da lahko polnjenje prostora z ni\u010dlami privede do znatnega (pribli\u017eno 100%) izbolj\u0161anja zmogljivosti. \u0160e posebej se to lahko zgodi pri diskih AWS EBS<\/a><\/noindex> (to so neuradni podatki, ki jih nisem mogel potrditi). Enako velja za shrambe GCP Persistent Disk<\/a><\/noindex> (in to so \u017ee uradne informacije, potrjene s testi). Drugi strokovnjaki so opazili enake opazovanja<\/a><\/noindex>, ki se nana\u0161ajo na razli\u010dne diske.<\/li>\n
    2. Manj kot je sistemskih klicev \u2014 vi\u0161ja je zmogljivost (prihranek zna\u0161a pribli\u017eno 5%). Zdi se, da je klic open()<\/code> z zastavico O_DSYNC<\/code> ali klic pwritev2()<\/code> z zastavico RWF_SYNC<\/code> br\u017eji klic fdatasync()<\/code>. Sumim, da je razlog v tem, da pri tak\u0161nem pristopu igra vlogo to, da za re\u0161evanje iste naloge opravimo manj sistemskih klicev (en klic namesto dveh). A razlika v zmogljivosti je zelo majhna, zato se lahko nanjo povsem ne ozrete in v aplikaciji uporabite tisto, kar ne bo povzro\u010dilo zapletov v njeni logiki.<\/li>\n<\/ol>\n

      \n\u010ce vas zanima tema trajne shrambe podatkov \u2014 tukaj je nekaj koristnih gradiv:<\/p>\n