Այժմ մենք նկարագրելու ենք Linux սկավառակի ամենատարածված ֆայլային համակարգը՝ ext2: Linux-ի առաջին թողարկումն օգտագործում էր MINIX 1 ֆայլային համակարգը, որն ուներ կարճ ֆայլերի անուններ և ֆայլի առավելագույն չափը 64 ՄԲ։ MINIX 1 ֆայլային համակարգը ի վերջո փոխարինվեց առաջին ընդլայնված ֆայլային համակարգով, ext, որը թույլ էր տալիս ավելի երկար ֆայլերի անուններ և ֆայլերի ավելի մեծ չափեր: Ցածր արդյունավետության պատճառով (կատարման առումով) ext-ը փոխարինվեց իր իրավահաջորդ ext2-ով, որն այսօր էլ լայնորեն կիրառվում է։

Ext2 սկավառակի բաժանումը պարունակում է Նկար 1-ում ներկայացված ֆայլային համակարգը: 10.17 դասավորություն. Block 0-ը չի օգտագործվում Linux-ի կողմից և պարունակում է համակարգչի բեռնման կոդը: Բլոկ 0-ից հետո սկավառակի բաժանումը բաժանվում է բլոկների խմբերի (բացառությամբ սկավառակի բալոնների սահմանների): Յուրաքանչյուր խումբ կազմակերպված է հետևյալ կերպ.

Առաջին բլոկը գերբլոկ է, որը պահպանում է տեղեկատվություն ֆայլային համակարգի դասավորության մասին, ներառյալ i-հանգույցների քանակը, սկավառակի բլոկների քանակը, անվճար սկավառակի բլոկների ցանկի սկիզբը (սա սովորաբար մի քանի հարյուր տարր է): Դրան հաջորդում է խմբի նկարագրիչը, որը պարունակում է տեղեկատվություն bitmaps-ի գտնվելու վայրի, խմբում ազատ բլոկների և i-հանգույցների քանակի և խմբում դիրեկտորիաների քանակի մասին: Այս տեղեկատվությունը կարևոր է, քանի որ ext2 ֆայլային համակարգը փորձում է դիրեկտորիաները հավասարաչափ բաշխել ամբողջ սկավառակի վրա:

Երկու բիթքարտեզները հետևում են անվճար բլոկներին և անվճար i-հանգույցներին (սա նաև ժառանգված է MINIX 1 ֆայլային համակարգից և տարբերում է այն UNIX ֆայլային համակարգերից, որոնք օգտագործում են անվճար բլոկների ցուցակ): Յուրաքանչյուր bitmap-ի չափը մեկ բլոկ է: 1 ԿԲ բլոկի չափով այս դիզայնը սահմանափակում է բլոկի խմբի չափը մինչև 8192 բլոկ և 8192 i-հանգույց: Առաջին թիվը իրական սահմանափակում է, իսկ երկրորդը գործնականում չկա: 4 ԿԲ բլոկների համար թվերը չորս անգամ ավելի մեծ են:

Այնուհետև i-հանգույցներն իրենք են գտնվում: Դրանք համարակալված են 1-ից մինչև որոշ առավելագույնը: Յուրաքանչյուր i-node-ի չափը 128 բայթ է, և այն նկարագրում է ուղիղ մեկ ֆայլ: i-node-ը պարունակում է հաշվապահական տեղեկատվություն (ներառյալ այն ամենը, ինչ վերադարձվել է stat-ի կողմից, որը պարզապես վերցնում է այն i-node-ից), ինչպես նաև բավարար տեղեկատվություն՝ գտնելու բոլոր սկավառակի բլոկները, որոնք պարունակում են ֆայլի տվյալները:

i-հանգույցներին հաջորդում են տվյալների բլոկները: Բոլոր ֆայլերը և գրացուցակները պահվում են այստեղ: Եթե ​​ֆայլը կամ գրացուցակը բաղկացած է մեկից ավելի բլոկից, ապա այդ բլոկները չպետք է իրար հարակից լինեն սկավառակի վրա: Իրականում մեծ ֆայլի բլոկները, ամենայն հավանականությամբ, ցրված կլինեն ամբողջ սկավառակի վրա:

Համապատասխան i-հանգույցները ցրված են սկավառակի բլոկի բոլոր խմբերում: Ext2-ը փորձում է սովորական ֆայլերը տեղադրել նույն բլոկխմբում, ինչ մայր գրացուցակը, իսկ տվյալների ֆայլերը նույն բլոկում, ինչ սկզբնաղբյուր ֆայլի i-հանգույցը (ենթադրելով, որ այնտեղ բավարար տարածք կա): Այս գաղափարը փոխառվել է Berkeley Fast File System-ից (McKusick et al., 1984): Bitmaps-ն օգտագործվում է բաշխման արագ որոշումներ կայացնելու համար

տարածք նոր ֆայլային համակարգի տվյալների համար:

Երբ նոր ֆայլերի բլոկներ են հատկացվում, ext2-ը նաև նախատեղացնում է մի քանի (ութ) լրացուցիչ բլոկներ նույն ֆայլի համար (նվազագույնի հասցնելու ֆայլի մասնատումը ապագա գրումների պատճառով): Այս սխեման բաշխում է ֆայլային համակարգը ամբողջ սկավառակի վրա: Այն ունի նաև լավ կատարողականություն (շնորհիվ իր հարակից միտումի և կրճատված մասնատման):

Ֆայլը մուտք գործելու համար նախ պետք է օգտագործեք Linux համակարգային զանգերից մեկը (օրինակ՝ բաց), որի համար պետք է նշեք դեպի ֆայլ տանող ուղին: Այս ուղին վերլուծված է, և դրա բաղկացուցիչ գրացուցակները հանվում են դրանից: Եթե ​​նշված է հարաբերական ուղի, ապա որոնումը սկսվում է գործընթացի ընթացիկ գրացուցակից, հակառակ դեպքում՝ արմատային գրացուցակից: Ամեն դեպքում, առաջին գրացուցակի համար i-node-ը հեշտ է գտնել՝ պրոցեսի նկարագրիչում կա դրա ցուցիչ, կամ (արմատային գրացուցակի դեպքում) այն պահվում է սկավառակի որոշակի բլոկում:

Գրացուցակը թույլ է տալիս օգտագործել ֆայլերի անունները մինչև 255 նիշ (նկ. 10.18): Յուրաքանչյուր գրացուցակ բաղկացած է մի շարք սկավառակի բլոկներից (որպեսզի գրացուցակը հնարավոր լինի ատոմային կերպով գրել սկավառակի վրա): Գրացուցակում ֆայլերի և գրացուցակների տարրերը գտնվում են չտեսակավորված հերթականությամբ (յուրաքանչյուր տարր անմիջապես հաջորդում է նախորդին): Տարրերը չեն կարող հատել բլոկի սահմանները, ուստի սովորաբար յուրաքանչյուր սկավառակի բլոկի վերջում կան չօգտագործված բայթեր:

Գրացուցակի յուրաքանչյուր մուտք Նկ. 10.18-ը բաղկացած է չորս ֆիքսված երկարությամբ և մեկ փոփոխական երկարությամբ դաշտերից: Առաջին դաշտը i-node համարն է՝ 19 հսկայական ֆայլի համար, 42՝ ծավալուն ֆայլի և 88՝ bigdir գրացուցակի համար։ Դրան հաջորդում է rec_len դաշտը, որը տալիս է գրացուցակի ամբողջ մուտքի չափը բայթերով (հնարավոր է, որ անունից հետո լրացուցիչ տեղապահեր կան): Այս դաշտն անհրաժեշտ է հաջորդ գրառումը գտնելու համար (այն դեպքում, երբ ֆայլի անունը կցվում է բայթերի անհայտ քանակով): Նկարում այս դաշտը նշված է սլաքով: Այնուհետև տեղակայված է այնպիսի դաշտ, ինչպիսին է ֆայլը, գրացուցակը և այլն: Վերջին ֆիքսված երկարությամբ դաշտը պարունակում է ֆայլի անվան երկարությունը բայթերով (այս օրինակի համար՝ 8, 10 և 6): Վերջապես, կա ինքնին ֆայլի անունը, որն ավարտվում է զրոյական բայթով և լրացվում է 32-բիթանոց սահմանով: Դրան կարող են հաջորդել լրացնող լրացուցիչ բայթեր:

Նկ. 10.18b-ը ցույց է տալիս նույն գրացուցակը այն բանից հետո, երբ տարրը հանվել է ծավալուն: Այն ամենը, ինչ անում է գրացուցակում, նախորդ հսկայական ֆայլի ռեկորդային չափի դաշտն ավելացնելն է, և հեռավոր ծավալուն ֆայլի գրացուցակի մուտքագրման բայթերը դառնում են առաջին գրառման տեղապահներ: Հետագայում այս բայթերը կարող են օգտագործվել նոր ֆայլ ստեղծելիս գրելու համար:

Քանի որ գրացուցակները որոնվում են գծային եղանակով, մեծ գրացուցակի վերջում գրառում գտնելը կարող է երկար ժամանակ տևել: Հետևաբար, համակարգը պահպանում է վերջերս մուտք գործած գրացուցակների քեշը: Քեշում որոնումը կատարվում է ֆայլի անունով, և եթե այն գտնվի, ապա թանկարժեք գծային որոնումն այլևս պետք չէ։ Ճանապարհի յուրաքանչյուր բաղադրիչի համար գրացուցակի մուտքագրման քեշը մուտքագրվում է ատամնափառ, և (իր i-հանգույցի միջոցով) գրացուցակը որոնվում է հետագա ուղու մուտքերի համար (մինչև ֆայլի իրական i-հանգույցը գտնվի):

Օրինակ՝ բացարձակ ճանապարհով նշված ֆայլը գտնելու համար (օրինակ՝ / usr / ast / ֆայլ), հետևեք այս քայլերին. Նախ, համակարգը գտնում է արմատային գրացուցակը, որը սովորաբար օգտագործում է i-node համարը 2 (հատկապես, երբ i-node համարը 1 վերապահված է վատ բլոկների համար): Այն պահում է համապատասխան տարրը գրացուցակի մուտքագրման քեշում (արմատային գրացուցակի հետագա որոնումների համար): Այնուհետև այն որոնում է արմատային գրացուցակում «usr» տողի համար, որպեսզի ստանա i-node համարը / usr գրացուցակի համար (որը նաև պահվում է գրացուցակի մուտքագրման քեշում): Այս i-հանգույցը այնուհետև կարդացվում է, և սկավառակի բլոկները հանվում են դրանից, այնպես որ կարող եք կարդալ / usr գրացուցակը և փնտրել «ast» տողը: Համապատասխան տարրը գտնելուց հետո այն կարող է օգտագործվել՝ որոշելու համար i-node համարը / usr / ast գրացուցակի համար: Հաշվի առնելով այս i-node համարը, այն կարելի է կարդալ և գտնել գրացուցակի բլոկներում: Ի վերջո, մենք փնտրում ենք «ֆայլ» և գտնում ենք դրա i-node համարը: Այսպիսով, հարաբերական ուղու օգտագործումը ոչ միայն ավելի հարմար է օգտագործողի համար, այլև նվազեցնում է համակարգի աշխատանքի ծավալը:

Եթե ​​ֆայլը հասանելի է, համակարգը հանում է i-node համարը և օգտագործում այն ​​որպես i-node աղյուսակի ինդեքս (սկավառակի վրա)՝ գտնելու համապատասխան i-հանգույցը և կարդալ այն հիշողության մեջ: Այս i-հանգույցը տեղադրված է i-node աղյուսակում՝ միջուկի տվյալների կառուցվածք, որը պարունակում է բոլոր i-հանգույցները՝ բացելու համար: այս պահինֆայլեր և գրացուցակներ: i-node տարրերի ձևաչափը պետք է պարունակի (առնվազն) բոլոր դաշտերը, որոնք վերադարձվել են stat համակարգի կողմից, որպեսզի stat աշխատի (տես Աղյուսակ 10.10): Աղյուսակ 10.13-ը ցույց է տալիս i-node կառուցվածքի որոշ դաշտեր, որոնք աջակցվում են Linux ֆայլային համակարգի կողմից: i-node-ի իրական կառուցվածքը պարունակում է շատ ավելի շատ դաշտեր, քանի որ սա նույն կառուցվածքն է, որն օգտագործվում է դիրեկտորիաների, սարքերի և այլ հատուկ ֆայլերի ներկայացման համար: i-node կառուցվածքը պարունակում է նաև հետագա օգտագործման համար նախատեսված դաշտեր: Պատմությունը ցույց է տվել, որ չօգտագործված բիթերը երկար ժամանակ պարապ չեն մնում։

Այժմ տեսնենք, թե ինչպես է համակարգը կարդում ֆայլը: Հիշեք, որ գրադարանային ընթացակարգի սովորական զանգը կարդալու համակարգային զանգը սկսելու համար ունի հետևյալ տեսքը.

n = կարդալ (fd, բուֆեր, nbytes);

Երբ միջուկը ձեռք է բերում վերահսկողություն, այն կարող է սկսել միայն այս երեք պարամետրերը և դրա ներքին աղյուսակների տեղեկատվությունը (օգտագործողին վերաբերող): Այս ներքին աղյուսակների տարրերից մեկը ֆայլերի նկարագրիչների զանգվածն է: Այն ինդեքսավորվում է ֆայլերի նկարագրիչներով և պարունակում է մեկ տարր յուրաքանչյուր բաց ֆայլի համար (մինչև որոշակի առավելագույն թիվը, լռելյայն սովորաբար 32 է):

Գաղափարն այն է, որ սկսվի այս ֆայլի նկարագրիչով և ավարտվի համապատասխան հանգույցով: Դիտարկենք մի լիովին հնարավոր սխեմա՝ ֆայլի նկարագրիչ աղյուսակում ցուցիչ դնել հանգույցի վրա: Չնայած իր պարզությանը, այս մեթոդը (ցավոք սրտի) չի աշխատում: Խնդիրը հետեւյալն է. Յուրաքանչյուր ֆայլի նկարագրիչ պետք է ունենա համապատասխան ֆայլի ցուցիչ, որը նույնականացնում է ֆայլի բայթը, որտեղից պետք է սկսել կարդալու կամ գրելու հաջորդ գործողությունը: Որտեղ պետք է պահվի այս ցուցիչը: Տարբերակներից մեկն այն հանգույցի աղյուսակում տեղադրելն է: Այնուամենայնիվ, այս մոտեցումը չի աշխատի, եթե մի քանի անկապ գործընթացներ միաժամանակ բացեն նույն ֆայլը, քանի որ յուրաքանչյուր գործընթաց պետք է ունենա իր ցուցիչը:

Երկրորդ լուծումը ցուցիչը ֆայլի նկարագրության աղյուսակում տեղադրելն է: Ավելին, յուրաքանչյուր գործընթաց, որը բացում է ֆայլը, ունի իր սեփական դիրքը ֆայլում: Ցավոք սրտի, այս սխեման նույնպես չի աշխատում, բայց այս դեպքում ձախողման պատճառն այնքան էլ ակնհայտ չէ և կապված է Linux համակարգում ֆայլերի փոխանակման բնույթի հետ։ Դիտարկենք shell script 5-ը, որը բաղկացած է երկու հրամաններից (p1 և p2), որոնք պետք է կատարվեն հերթով: Եթե ​​սցենարը կանչվում է հրամանի տողով

ապա ակնկալվում է, որ p1-ն իր ելքը կգրի x ֆայլում, և այնուհետև p2-ը նույնպես կգրի իր ելքը x ֆայլում՝ սկսած այնտեղից, որտեղ p1-ը դադարեց:

Երբ կեղևը սկսում է p1 պրոցեսը, x ֆայլը սկզբում դատարկ կլինի, ուստի p1 հրամանը պարզապես կսկսի գրել ֆայլին 0 դիրքում: Այնուամենայնիվ, երբ p1-ն ավարտի իր աշխատանքը, անհրաժեշտ է որոշակի մեխանիզմ՝ ապահովելու համար, որ p2 գործընթացը տեսնի որպես դրա մեկնարկային դիրքը ոչ թե 0 է (բայց դա հենց այն է, ինչ տեղի կունենա, եթե ֆայլի դիրքը պահվի ֆայլի նկարագրության աղյուսակում), այլ այն արժեքը, որի վրա կանգ է առել pi-ն:

Ինչպես է դա արվում, ցույց է տրված Նկ. 10.19. Խնդիրը նոր աղյուսակ ներկայացնելն է՝ նկարագրության աղյուսակը բաց ֆայլեր(բաց ֆայլի նկարագրության աղյուսակ) - ֆայլի նկարագրության աղյուսակի և i-node աղյուսակի միջև և դրա մեջ պահել ֆայլի ցուցիչը (ինչպես նաև կարդալու/գրելու բիթը): Նկարում ծնող պրոցեսը կեղևն է, իսկ երեխան սկզբում պրոցես pi է, ապա պրոցես p2: Երբ shell-ը ստեղծում է pi պրոցես, նրա օգտագործողի կառուցվածքը (ներառյալ ֆայլի նկարագրության աղյուսակը) հետևյալն է ճշգրիտ պատճենընույն կեղևի կառուցվածքը, այնպես որ նրանք երկուսն էլ պարունակում են նույն բաց ֆայլի նկարագրության աղյուսակի ցուցիչներ: Երբ գործընթացի pi-ն դուրս է գալիս, shell ֆայլի նկարագրիչը շարունակում է մատնանշել բաց ֆայլի նկարագրիչ աղյուսակը, որը պարունակում է գործընթացի p1 դիրքը ֆայլում: Երբ կեղևն այժմ ստեղծում է պրոցես p2, նոր երեխա գործընթացն ավտոմատ կերպով ժառանգում է դիրքը ֆայլում, և ոչ նոր պրոցեսը, ոչ էլ կեղևը չի պահանջվում իմանալ այս դիրքի ընթացիկ արժեքը:

Եթե ​​որևէ կողմնակի գործընթաց բացում է ֆայլը, ապա այն կստանա իր սեփական մուտքը բաց ֆայլերի նկարագրության աղյուսակում՝ ֆայլում իր դիրքով, ինչը հենց այն է, ինչ անհրաժեշտ է: Այսպիսով, բաց ֆայլի նկարագրության աղյուսակի նպատակն է թույլ տալ ծնող և երեխա գործընթացներին կիսել նույն ցուցիչը ֆայլում, բայց տրամադրել անձնական ցուցիչներ արտաքին գործընթացների համար:

Այսպիսով (վերադառնալով ընթերցում կատարելու խնդրին), մենք ցույց տվեցինք, թե ինչպես է որոշվում դիրքը ֆայլում և i-node-ում: I-node-ը պարունակում է ֆայլի առաջին 12 բլոկների սկավառակի հասցեները: Եթե ​​ֆայլի դիրքն ընկնում է իր առաջին 12 բլոկների մեջ, ապա անհրաժեշտ ֆայլի բլոկը կարդացվում է և տվյալները պատճենվում են օգտագործողին: 12 բլոկից ավելի երկար ֆայլերի համար i-node-ը պարունակում է մեկ անուղղակի բլոկի սկավառակի հասցեն (Նկար 10.19): Այս բլոկը պարունակում է լրացուցիչ սկավառակի բլոկների սկավառակի հասցեներ: Օրինակ, եթե բլոկի չափը 1 ԿԲ է, իսկ սկավառակի հասցեն՝ 4 բայթ, ապա մեկ անուղղակի բլոկը կարող է պահել մինչև 256 սկավառակի հասցե: Այս սխեման թույլ է տալիս աջակցել մինչև 268 ԿԲ չափի ֆայլեր:

ext2(կոչվում է նաև որպես ext2fs) - Երկրորդ ընդլայնված ֆայլային համակարգ(Երկրորդ ընդլայնված ֆայլային համակարգ) ֆայլային համակարգ է, որը կառուցված է Linux միջուկի վրա: Ext2-ը ստեղծվել և մշակվել է Remy Card-ի կողմից: ext2 ֆայլային համակարգը կառուցվել է նրա կողմից՝ փոխարինելու հին, նախորդ տարբերակը՝ ext.

Արագության և կատարողականի առումով այս ֆայլային համակարգը կարող է ծառայել որպես չափանիշ: Այս մասին են վկայում ֆայլային համակարգերի կատարողականի թեստերի արդյունքները։ Օրինակ, Dell Tech Center-ի ընթերցման և գրելու արագության հաջորդական թեստերում ext2-ը գերազանցում է ext3-ին և ընթերցման արագությամբ զիջում է միայն վերջին ext4-ին:

Ext2-ի հիմնական թերությունն այն է, որ այն ամսագրային ֆայլային համակարգ չէ: Այնուամենայնիվ, այս թերությունը վերացվել է հաջորդ ֆայլային համակարգում՝ ext3-ում:

ext2-ն օգտագործվում է ֆլեշ քարտերի և պինդ վիճակի կրիչներում (SSD), քանի որ գրանցման բացակայությունը առավելություն է գրելու ցիկլի սահմանափակումներով կրիչների հետ գործ ունենալիս:

Ext2 պատմություն

Linux համակարգի արագ զարգացման ընթացքում այն ​​օգտագործել է Minix OS ֆայլային համակարգը։ Այն բավականին կայուն էր, բայց միևնույն ժամանակ 16-բիթանոց էր։ Արդյունքում, այն ուներ 64 Մբ կոշտ սահմանաչափ մեկ բաժանման համար: Բացի այդ, կար ֆայլի անվան առավելագույն երկարության սահմանափակում, որը կազմում էր 14 նիշ:

Այս սահմանափակումները միասին հանգեցրին «ընդլայնված ֆայլային համակարգի» զարգացմանը (այստեղից էլ տերմինը « Ընդլայնված ֆայլային համակարգ»): Նրան հանձնարարված էր լուծել Minix-ի երկու հիմնական խնդիր: Նոր ֆայլային համակարգը հրապարակվեց 1992 թվականի ապրիլին։ Դա Ext էր, այն երկարացրեց ֆայլի չափի սահմանաչափը մինչև 2 գիգաբայթ, իսկ ֆայլի անվան երկարության սահմանաչափը սահմանեց 255 նիշ:

Այնուամենայնիվ, չնայած նոր ֆայլային համակարգի հաջողությանը, դեռևս բավականին չլուծված խնդիրներ կային: Օրինակ, բաժանված մուտքի աջակցություն չկար, տվյալների փոփոխման ժամանակային դրոշմակնիքներ չկային: Այս խնդիրների լուծման անհրաժեշտությունը ընդլայնված ext2 ֆայլային համակարգի հաջորդ տարբերակի ստեղծման շարժառիթն էր (« Երկրորդ ընդլայնված ֆայլային համակարգ»): ext2-ը մշակվել է 1993թ. հունվարին և նաև ներդրել է POSIX-ին համապատասխան ACL-ներ և ընդլայնված ֆայլի ատրիբուտներ:

Ext2 տրամաբանական կազմակերպում

Ext2 գրացուցակի հիերարխիայի գրաֆիկը ներկայացված է որպես ցանց: Դա պայմանավորված է նրանով, որ մեկ ֆայլ կարող է ներառվել միանգամից մի քանի գրացուցակներում:

Բոլոր ֆայլերի տեսակներն ունեն խորհրդանշական անուններ: Հիերարխիկորեն կազմակերպված ֆայլային համակարգերը սովորաբար օգտագործում են երեք տեսակի անուններ՝ պարզ, բարդ և հարաբերական: Այսպիսով, այն գտնվում է ext2-ում: Պարզ անվան դեպքում սահմանափակումն այն է, որ դրա երկարությունը չպետք է գերազանցի 255 նիշը, բացի այդ, անունը չպետք է պարունակի NULL նիշ և կտրատել։

Ինչ վերաբերում է NULL նիշին, ապա սահմանափակումները կապված են C լեզվում տողերի ներկայացման հետ, շեղ նիշի դեպքում ամեն ինչ կայանում է նրանում, որ այն օգտագործվում է որպես բաժանարար նիշ դիրեկտորիաների միջև։

Լիովին որակավորված անունը բոլոր գրացուցակների պարզ խորհրդանշական անունների շղթա է, որոնց միջոցով ուղին անցնում է արմատից մինչև այս ֆայլի... Ext2-ում ֆայլը կարող է լինել մի քանի գրացուցակներում, ինչը նշանակում է, որ այն կարող է ունենալ մի քանի լրիվ որակավորված անուններ (մեկ ֆայլ՝ մի քանի լրիվ որակավորված անուններ): Բայց ամեն դեպքում, լրիվ անունը սահմանում է ֆայլը:

Ext2 հատկանիշներ.

• ֆայլի տեսակը և թույլտվությունները,
• սեփականատեր, մուտքի խումբ,
• թույլատրված գործողությունների մասին տեղեկատվություն,
• ստեղծման ժամանակը, վերջին մուտքի ամսաթիվը, վերջին փոփոխության ամսաթիվը և վերջին ջնջման ժամանակը,
• ընթացիկ ֆայլի չափը,
• ֆայլի ճշգրտում.

• սովորական ֆայլ,
• կատալոգ,
• բայթ ուղղված սարքի ֆայլ,
• արգելափակել սարքի ֆայլը,
• անունով խողովակ,
• խորհրդանշական հղում,

• զբաղեցրած բլոկների քանակը,
• մյուսները

Ֆայլի ատրիբուտները պարունակվում են հատուկ աղյուսակներում, այլ ոչ գրացուցակներում, ինչպես սովորաբար լինում է պարզ ֆայլային համակարգերի դեպքում: Արդյունքում գրացուցակը ունի շատ պարզ կառուցվածք, որը բաղկացած է երկու մասից՝ inode համար և անուն:

Ֆիզիկական կազմակերպում ext2

Սկավառակի բաժանման կառուցվածքը

Որպես ext2-ի մաս՝ կարելի է առանձնացնել հետևյալը.

• բլոկներ և բլոկների խմբեր;
• ինոդ;
• սուպերբլոկ:

Սկավառակի ամբողջ տարածքը բաժանված է ֆիքսված չափի բլոկների, որոնք հատվածի չափի բազմապատիկ են (1024, 2048, 4096 կամ 8192 բայթ): Բլոկի չափը նշվում է սկավառակի բաժանման վրա ֆայլային համակարգ ստեղծելիս: Բոլոր բլոկներին հատկացվում են հաջորդական թվեր: Մեծ կարդալիս կոշտ սկավառակի գլխիկների մասնատվածությունը և շարժումների քանակը նվազեցնելու համար տվյալների զանգվածներբլոկները միավորվում են խմբերի մեջ:

Ֆայլային համակարգի հիմնական հայեցակարգը inode-ն է (նաև կոչվում է ինոդ - տեղեկատվական հանգույց): Այն հատուկ կառույց է, որը պարունակում է տեղեկատվություն ֆայլի հատկանիշների և ֆիզիկական գտնվելու վայրի մասին: Ինդեքսային ապակոդավորիչները միավորվում են աղյուսակի մեջ յուրաքանչյուր բլոկային խմբի սկզբում: Սուպերբլոկը ext2 ֆայլային համակարգի հիմնական տարրն է: Այն պարունակում է ընդհանուր տեղեկություններ ֆայլային համակարգի մասին: Սուպերբլոկը գտնվում է հատվածի սկզբից 1024 բայթ: Սուպերբլոկի ամբողջականությունը որոշում է ֆայլային համակարգի առողջությունը: ՕՀ-ն ստեղծում է սուպերբլոկի մի քանի կրկնօրինակներ այն դեպքում, երբ բաժանումը վնասված է: Սուպերբլոկից հետո հաջորդ բլոկում կա գլոբալ նկարագրող աղյուսակ՝ բլոկների խմբերի նկարագրությունը զանգվածի տեսքով։ ընդհանուր տեղեկությունբլոկների բոլոր խմբերի մասին:

Արգելափակման խումբ

ext2 բաժանման բոլոր բլոկները բաժանված են խմբերի: Յուրաքանչյուր խմբի համար ստեղծվում է գլոբալ նկարագրիչ աղյուսակի առանձին գրառում: Այս գրառումը պահպանում է հիմնական պարամետրերը, ինչպիսիք են՝ բլոկի համարը bitmaps-ում և աղյուսակներում, անվճար բլոկների քանակը խմբում, տեղեկատուներ պարունակող ինոդների քանակը:

Արգելափակել bitmapՀամակարգ է, որտեղ յուրաքանչյուր բիթ տեղեկացնում է, թե արդյոք իրեն համապատասխան բլոկը վերագրված է որևէ ֆայլի: Եթե ​​բիթը 1 է, ապա բլոկը զբաղված է: Inode bitmap-ը կատարում է նմանատիպ գործառույթ՝ այն ցույց է տալիս, թե որ inode-ներն են զբաղված, որոնք՝ ոչ: Linux միջուկը փորձում է հավասարաչափ բաշխել գրացուցակների ինոդները խմբերի և ֆայլերի ինոդները տեղափոխել ծնող գրացուցակով խումբ: Ամբողջ մնացած տարածքը, որը երևում է աղյուսակում որպես տվյալ, հատկացվում է ֆայլերի պահպանմանը:

Տվյալների հասցեավորման համակարգ

Տվյալների հասցեավորման համակարգը ֆայլային համակարգի ամենալուրջ և հիմնական բաղադրիչներից մեկն է: Նրա շնորհիվ կա ցանկալի ֆայլսկավառակի բազմաթիվ դատարկ կամ զբաղեցրած բլոկների շարքում:

ext2-ն օգտագործում է հետևյալ ֆայլի բլոկի հասցեավորման սխեման. Ֆայլի հասցեն պահելու համար հատկացվում է 15 դաշտ, որոնցից յուրաքանչյուրը բաղկացած է 4 բայթից։ Եթե ​​ֆայլը տեղավորվում է 12 բլոկների մեջ, ապա համապատասխան կլաստերների համարները նշված են հասցեի առաջին տասներկու դաշտերում։ Եթե ​​ֆայլի չափը գերազանցում է 12 բլոկը, ապա հաջորդ դաշտը պարունակում է այն կլաստերի հասցեն, որում կարող են տեղակայվել ֆայլի հաջորդ բլոկների համարները։ Այսպիսով, տասներեքերորդ դաշտն օգտագործվում է անուղղակի հասցեավորման համար։

Բլոկի առավելագույն չափը 4096 բայթ է, 13-րդ դաշտին համապատասխանող կլաստերը կարող է պարունակել հաջորդ ֆայլի բլոկների մինչև 1024 համար: Եթե ​​ֆայլի չափը գերազանցում է 12 + 1024 բլոկը, ապա օգտագործվում է 14-րդ դաշտը, որը պարունակում է 1024 կլաստերի համար պարունակող կլաստերի հասցեն, որոնցից յուրաքանչյուրը վերաբերում է 1024 ֆայլի բլոկներին։ Այստեղ արդեն օգտագործվում է կրկնակի անուղղակի հասցեավորում։ Իսկ եթե ֆայլը պարունակում է ավելի քան 12 + 1024 + 1048576 բլոկ, ապա կիրառվում է եռակի անուղղակի հասցեավորման վերջին 15-րդ դաշտը։

Հասցեավորման այս համակարգը թույլ է տալիս առավելագույն չափը 4096 բայթ ունենալ 2 ՏԲ-ից մեծ ֆայլեր ունենալու համար:

Եթե ​​ունեք երկու օպերացիոն համակարգ՝ Windows-ը և Linux-ը տեղադրված, ապա, անկասկած, կցանկանայիք պարունակվել անվճար օպերացիոն համակարգի միջնորմների վրա անմիջապես Windows-ից՝ առանց ձեր համակարգիչը վերագործարկելու:

Ցավոք, Windows-ում Linux OS բաժանմունքների աջակցություն չկա: Բայց ապարդյուն։ Ինձ թվում է, որ սա կարող է լավ ժեստ լինել Microsoft-ի կողմից:

Խնդիրի էությունը կայանում է նրանում, որ Windows-ն օգտագործում է NTFS ֆայլային համակարգը, մինչդեռ Linux-ն ունի ֆայլերի կազմակերպման իր ձևը՝ ընդլայնված ֆայլային համակարգը, որի վերջին տարբերակն ունի 4 սերիական համարը։

Linux-ն ավելի հարմար է օգտագործման համար, քան իր առևտրային քույրը. Linux-ը լռելյայն աջակցում է Windows NTFS ֆայլային համակարգին: Իհարկե, դուք չեք կարողանա Linux-ը տեղադրել NTFS բաժանման վրա, բայց դուք կարող եք կարդալ և գրել տվյալներ մեկից:

Ext2 IFS

Ext2 IFS-ն աջակցում է Windows NT4.0 / 2000 / XP / 2003 / Vista / 2008 տարբերակները x86 և x64 և թույլ է տալիս դիտել Linux ext2 բաժանմունքների բովանդակությունը և կարող է նաև գրել դրանց: Կոմունալը տեղադրում է համակարգի դրայվեր ext2fs.sys, որը տարածվում է Windows-ի հնարավորություններըև ներառում է ամբողջական աջակցություն ext2-ի համար. ext2 միջնորմներին տրվում են դրայվային տառեր, և դրանց վրա գտնվող ֆայլերն ու թղթապանակները ցուցադրվում են բոլոր հավելվածների երկխոսություններում, օրինակ՝ Explorer-ում:

Ext2 FSD

Ext2 FSD-ն անվճար վարորդ է Windows համակարգեր(2K / XP / VISTA / 7 տարբերակներ x86 և x64): Ինչպես նախորդ կոմունալ ծրագիրը, որն իր էությամբ նաև վարորդ է, այն ներառում է Windows-ի ext2 ֆայլային համակարգի ամբողջական աջակցություն:

LTOOLS - կոմունալ ծառայությունների մի շարք հրամանի տողորը թույլ է տալիս կարդալ և գրել տվյալներ Linux ext2, ext3 և ReiserFS միջնորմներից (ստանդարտ Linux ֆայլային համակարգեր) DOS-ից կամ Windows-ից:

Կա ծրագրի գրաֆիկական կեղևով տարբերակ (գրված Java-ով)՝ LTOOLSgui, ինչպես նաև գրված գրաֆիկական կեղևով տարբերակ։

Ext2Read

Աղանդերի համար, ինչպես միշտ, ամենահամեղը։

Ext2Read-ը ֆայլերի կառավարչի կոմունալ ծրագիր է, որը թույլ է տալիս դիտել և գրել ext2 / ext3 / ext4 միջնորմները: Աջակցում է LVM2-ին և, ի տարբերություն այս վերանայման այլ ծրագրերի, ext4 ֆայլային համակարգին: Ներկառուցված աջակցություն ռեկուրսիվ գրացուցակի պատճենման համար:

Եվ ահա երկրորդ աղանդերը. Սկզբում ասվում էր, որ Microsoft-ի լավ ժեստ կլիներ Windows-ում Linux-ի բաժանմունքների աջակցությունը լռելյայնորեն միացնելը:

Ժեստը արվել է Linux-ի 20-ամյակի կապակցությամբ: Տեսեք ինքներդ:

Այսքանը: Շնորհակալություն ուշադրության համար. Ես պայքարելու եմ մայիսյան բզեզների դեմ: Այս գարնանը դրանք շատ են: 🙂

ՎԼԱԴԻՄԻՐ ՄԵՇԿՈՎ

Ext2 ֆայլային համակարգի ճարտարապետություն

Այս հոդվածում քննարկվում է ext2-ի տրամաբանական կառուցվածքը՝ Linux օպերացիոն համակարգի ֆայլային համակարգը:

Ext2 ֆայլային համակարգի հիմնական բաղադրիչները

Ինչպես ցանկացած UNIX ֆայլային համակարգի դեպքում, ext2 ֆայլային համակարգը կարելի է բաժանել հետևյալ բաղադրիչների.

• բլոկներ և բլոկների խմբեր;
• տեղեկատվական հանգույց;
• սուպերբլոկ:

Բլոկներ և բլոկ խմբեր

Սկավառակի ամբողջ տարածքը բաժանված է ֆիքսված չափի բլոկների, որոնք բազմապատիկ են հատվածի չափսերից՝ 1024, 2048 և 4096 բայթ: Բլոկի չափը նշվում է կոշտ սկավառակի բաժանման վրա ֆայլային համակարգ ստեղծելիս: Բլոկի փոքր չափը խնայում է կոշտ սկավառակի տարածությունը, բայց նաև սահմանափակում է ֆայլային համակարգի առավելագույն չափը: Բոլոր բլոկները համարակալված են: Մեծ տվյալների զանգվածներ կարդալիս կոշտ սկավառակի գլխիկների մասնատումը և շարժումների քանակը նվազեցնելու համար բլոկները միավորվում են խմբերի:

Տեղեկատվական հանգույց

Ֆայլային համակարգի հիմնական հայեցակարգը տեղեկատվական հանգույցն է կամ inode: Այն հատուկ կառույց է, որը պարունակում է տեղեկատվություն ֆայլի հատկանիշների և ֆիզիկական գտնվելու վայրի մասին: Ֆայլի ատրիբուտներն են նրա տեսակը (սովորական ֆայլ, գրացուցակ և այլն), դրա մուտքի իրավունքը, սեփականատիրոջ ID-ն, չափը, ստեղծման ժամանակը: Ֆիզիկական տեղադրության տեղեկատվությունը բացարձակ բլոկային թվերի հաջորդականություն է, որը պարունակում է ֆայլի տվյալներ:

Սուպերբլոկ

Սուպերբլոկը ext2 ֆայլային համակարգի հիմնական տարրն է: Այն պարունակում է հետևյալ տեղեկատվությունը ֆայլային համակարգի մասին (ցուցակը թերի է).

• ֆայլային համակարգում բլոկների և ինոդների ընդհանուր քանակը.
• ֆայլային համակարգում անվճար բլոկների և ինոդների քանակը.
• ֆայլային համակարգի բլոկի չափը;
• խմբում բլոկների և ինոդների քանակը.
• inode չափը;
• ֆայլային համակարգի նույնացուցիչ;
• առաջին տվյալների բլոկի համարը:

Այսինքն՝ դա սուպերբլոկ պարունակող բլոկի թիվն է։ Այս թիվը միշտ 0 է, եթե ֆայլային համակարգի բլոկի չափը 1024 բայթից մեծ է, և 1, եթե բլոկի չափը 1024 բայթ է:

Ֆայլային համակարգի գործունակությունն ուղղակիորեն կախված է սուպերբլոկի ամբողջականությունից: Օպերացիոն համակարգը ստեղծում է սուպերբլոկի բազմաթիվ կրկնօրինակներ, որպեսզի այն հնարավոր լինի վերականգնել վնասվելու դեպքում: Հիմնական պատճենը գտնվում է օֆսեթով 1024 բայթ այն բաժանման սկզբից, որի վրա ստեղծվել է ֆայլային համակարգը (առաջին 1024 բայթը վերապահված է օպերացիոն համակարգի բեռնիչի համար):

ext2 ֆայլային համակարգի վաղ տարբերակները բլոկների յուրաքանչյուր խմբի սկզբում ստեղծում էին սուպերբլոկի պատճենները: Սա հանգեցրեց սկավառակի տարածության մեծ կորստի, ուստի հետագայում սուպերբլոկների կրկնօրինակների թիվը կրճատվեց, և 0, 1, 3, 5 և 7 բլոկային խմբերը հատկացվեցին դրանք տեղավորելու համար:

Արգելափակել խմբի ձևաչափը

Ext2 ֆայլային համակարգի ընդհանրացված բլոկային դիագրամը ներկայացված է Նկ. մեկ.

Գրեթե բոլոր բլոկային խմբերն ունեն նույն ձևաչափը: Յուրաքանչյուր խումբ, բացի տեղեկատվական բլոկներից, բիթքարտեզի տեսքով պահպանում է բլոկների զբաղվածության և խմբի ինոդի մասին տեղեկատվությունը: Բլոկ 0 խումբը ներառում է նաև սուպերբլոկ և խմբի նկարագրող աղյուսակ, որը մենք կքննարկենք ստորև:

Բլոկի զբաղվածության բիթքարտեզը սովորաբար գտնվում է խմբի առաջին բլոկում: Եթե ​​խմբում կա superblock backup, ապա bitmap-ը գտնվում է խմբի երկրորդ բլոկում։ Bitmap-ի չափը մեկ բլոկ է: Այս քարտի յուրաքանչյուր բիթ ցույց է տալիս բլոկի վիճակը: Եթե ​​բիթը դրված է (1), ապա բլոկը զբաղված է, եթե այն ջնջված է (0), ապա բլոկը ազատ է: Խմբի առաջին բլոկը համապատասխանում է քարտի զրոյական բիթին, երկրորդ բլոկը համապատասխանում է առաջին բիթին և այլն։

Նույն խմբի ինոդները հավաքվում են աղյուսակում: Խմբի ինոդի զբաղվածության բիթքարտեզում յուրաքանչյուր բիթ ներկայացնում է խմբի ինոդի աղյուսակում գտնվող տարրի վիճակը:

Յուրաքանչյուր բլոկ խումբ նկարագրվում է բլոկային խմբի նկարագրիչի միջոցով: Խմբի նկարագրիչը կառույց է, որը պարունակում է տեղեկատվություն բլոկի զբաղվածության բիթքարտեզի, ինոդի զբաղվածության բիթքարտեզի և համապատասխան խմբի ինոդի աղյուսակի հասցեների մասին։ Խմբի բոլոր նկարագրիչները հավաքվում են խմբի նկարագրիչների աղյուսակում, որը պահվում է 0-րդ բլոկի խմբում: Ինչպես գերբլոկի դեպքում, օպերացիոն համակարգը կրկնօրինակում է խմբի նկարագրիչների աղյուսակը:

Ֆայլի ընթերցման ալգորիթմ

Յուրաքանչյուր inode, ինչպես բլոկը, ունի հաջորդական համար, որը եզակի է ֆայլային համակարգում և պարունակում է տեղեկատվություն միայն մեկ ֆայլի մասին: Այսպիսով, ֆայլի բովանդակությանը հասանելիություն ստանալու համար անհրաժեշտ է իմանալ համապատասխան ինոդի հաջորդական համարը:

Ինչպես նշվեց վերևում, ֆայլի ֆիզիկական դիրքի մասին տեղեկատվությունը պարունակվում է inode-ում: Այս տեղեկատվությունը ֆայլի տվյալներ պարունակող 32-բիթանոց բլոկային թվերի հաջորդականություն է (նկ. 1): Առաջին 12 համարները տեղեկատվության ուղղակի բլոկներ են: 13-րդ համարը անուղղակի բլոկի համար է: Այն պարունակում է բլոկի հասցեն, որում պահվում են տեղեկատվական բլոկների հասցեները: Թիվ 14-ը կրկնակի բլոկների թիվ է, համարը 15-ը եռակի բլոկների թիվ է:

Ֆայլի անունը ներառված չէ inode-ում, ֆայլերի անունների և inode հաջորդական թվերի միջև քարտեզագրումն իրականացվում է դիրեկտորիաների միջոցով:

Կատալոգներ

UNIX և POSIX համակարգերի ֆայլերը պահվում են ծառի կառուցվածքով հիերարխիկ ֆայլային համակարգում: Ֆայլային համակարգի արմատը արմատային գրացուցակն է, որը նշված է «/» նշանով: Ֆայլային համակարգի ծառի յուրաքանչյուր միջանկյալ հանգույց գրացուցակ է: Ֆայլային համակարգի ծառի տերևային հանգույցները կամ դատարկ գրացուցակներ են կամ ֆայլեր: Ֆայլի բացարձակ ուղու անունը բաղկացած է բոլոր դիրեկտորիաների անուններից, որոնք տանում են դեպի նշված ֆայլըսկսած արմատային գրացուցակից: Օրինակ, pathname /home/test.file նշանակում է, որ test.file ֆայլը գտնվում է հիմնական գրացուցակում, որն, իր հերթին, գտնվում է «/» արմատային գրացուցակում:

Գրացուցակը, ինչպես ֆայլը, նկարագրվում է օգտագործելով inode: Գրացուցակի բովանդակությունը մուտքերի զանգված է, որոնցից յուրաքանչյուրը պարունակում է տեղեկատվություն ընթացիկ գրացուցակի «ներսում» գտնվող ֆայլի մասին:

Գրացուցակի մուտքն ունի հետևյալ ձևաչափը.

• ֆայլի ինոդի սերիական համարը.
• ռեկորդային երկարությունը բայթերով;
• Ֆայլի անուն;
• ֆայլի անվան երկարությունը.

Ֆայլի inode համարը գտնելը միշտ սկսվում է արմատային գրացուցակից: Օրինակ, արմատային գրացուցակում գտնվող ֆայլի ինոդային համարը ստանալու համար օպերացիոն համակարգը պետք է ստանա արմատային գրացուցակի բովանդակությունը, գտնի այս ֆայլի անունով մուտքագրում և հանի ֆայլի ինոդ համարը այս մուտքից: .

Առաջին մի քանի inode համարները վերապահված են ֆայլային համակարգի կողմից և նշված են վերնագրի ֆայլում.

* Հատուկ ինոդային համարներ

#define EXT2_BAD_INO 1 / * Վատ բլոկներ inode * /

#define EXT2_ROOT_IN 2 / * Root inode * /

#define EXT2_ACL_IDX_IN 3 / * ACL inode * /

#define EXT2_ACL_DATA_INO 4 / * ACL inode * /

#define EXT2_BOOT_LOADER_INO 5 / * Boot loader inode * /

#define EXT2_UNDEL_DIR_INO 6 / * Ջնջել գրացուցակը inode * /

Inode համարը 2 (արմատային inode) վերապահված է արմատային գրացուցակը գրելու համար: Այս ինոդը գտնվում է 0-րդ բլոկային խմբում և զբաղեցնում է երկրորդ տեղը խմբի ինոդային աղյուսակում։ Առաջին չվերապահված ինոդ համարը պահվում է սուպերբլոկում:

Ֆայլի ինոդի հաջորդական համարը որոշելուց հետո միջուկը հաշվարկում է խմբի համարը, որում գտնվում է այս ինոդը և նրա դիրքը խմբի ինոդի աղյուսակում։ Այս inode դիրքից կարդալով՝ օպերացիոն համակարգը ստանում է ամբողջական տեղեկատվություն ֆայլի մասին, ներառյալ այն բլոկների հասցեները, որոնցում պահվում է ֆայլի բովանդակությունը։

Բլոկի խմբի համարը, որում գտնվում է ինոդը, հաշվարկվում է բանաձևով.

խումբ = (inode_num - 1) / inodes_per_group

որտեղ:

• խումբ- բլոկային խմբի անհրաժեշտ թիվը.
• inode_num- ֆայլը սահմանող ինոդի հերթական համարը.
• inodes_per_group- խմբում ինոդների քանակը (այս տեղեկատվությունը սուպերբլոկում է):

Խմբի ինոդի աղյուսակում ինոդի դիրքը որոշվում է բանաձևով.

ինդեքս = (inode_num - 1)% inodes_per_groupe

որտեղ ինդեքսը աղյուսակի ինոդի դիրքն է:

Եկեք նայենք արմատային գրացուցակում գտնվող test.file ֆայլի բովանդակությունը ստանալու օրինակին: Ֆայլը կարդալու համար /test.file:

• գտնել այս ֆայլի մասին գրառում արմատային գրացուցակի մուտքերի զանգվածում.
• հանեք ֆայլի ինոդի հաջորդական համարը, հաշվարկեք այն խմբի թիվը, որում գտնվում է այս ինոդը.
• առբերել խմբի inode աղյուսակի հասցեն այս խմբի նկարագրիչից.
• հաշվարկել այս աղյուսակում inode դիրքը.
• կարդալ ֆայլի ինոդը;
• հանեք տեղեկատվական բլոկների հասցեները ինոդից և կարդացեք այդ բլոկների տեղեկատվությունը:

Նկ. 2-ը մանրամասն ցույց է տալիս /test.file ֆայլի ընթերցման փուլերը:

Քայլեր 1-6 - Արմատային գրացուցակի ընթերցում.

1. Խմբի նկարագրիչի աղյուսակը կարդացվում է 0-րդ խմբից:
2. Բլոկային խմբի 0 նկարագրիչը վերցվում է խմբի նկարագրիչ աղյուսակից և 0 խմբի inode աղյուսակի հասցեն կարդացվում է դրանից:
3. Inode աղյուսակը կարդացվում է բլոկ 0-ից:
4. Արմատային գրացուցակի inode համարը ամրագրված է 2-ի վրա, ուստի երկրորդ տարրը կարդացվում է 0 խմբի inode աղյուսակից, որը պարունակում է արմատային գրացուցակի պարունակություն պարունակող բլոկի հասցեն։ Ենթադրենք այս բլոկը գտնվում է A բլոկ խմբում:
5. Արմատային գրացուցակի գրառումներ պարունակող բլոկը կարդացվում է A բլոկ խմբից:
6. Կատարվում է «test.file» անունով մուտքի որոնում: Նման մուտքագրման դեպքում «test.file» ֆայլի ինոդային համարը վերցվում է դրանից:

Ինոդի համարը որոշվելուց հետո ֆայլի տեղեկատվական բլոկները կարող են մուտք գործել (քայլեր 7-11).

7. Հաշվարկվում է այն խմբի թիվը, որում գտնվում է տվյալ ինոդը և նրա դիրքը խմբի ինոդային աղյուսակում (ենթադրենք, որ խմբի համարը B է, իսկ աղյուսակի դիրքը՝ X)։
8. Խմբի նկարագրիչի աղյուսակից մենք հանում ենք բլոկ խմբի B նկարագրիչը և այնտեղից կարդում ենք այս բլոկային խմբի inode աղյուսակի հասցեն։
9. Ինոդային աղյուսակը կարդացվում է B բլոկ խմբից:
10. X դիրքի ինոդը կարդացվում է B բլոկային խմբի ինոդային աղյուսակից:
11. Բլոկի հասցեները ֆայլի պարունակությամբ /test.file-ը հանվում են կարդացված ինոդից և տեղեկատվությունը կարդացվում է նշված հասցեով բլոկից:

Ֆայլի ընթերցման ալգորիթմի ծրագրային ներդրում

Նախնական տվյալներ. կա կոշտ սկավառակի բաժանում, որի վրա ստեղծվում է ext2 ֆայլային համակարգը: Այս բաժինը համապատասխանում է սարքի ֆայլին / dev / hda3: Բաժանմունքի արմատային գրացուցակում ստեղծվում է տնային ենթացանց, և այն պարունակում է test.file ֆայլը հետևյալ բովանդակությամբ.

Արդյո՞ք ցիտրուսները կապրեն հարավի թավուտներում:

Այո, բայց կեղծ պատճեն!

1234567890-=

Մի վատ մտածեք, սա անհեթեթություն չէ, այլ փորձնական վարժություն նախկին ԽՍՀՄ ազդանշանային զորքերում հեռագրային օպերատորների վերապատրաստման դասընթացից:

Ուշադրություն. Դիտարկենք մեկը կարևոր կետ... Ստեղծված ֆայլը անմիջապես չի գրվի սկավառակի վրա, այլ նախ կգնա սկավառակի բուֆեր: Վերոնշյալ ալգորիթմի միջոցով ֆայլի բովանդակությունը անմիջապես ստանալու փորձը ոչնչի չի հանգեցնի, քանի որ այս ֆայլի մասին տեղեկատվությունը ֆիզիկապես բացակայում է սկավառակի վրա: Դուք պետք է «ստիպեք» համակարգին գրել սկավառակի բուֆերը սկավառակի վրա: Դա անելու ամենահեշտ ձևը վերաբեռնման գործողություն կատարելն է: Հետևաբար, ֆայլը ստեղծելուց հետո վերագործարկեք համակարգը:

Մեր խնդիրն է օգտագործել սարքի ֆայլը / dev / hda3 ֆայլը կարդալու համար /home/test.file՝ ուղղակիորեն մուտք գործելով դրա տեղեկատվական բլոկները:

Դիտարկենք այս գործողությունը կատարող մոդուլի ծրագրային ներդրումը:

Վերնագրի ֆայլեր.

#ներառում

#ներառում

#ներառում

#ներառում

#ներառում

#ներառում

Վերնագրի ֆայլը սահմանում է կառուցվածքային տիպերը, որոնք նկարագրում են ext2 ֆայլային համակարգի հիմնական բաղադրիչները՝ superblock, block խմբի նկարագրիչ, տեղեկատվական հանգույց, գրացուցակի մուտքագրում։

Եկեք համառոտ դիտարկենք այն ոլորտները, որոնք ներառված են այս կառույցներից յուրաքանչյուրում.

1. Superblock կառուցվածքը struct ext2_super_block:
   • __u32 s_inodes_count- ֆայլային համակարգում ինոդների ընդհանուր թիվը.
   • __u32 s_blocks_count- ֆայլային համակարգում բլոկների ընդհանուր քանակը.
   • __u32 s_free_blocks_count- անվճար բլոկների քանակը;
   • __u32 s_free_inodes_count- անվճար ինոդների քանակը;
   • __u32 s_first_data_block- առաջին տվյալների բլոկի համարը (բլոկի համարը, որում գտնվում է սուպերբլոկը);
   • __u32 s_log_block_size- Այս արժեքը օգտագործվում է բլոկի չափը հաշվարկելու համար: Բլոկի չափը որոշվում է բանաձևով՝ բլոկի չափ = 1024<< s_log_block_size;
   • __u32 s_blocks_per_group- խմբում բլոկների քանակը.
   • __u32 s_inodes_per_group- խմբում ինոդների քանակը.
   • __u16 s_magic- ext2 ֆայլային համակարգի նույնացուցիչ (ստորագրություն 0xEF53);
   • __u16 s_inode_size- տեղեկատվական հանգույցի չափը (inode);
   • __u32 s_first_inoԱռաջին չվերապահված ինոդի համարն է:
2. Բլոկների խմբի նկարագրիչի կառուցվածքը ext2_group_desc է.
   • __u32 bg_block_bitmap- խմբի բլոկների զբաղվածության bitmap;
   • __u32 bg_inode_bitmap- inode խմբի զբաղեցման բիթքարտեզ;
   • __u32 bg_inode_table- խմբի inode աղյուսակի հասցեն:
3. Տեղեկատվական հանգույցի կառուցվածքը ext2_inode struct:
   • __u16 i_mode - ֆայլի տեսակը և դրա մուտքի իրավունքը: Ֆայլի տեսակը որոշվում է այս դաշտի 12-15 բիթերով.
     • 0xA000- խորհրդանշական հղում;
     • 0x8000- սովորական ֆայլ;
     • 0x6000- արգելափակել սարքի ֆայլը;
     • 0x4000- գրացուցակ;
     • 0x2000- նիշերի սարքի ֆայլ;
     • 0x1000- FIFO ալիք:
   • __u32 i_size- չափը բայթերով;
   • __u32 i_atime- ֆայլին վերջին մուտքի ժամանակը.
   • __u32 i_ctime- ֆայլի ստեղծման ժամանակը;
   • __u32 i_mtime- վերջին փոփոխության ժամանակը;
   • __u32 i_blocks- ֆայլի զբաղեցրած բլոկների քանակը.
   • __u32 i_block- տեղեկատվական բլոկների հասցեներ (ներառյալ բոլոր անուղղակի հղումները):

EXT2_N_BLOCKS արժեքը սահմանվում է ֆայլում՝

* Տվյալների բլոկների նկատմամբ հաստատուններ

#սահմանել EXT2_NDIR_BLOCKS 12

#սահմանել EXT2_IND_BLOCK EXT2_NDIR_BLOCKS

#define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1)

#define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1)

#define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1)

4. Գրացուցակի մուտքագրման կառուցվածքը ext2_dir_entry_2:

#define EXT2_NAME_LEN 255

• __u32 inode- ֆայլի inode համարը;
• __u16 rec_len- գրացուցակի մուտքի երկարությունը.
• __u8 անուն_լեն- ֆայլի անվան երկարությունը;
• char անունը – Ֆայլի անունը.

Սահմանենք այն բաժնի անվանումը, որի վրա ստեղծվում է ֆայլային համակարգը, գլոբալ կառուցվածքները և փոփոխականները։

#define PART_NAME «/ dev / hda3»

struct ext2_super_block sb;

/ * բուֆեր՝ խմբի նկարագրիչ աղյուսակը պահելու համար * /

անստորագիր char buff_grp;

անստորագիր char buff; / * տեղեկատվական բուֆեր * /

int indev; / * սարքի ֆայլի նկարագրիչ * /

int BLKSIZE; / * ֆայլային համակարգի բլոկի չափը * /

Եկեք սահմանենք մի քանի գործառույթ, որոնք մենք պետք է աշխատենք.

Superblock կարդալու գործառույթ.

void read_sb ()

Memset (& sb, 0.1024);

Մենք բաժանման սկզբից տեղափոխում ենք 1024 բայթ և կարդում ենք գերբլոկը ext2_super_block sb կառուցվածքի մեջ.

Եթե ​​(lseek (indev, 1024,0)< 0) {

Սխալ («lseek»);

Ելք (-1);

Եթե ​​(կարդա (indev, (char *) & sb, sizeof (sb))< 0) {

Սխալ («կարդալ»);

Ելք (-1);

Ֆայլային համակարգի նույնացուցիչի ստուգում.

Եթե ​​(sb.s_magic! = EXT2_SUPER_MAGIC) (

Printf («Անհայտ ֆայլային համակարգի տեսակ»);

Ելք (-1);

EXT2_SUPER_MAGIC արժեքը սահմանվում է վերնագրի ֆայլում:

Մենք ցուցադրում ենք տեղեկատվություն ֆայլային համակարգի մասին, որը գտնվում է սուպերբլոկում.

printf ("Superblock info -----------");

Printf («Inodes count -% u», sb.s_inodes_count);

Printf ("Blocks count -% u", sb.s_blocks_count);

Printf ("Block size -% u", 1024<< sb.s_log_block_size);

Printf («Առաջին inode -% d», sb.s_first_ino);

Printf («Magic - 0x% X», sb.s_magic);

Printf («Inode size -% d», sb.s_inode_size);

Printf («Inodes per group -% u», sb.s_inodes_per_group);

Printf («Blosks per group -% u», sb.s_blocks_per_group);

Printf («Առաջին տվյալների բլոկ -% u», sb.s_first_data_block);

Վերադարձ;

Խմբի նկարագրիչի աղյուսակի ընթերցման գործառույթը.

void read_gdt ()

Մենք հաշվարկում ենք ֆայլային համակարգի բլոկի չափը.

BLKSIZE = 1024<< sb.s_log_block_size

Խմբի նկարագրիչ աղյուսակը գտնվում է տվյալների առաջին բլոկին անմիջապես հաջորդող բլոկում (սուպերբլոկից հետո):

Մենք կարդում ենք աղյուսակը.

Եթե ​​(lseek (indev, (sb.s_first_data_block + 1) * BLKSIZE, 0)< 0) {

Սխալ («lseek»);

Ելք (-1);

Եթե ​​(կարդա (indev, buff_grp, BLKSIZE)< 0) {

Սխալ («կարդալ»);

Ելք (-1);

Վերադարձ;

Ինոդի բովանդակությունը իր թվով ստանալու ֆունկցիա.

void get_inode (int inode_num, struct ext2_inode * in)

Ֆունկցիայի մուտքային պարամետրերն են inode համարը և struct ext2_inode կառուցվածքը։

Struct ext2_group_desc gd;

U64 խումբ, ինդեքս, դիրք;

Մենք հաշվարկում ենք բլոկ խմբի համարը, որը պարունակում է ինոդը inode_num հերթական թվով.

Խումբ = (inode_num - 1) / sb.s_inodes_per_group;

Խմբի նկարագրիչի աղյուսակից հանեք խմբի նկարագրիչ խումբը և պատճենեք այն ext2_group_desc gd կառուցվածքի մեջ.

Memset ((void *) & gd, 0, sizeof (gd));

Memcpy ((void *) & gd, buff_grp + (group * (sizeof (gd))), sizeof (gd));

Մենք հաշվարկում ենք inode-ի դիրքը inode_num հերթական թվով խմբային խմբի inode աղյուսակում և այս ինոդը կարդում ենք ext2_inode կառուցվածքում.

ինդեքս = (inode_num - 1)% sb.s_inodes_per_group;

Pos = ((__u64) gd.bg_inode_table) * BLKSIZE + (ինդեքս * sb.s_inode_size);

Pread64 (indev, in, sb.s_inode_size, pos);

Վերադարձ;

Տվյալների բլոկի ընթերցման գործառույթը.

void read_iblock (struct ext2_inode * in, int blk_num)

U64 pos;

Ֆունկցիայի մուտքային պարամետրերն են ինոդի կառուցվածքը և բլոկի համարը (նշանակում է ինոդում տեղակայված հասցեների բլոկների հաջորդականության թիվը):

Մենք հաշվարկում ենք բաժանման տեղեկատվական բլոկի օֆսեթը և այս բլոկը կարդում ենք գլոբալ բաֆլի մեջ.

Pos = ((__u64) in-> i_block) * BLKSIZE;

Pread64 (indev, buff, BLKSIZE, pos);

Վերադարձ;

Արմատային գրացուցակի բովանդակությունը ստանալու գործառույթ.

void get_root_dentry ()

Struct ext2_inode in;

Արմատային գրացուցակի inode համարը հայտնի է, ուստի մենք ստանում ենք արմատային գրացուցակի inode-ի բովանդակությունը և կարդում դրա բովանդակությունը buff buffer-ում.

get_inode (EXT2_ROOT_INO, & in);

Read_iblock (& ​​in, 0);

Buff բուֆերը կպարունակի արմատային գրացուցակի բովանդակությունը:

Վերադարձ;

Ֆայլի անունով ինոդ համարը ստանալու գործառույթ.

int get_i_num (char * անուն)

Ֆունկցիայի մուտքային պարամետրերն են ֆայլի անվանումը: Վերադարձված արժեքը ֆայլի inode հերթականությունն է:

Int i = 0, rec_len = 0;

Struct ext2_dir_entry_2 dent;

Buff buffer-ը պարունակում է գրացուցակի գրառումների զանգված: Ֆայլի ինոդի սերիական համարը որոշելու համար այս զանգվածում պետք է մուտքագրեք այս ֆայլի անվանումը.

Համար (; i< 700; i++) {

Memcpy ((void *) & dent, (buff + rec_len), sizeof (dent));

Եթե ​​(! Memcmp (dent.name, name, dent.name_len)) կոտրել;

Rec_len + = dent.rec_len;

Վերադարձի dent.inode;

Հիմա եկեք նկարագրենք հիմնական գործառույթը.

int main ()

Փոփոխականներ և կառուցվածքներ.

struct ext2_inode in;

// ֆայլի բացարձակ ուղու անունը

Չստորագրված char * full_path = "/home/test.file";

Չստորագրված char buff1;

Ստատիկ int i = 1;

Int n, i_num, outf, type;

Բացարձակ ուղու անվան առաջին նիշը պետք է լինի առաջ կտրվածք (/): Մենք ստուգում ենք սա.

Եթե ​​(full_path! = "/") (

Սխալ («slash»);

Ելք (-1);

Բացեք սարքի ֆայլը, կարդացեք սուպերբլոկը և խմբի նկարագրիչ աղյուսակը.

Indev = բաց (PART_NAME, O_RDONLY);

Եթե ​​(indev< 0) {

Սխալ («բաց»);

Ելք (-1);

Read_sb ();

Read_gdt ();

Մենք ստանում ենք արմատային գրացուցակի բովանդակությունը.

get_root_dentry ();

Այժմ buff-ը պարունակում է արմատային գրացուցակի բոլոր գրառումները (եթե ցանկանում եք, կարող եք դրանք պահել առանձին ֆայլում): Այժմ, երբ մենք ունենք արմատային գրացուցակի գրառումները, մենք կարող ենք հասնել test.file-ի բովանդակությանը, օգտագործելով վերը նշված ֆայլի ընթերցման ալգորիթմը: Այդ նպատակով մենք ցիկլ ենք կազմակերպելու։ Օղակի մարմնում վերլուծենք ֆայլի բացարձակ ուղու անունը՝ ընդգծելով դրա տարրերը՝ ենթագրքեր (մենք ունենք միայն մեկը՝ տուն) և անհրաժեշտ ֆայլի անվանումը (test.file): Յուրաքանչյուր տարրի համար որոշեք ինոդի հերթական համարը, կարդացեք այս ինոդը և այնուհետև ստացեք զրոյական բլոկի պարունակությունը (ինոդում տեղակայված հասցեների բլոկների հաջորդականությունից).

մինչդեռ (1) (

Memset (buff1,0, sizeof (buff1));

Համար (n = 0; n< EXT2_NAME_LEN; n++, i++) {

Buff1 [n] = լրիվ_ուղի [i];

Եթե ​​((buff1 [n] == «/») || (buff1 [n] == «?»)) (

Ես ++;

Ընդմիջում;

buff1 [n] = "?";

Ֆայլի բացարձակ ուղու անվանման յուրաքանչյուր տարրի համար մենք որոշում ենք ինոդի հաջորդական համարը, կարդում ենք այս ինոդը հիշողության մեջ և այնուհետև ստանում զրոյական բլոկի բովանդակությունը.

I_num = get_i_num (buff1);

Get_inode (i_num, & in);

Read_iblock (& ​​in, 0);

Եկեք ցուցադրենք ֆայլի մասին տեղեկատվությունը (անունը, ինոդի համարը, ֆայլի չափը և դրա տեսակը).

Printf («Inode number -% u», i_num);

Printf («Ֆայլի անուն -% s», buff1);

Printf («Ֆայլի չափը -% u», in.i_size);

Ֆայլի տեսակը որոշվում է ext2_inode struct-ի i_mode դաշտի ամենակարևոր չորս բիթերով.

տեսակ = ((in.i_mode & 0xF000) >> 12);

Printf ("Type -% d", տեսակ);

Անջատիչ (տեսակ) (

Պատյան (0x04):

Printf («(տեղեկատու)»);

Ընդմիջում;

Պատյան (0x08):

Printf («(սովորական ֆայլ)»);

Ընդմիջում;

Պատյան (0x06):

Printf («(արգելափակել սարքի ֆայլը)»);

Ընդմիջում;

Պատյան (0x02):

Printf («(նիշերի սարքի ֆայլ)»);

Ընդմիջում;

Կանխադրված:

Printf («(անհայտ տեսակ)»);

Ընդմիջում;

Ֆայլի տեսակի ստուգում: Եթե ​​սա սովորական ֆայլ է, մենք խախտում ենք հանգույցը.

Եթե ​​(տիպ & 0x08) (

Buff բուֆերը կպարունակի տեղեկատվություն, որը կարդացվում է տեղեկատվական բլոկներից /home/test.file-ում: Եկեք այս տեղեկատվությունը գրենք ֆայլում.

Outf = բաց («դուրս», O_CREAT | O_RDWR, 0600);

Գրել (outf, buff, sizeof (buff));

Փակել (outf);

Ընդմիջում;

Մենք հեռանում ենք:

Փակել (indev);

Վերադարձ 0;

Այս նկատառումով տրամաբանական կառուցվածքը ext2 ֆայլային համակարգը ավարտված է:

(Երկրորդ ընդլայնված ֆայլային համակարգ):

Linux ֆայլային համակարգերի զարգացման պատմությունը

Ext2fs սկավառակի բաժանման կառուցվածքը

·

· Կատալոգներ

· Սարքի ֆայլեր

·

·

EXT2fs գրադարան

· EXT2fs համակարգի հարմարություններ

· Կատարման հաշվարկ

Մատֆակ

Պրոգ.

2-րդ կուրս 5-րդ գր.

Չիչիրով Անդրեյ

Գլխային համակարգ EXT2fs (Երկրորդ ընդլայնված ֆայլային համակարգ):

Linux ֆայլային համակարգերի զարգացման պատմությունը

Linux-ի առաջին տարբերակները մշակվել են Minix օպերացիոն համակարգի հիման վրա։ Ավելի հեշտ կլիներ սկավառակները բաժանել երկու համակարգերի միջև, քան նոր ֆայլային համակարգ մշակելը, ուստի Լինուս Տորվալդսը որոշեց Linux-ի աջակցություն ներդնել Minix ֆայլային համակարգի համար: Այն ժամանակ, այս ֆայլային համակարգը բավականին արդյունավետ ծրագրային արտադրանք էր համեմատաբար փոքր գումարսխալներ.

Այնուամենայնիվ, Minix ֆայլային համակարգի կառուցվածքի հետ կապված սահմանափակումները բավականին մեծ էին, ուստի նրանք սկսեցին մտածել Linux-ի համար նոր ֆայլային համակարգի մշակման մասին։

Linux-ի միջուկում նոր ֆայլային համակարգի ներդրումը պարզեցնելու համար մշակվել է վիրտուալ ֆայլային համակարգ (VFS): VFS-ն ի սկզբանե գրվել է Քրիս Պրովենցանոյի կողմից, այնուհետև վերաշարադրվել է Լինուս Տորվալդսի կողմից՝ նախքան այն ինտեգրելը միջուկում:

VFS միջուկում տեղադրվելուց հետո, 1992 թվականի ապրիլին նոր ֆայլային համակարգ EXTfs (Extended File System) մշակվեց և ավելացվեց Linux 0.96c-ում: Նոր ֆայլային համակարգում հանվել են Minix համակարգի երկու նշանակալի սահմանափակումներ՝ դրա առավելագույն չափը կարող էր հասնել 2 գիգաբայթի, իսկ ֆայլի անվան առավելագույն երկարությունը՝ 255 նիշ։ Սա բարելավում էր Minix ֆայլային համակարգի համեմատ, չնայած որոշ խնդիրներ դեռ առկա էին: Չկար աջակցություն բաժանված մուտքի, inode փոփոխության և ֆայլի փոփոխման ժամանակի բջիջների փոփոխության համար: Այս ֆայլային համակարգը օգտագործում էր կապակցված ցուցակներ՝ ազատ բլոկների և ինոդների վրա գործելու համար, ինչը մեծապես ազդեց համակարգի աշխատանքի վրա. ժամանակի ընթացքում ցուցակները դարձան անկարգություններ և խզված, ինչը հանգեցրեց ֆայլային համակարգի մասնատմանը:

Այս խնդիրների լուծումը 1993 թվականի հունվարին երկու նոր ֆայլային համակարգերի ալֆա տարբերակների թողարկումն էր՝ Xia և EXT2fs (Երկրորդ ընդլայնված ֆայլային համակարգ): Մեծ մասամբ Xia ֆայլային համակարգը հիմնված էր Minix-ի վրա՝ ավելացնելով մի քանի նոր հնարավորություններ: Հիմնականում դա երկար ֆայլերի անուններով աշխատելու ունակությունն էր, ավելի մեծ սկավառակի միջնորմների աջակցությունը և ֆայլի փոփոխման ժամանակի երեք բջիջների աջակցությունը: Մյուս կողմից, EXT2fs-ը հիմնված էր EXTfs-ի վրա՝ բազմաթիվ բարելավումներով և լրացումներով: Նա նաև հնարավորություններ ուներ ապագա զարգացման համար:

Երբ երկու ֆայլային համակարգերը թողարկվեցին, դրանք ֆունկցիոնալ առումով մոտավորապես նույնն էին: Xia համակարգը ավելի հուսալի էր, քան EXT2fs-ը՝ այն նվազագույնի հասցնելու գնով: Նրանց ավելի լայն կիրառման հետ մեկտեղ EXT2fs համակարգում հայտնաբերվել են սխալներ և ավելացվել են մեծ թվով նոր հնարավորություններ և բարելավումներ։ EXT2fs ֆայլային համակարգը այժմ շատ հուսալի է և դարձել է Linux ֆայլային համակարգի դե ֆակտո ստանդարտ:

Հետևյալ աղյուսակը պարունակում է ընդհանուր տեղեկություններ տարբեր ֆայլային համակարգերի կողմից տրամադրվող ֆունկցիոնալության մասին:

	Minix FS	Ext FS	Ext2 FS	Xia FS
Ֆայլային համակարգի առավելագույն չափը
Առավելագույն երկարությունըֆայլ
Ֆայլի անվան առավելագույն երկարությունը
Աջակցություն ֆայլի փոփոխման ժամանակի երեք բջիջների համար
Ընդարձակելիություն
Չափափոխվող բլոկ
Տեղեկատվության պաշտպանություն

Անհրաժեշտության դեպքում, ֆայլի անվան երկարությունը Ext 2կարող է ավելացվել մինչև 1012 թ.

EXT2fs-ը մի շարք բլոկներ է պահում արմատային օգտագործողի համար: Սա սովորաբար ընդհանուրի 5%-ն է, ինչը թույլ է տալիս համակարգի ադմինիստրատորին խուսափել կոշտ սկավառակի տարածքի սպառումից՝ այն լրացնելով այլ օգտվողների գործընթացներով:

Ext2fs սկավառակի բաժանման կառուցվածքը

Արտադրողներ կոշտ սկավառակներսովորաբար առաքում են իրենց արտադրանքը ցածր ձևաչափով: Սա, որքան գիտեմ, նշանակում է, որ սկավառակի ամբողջ տարածքը հատուկ պիտակների օգնությամբ բաժանված է «սեկտորների»՝ 512 բայթ մեծությամբ։ Նման սկավառակը (կամ սկավառակի բաժանումը) պետք է պատրաստվի հատուկ օպերացիոն համակարգում օգտագործելու համար: MS-DOS-ում կամ Windows-ում պատրաստման ընթացակարգը կոչվում է ֆորմատավորում, իսկ Linux-ում՝ ֆայլային համակարգի ստեղծում։ Ֆայլային համակարգի ստեղծում ext2fsսկավառակի բաժանման մեջ որոշակի տրամաբանական կառուցվածք ստեղծելն է: Այս կառույցը կառուցված է հետևյալ կերպ. Նախ, սկավառակի վրա հատկացվում է բեռնման տարածք: Բեռնման տարածքը ստեղծվում է ցանկացած ֆայլային համակարգում: Առաջնային բաժանման վրա այն պարունակում է boot record, կոդի մի հատված, որը մեկնարկում է օպերացիոն համակարգի բեռնման գործընթացը գործարկման պահին: Այս տարածքը չի օգտագործվում այլ բաժիններում: Սկավառակի մնացած բոլոր տարածքները բաժանված են բլոկների: Բլոկի չափը կարող է լինել 1, 2 կամ 4 կիլոբայթ: Բլոկը սկավառակի տարածության հասցեային միավոր է: Ֆայլերը տեղաբաշխված են ամբողջ բլոկներով, ուստի բլոկի չափս ընտրելիս փոխզիջում կա: Բլոկի մեծ չափը սովորաբար նվազեցնում է սկավառակի մուտքերի քանակը ֆայլ կարդալիս կամ գրելիս, բայց դա մեծացնում է վատնված տարածքի համամասնությունը, հատկապես, երբ կան շատ փոքր ֆայլեր:

Բլոկները իրենց տարածքում միավորված են բլոկների խմբերի մեջ: Ֆայլային համակարգի բլոկների խմբերը և խմբի ներսում բլոկները համարակալվում են հաջորդաբար՝ սկսած 1-ից: Սկավառակի առաջին բլոկը համարակալված է 1-ով և պատկանում է 1-ին համարով խմբին: Սկավառակի բլոկների ընդհանուր թիվը (սկավառակի բաժանման մեջ) հատվածներով արտահայտված սկավառակի չափի բաժանարար է: Իսկ բլոկային խմբերի թիվը չի պահանջվում բլոկների թիվը բաժանելու համար, քանի որ բլոկների վերջին խումբը կարող է ամբողջական չլինել։ Բլոկների յուրաքանչյուր խմբի սկիզբն ունի հասցե, որը կարելի է ստանալ որպես ((խմբի համարը - 1) * (խմբի բլոկների թիվը)):

Բլոկների յուրաքանչյուր խումբ ունի նույն կառուցվածքը: Դրա կառուցվածքը ներկայացված է հետևյալ աղյուսակում:

Սկավառակի բաժանման բլոկների խմբի կառուցվածքը ext2fs

Այս կառուցվածքի առաջին տարրը (սուպերբլոկը) նույնն է բոլոր խմբերի համար, իսկ մնացած բոլորը անհատական ​​են յուրաքանչյուր խմբի համար։ Սուպերբլոկը պահվում է յուրաքանչյուր բլոկ խմբի առաջին բլոկում (բացառությամբ 1-ին խմբի, որը պարունակում է առաջին բլոկի բեռնման գրառումը): Սուպերբլոկֆայլային համակարգի մեկնարկային կետն է: Այն ունի 1024 բայթ չափ և միշտ գտնվում է օֆսեթում 1024 բայթ ֆայլային համակարգի սկզբից... Սուպերբլոկի բազմաթիվ պատճենների առկայությունը պայմանավորված է ֆայլային համակարգի այս տարրի ծայրահեղ կարևորությամբ: Կրկնվող սուպերբլոկները օգտագործվում են ֆայլային համակարգի վթարի վերականգնման համար:

Սուպերբլոկում պահվող տեղեկատվությունը օգտագործվում է սկավառակի մնացած տվյալների հասանելիությունը կազմակերպելու համար: Սուպերբլոկը որոշում է ֆայլային համակարգի չափը, բաժանման ֆայլերի առավելագույն քանակը, ազատ տարածության քանակը և պարունակում է տեղեկատվություն այն մասին, թե որտեղ պետք է փնտրել չբաշխված տարածքները: Երբ ՕՀ-ն գործարկվում է, սուպերբլոկը կարդացվում է հիշողության մեջ և ֆայլային համակարգի բոլոր փոփոխությունները նախ արտացոլվում են օպերացիոն համակարգի սուպերբլոկի պատճենում և միայն պարբերաբար գրվում սկավառակի վրա: Սա բարելավում է համակարգի աշխատանքը, քանի որ շատ օգտվողներ և գործընթացներ անընդհատ թարմացնում են ֆայլերը: Մյուս կողմից, համակարգը անջատելիս սուպերբլոկը պետք է գրվի սկավառակի վրա, ինչը թույլ չի տալիս անջատել համակարգիչը՝ ուղղակի հոսանքազրկելով։ Հակառակ դեպքում հաջորդ բեռնման ժամանակ սուպերբլոկում գրված տեղեկատվությունը չի համապատասխանի ֆայլային համակարգի իրական վիճակին։

Սուպերբլոկն ունի հետևյալ կառուցվածքը

Դաշտի անվանումը	Մի տեսակ	Մեկնաբանություն
s_inodes_count	ՈՒԼՈՆԳ	Ֆայլային համակարգում ինոդների քանակը
s_blocks_count	ՈՒԼՈՆԳ	Ֆայլային համակարգում բլոկների քանակը
s_r_blocks_count	ՈՒԼՈՆԳ	Գերօգտագործողի համար վերապահված բլոկների քանակը
s_free_blocks_count	ՈՒԼՈՆԳ	Անվճար բլոկների հաշվիչ
s_free_inodes_count	ՈՒԼՈՆԳ	Անվճար inode հաշվիչ
s_first_data_block	ՈՒԼՈՆԳ	Առաջին բլոկը, որը պարունակում է տվյալներ: Կախված բլոկի չափից, այս դաշտը կարող է լինել 0 կամ 1:
s_log_block_size	ՈՒԼՈՆԳ	Տրամաբանական բլոկի չափի ցուցիչ՝ 0 = 1 ԿԲ; 1 = 2 ԿԲ; 2 = 4 Կբ.
s_log_frag_size	ԵՐԿԱՐ	Հատվածի չափի ցուցիչ (կարծես թե հատված հասկացությունը ներկայումս չի օգտագործվում)
s_blocks_per_group	ՈՒԼՈՆԳ	Բլոկների քանակը յուրաքանչյուր բլոկային խմբում
s_frags_per_group	ՈՒԼՈՆԳ	Բլոկների յուրաքանչյուր խմբի բեկորների քանակը
s_inodes_per_group	ՈՒԼՈՆԳ	Յուրաքանչյուր բլոկային խմբում ինոդների քանակը
s_mtime	ՈՒԼՈՆԳ	Ժամանակը, երբ ֆայլային համակարգը վերջին անգամ տեղադրվել է:
s_wtime	ՈՒԼՈՆԳ	Ժամանակը, երբ ֆայլային համակարգը վերջին անգամ գրվել է
s_mnt_count	ՈՒՇՈՐՏ	Ֆայլային համակարգի վրա ամրացումների քանակի հաշվարկ: Եթե ​​այս հաշվիչը հասնում է հաջորդ դաշտում նշված արժեքին (s_max_mnt_count), ապա ֆայլային համակարգը պետք է ստուգվի (դա արվում է վերագործարկման ժամանակ) և հաշվիչը զրոյականացվում է:
s_max_mnt_count	ԿԱՐՃ	Թիվ, որը ցույց է տալիս, թե քանի անգամ կարող է տեղադրվել ֆայլային համակարգը
s_magic	ՈՒՇՈՐՏ	Կախարդական համարը (0xEF53), որը ցույց է տալիս, որ ֆայլային համակարգը ex2fs տեսակի է
s_state	ՈՒՇՈՐՏ	Դրոշներ, որոնք ցույց են տալիս ֆայլային համակարգի ներկայիս վիճակը (արդյոք այն մաքուր է և այլն)
s_errors	ՈՒՇՈՐՏ	Դրոշներ, որոնք նշում են սխալ հաղորդագրությունների հետ աշխատելու ընթացակարգերը (ինչ անել, եթե սխալներ հայտնաբերվեն):
s_pad	ՈՒՇՈՐՏ	Լցնում
s_lastcheck	ՈՒԼՈՆԳ	Ֆայլային համակարգի վերջին ստուգման ժամանակը
s_checkinterval	ՈՒԼՈՆԳ	Ֆայլային համակարգի ստուգումների միջև առավելագույն ժամանակահատված
s_creator_os	ՈՒԼՈՆԳ	ՕՀ-ի տեսակի նշում, որում ստեղծվել է ֆայլային համակարգը
s_rev_level	ՈՒԼՈՆԳ	Ֆայլային համակարգի վերանայման մակարդակը:
s_վերապահված	ՈՒԼՈՆԳ	Լիցքավորում մինչև 1024 բայթ

Սուպերբլոկին հաջորդում են Խմբի նկարագրիչները: Այս նկարագրությունը զանգված է հետևյալ կառուցվածքով.

Դաշտի անվանումը	Մի տեսակ	Նշանակում
bg_block_bitmap	ՈՒԼՈՆԳ	Բլոկի հասցեն, որը պարունակում է տվյալ խմբի բլոկի բիթքարտեզը
bg_inode_bitmap	ՈՒԼՈՆԳ	Այս խմբի համար inode bitmap պարունակող բլոկի հասցեն
bg_inode_table	ՈՒԼՈՆԳ	Տվյալ խմբի ինոդային աղյուսակը պարունակող բլոկի հասցեն
bg_free_blocks_count	ՈՒՇՈՐՏ	Այս խմբում անվճար բլոկների քանակի հաշվիչը
bg_free_inodes_count	ՈՒՇՈՐՏ	Այս խմբում անվճար ինոդների քանակը
bg_used_dirs_count	ՈՒՇՈՐՏ	Այս խմբի ինոդների քանակը, որոնք դիրեկտորիաներ են
bg_pad	ՈՒՇՈՐՏ	Լցնում
bg_reserved	ՈՒԼՈՆԳ	Լցնում

Բլոկների խմբի նկարագրության չափը կարող է հաշվարկվել որպես (block_group_size_in_ext2 * number_groups) / block_size(անհրաժեշտության դեպքում կլորացրեք):

Խմբի նկարագրության մեջ պահվող տեղեկատվությունը օգտագործվում է բլոկի և ինոդի բիթքարտեզները և inode աղյուսակը գտնելու համար: Հիշեք, որ բլոկները և բլոկների խմբերը համարակալված են 1-ից սկսած:

Բլոկի bitmap-ը կառուցվածք է, որի յուրաքանչյուր բիթ ցույց է տալիս, արդյոք համապատասխան բլոկը վերագրված է ֆայլին: Եթե ​​բիթը 1 է, ապա բլոկը զբաղված է: Այս քարտեզը օգտագործվում է ազատ բլոկների որոնման համար այն դեպքերում, երբ անհրաժեշտ է տարածք հատկացնել ֆայլի համար: Բլոկների բիթքարտեզը զբաղեցնում է մի շարք բլոկներ, որոնք հավասար են (number_blocks_in_group / 8) / block_size(անհրաժեշտության դեպքում կլորացրեք):

Inode bitmap-ը կատարում է նույն գործառույթը, ինչ inode աղյուսակը. այն ցույց է տալիս, թե որ նկարագրիչներն են օգտագործվում:

Բլոկխմբի կառուցվածքի հաջորդ տարածքը օգտագործվում է ֆայլի inode աղյուսակը պահելու համար: Ինոդի կառուցվածքն ավելի մանրամասն կքննարկվի հաջորդ ենթաբաժնում:

Վերջապես, բլոկի խմբում մնացած ամբողջ տարածքը հատկացվում է փաստացի ֆայլերը պահելու համար:

Ֆայլային համակարգԱրտաք 2-ը բնութագրվում է.

• հիերարխիկ կառուցվածքը,
• տվյալների զանգվածների հետևողական մշակում,
• դինամիկ ֆայլի ընդլայնում,
• ֆայլերում տեղեկատվության պաշտպանություն,
• ծայրամասային սարքերը (օրինակ՝ տերմինալները և ժապավենային սարքերը) որպես ֆայլեր:

Ֆայլերի ներքին ներկայացում

Ext 2-ի յուրաքանչյուր ֆայլ ունի յուրահատուկ ինդեքս: Ցուցանիշը պարունակում է այն տեղեկատվությունը, որն անհրաժեշտ է ցանկացած գործընթացի՝ ֆայլ մուտք գործելու համար: Գործընթացում է ֆայլեր մուտք գործելու միջոցով՝ օգտագործելով հստակ սահմանված համակարգային զանգեր և նույնականացնելով ֆայլը մի շարք նիշերի հետ, որոնք գործում են որպես տարբերվող ֆայլի անվանում: Յուրաքանչյուր նշանավոր անուն եզակիորեն նույնականացնում է ֆայլը, այնպես որ միջուկը այդ անունը թարգմանում է ֆայլի ինդեքսով: Ցուցանիշը ներառում է հասցեների աղյուսակ՝ ֆայլի տեղեկատվության գտնվելու վայրը սկավառակի վրա: Քանի որ սկավառակի վրա գտնվող յուրաքանչյուր բլոկ հասցեագրված է իր համարով, այս աղյուսակը պահում է սկավառակի բլոկի համարների հավաքածու: Ճկունության համար միջուկը ֆայլին միաժամանակ կցում է կտորներ՝ թույլ տալով ֆայլի տեղեկատվությունը ցրվել ֆայլային համակարգով մեկ: Բայց այս դասավորությունը բարդացնում է տվյալներ գտնելու խնդիրը: Հասցեների աղյուսակը պարունակում է ֆայլին պատկանող տեղեկատվություն պարունակող բլոկի համարների ցանկ, սակայն պարզ հաշվարկները ցույց են տալիս, որ ինդեքսում ֆայլերի բլոկների գծային ցանկը դժվար է կառավարել: Որպեսզի փոքր ինդեքսի կառուցվածքը թույլ տա աշխատել մեծ ֆայլերի հետ, սկավառակի բլոկի հասցեների աղյուսակը հավասարեցվում է Նկար 1-ում ներկայացված կառուցվածքին:

Ext 2-ի ֆայլերի մեծամասնությունը 10 ԿԲ-ից և նույնիսկ 1 ԿԲ-ից չի գերազանցում: Քանի որ ֆայլի 10 ԿԲ-ը գտնվում է ուղիղ հասցեների բլոկներում, ֆայլերում պահվող տվյալների մեծ մասը հասանելի է մեկ սկավառակի միջոցով: Հետևաբար, ի տարբերություն մեծ ֆայլեր մուտք գործելու, ստանդարտ չափսի ֆայլերի հետ աշխատելն արագ է:

Ֆայլի ինոդներ

Սկավառակի յուրաքանչյուր ֆայլ համապատասխանում է մեկ և միայն մեկ ֆայլի ինոդին, որը նույնականացվում է իր հաջորդական համարով՝ ֆայլի ինդեքսով: Սա նշանակում է, որ ֆայլերի թիվը, որոնք կարող են ստեղծվել ֆայլային համակարգում, սահմանափակվում է ինոդների քանակով, որը կա՛մ հստակորեն նշված է ֆայլային համակարգի ստեղծման ժամանակ, կա՛մ հաշվարկվում է սկավառակի բաժանման ֆիզիկական չափի հիման վրա: Ինոդները սկավառակի վրա գոյություն ունեն ստատիկ ձևով, և միջուկը դրանք կարդում է հիշողության մեջ՝ նախքան դրանց հետ աշխատելը:

Ֆայլի inode-ն ունի հետևյալ կառուցվածքը.

Դաշտի անվանումը	Մի տեսակ	Նկարագրություն
I_mode	ՈՒՇՈՐՏ	Այս ֆայլի տեսակը և մուտքի իրավունքները:
I_uid	ՈՒՇՈՐՏ	Սեփականատիրոջ Uid.
I_size	ՈՒԼՈՆԳ	Ֆայլի չափը բայթերով:
I_atime	ՈՒԼՈՆԳ	Ֆայլին վերջին մուտքի ժամանակը (Մուտքի ժամանակ):
I_ctime	ՈՒԼՈՆԳ	Ֆայլի ստեղծման ժամանակը:
I_mtime	ՈՒԼՈՆԳ	Ֆայլի վերջին փոփոխության ժամանակը:
I_dtime	ՈՒԼՈՆԳ	Ֆայլի ջնջման ժամանակը:
I_gid	ՈՒՇՈՐՏ	Խմբի նույնացուցիչ (GID):
I_links_count	ՈՒՇՈՐՏ	Հղումները հաշվում են:
I_blocks	ՈՒԼՈՆԳ	Ֆայլի զբաղեցրած բլոկների քանակը:
I_flags	ՈՒԼՈՆԳ	Ֆայլի դրոշներ (Ֆայլի դրոշներ)
I_Reserved1	ՈՒԼՈՆԳ	Վերապահված է ՕՀ-ի համար
I_block	ՈՒԼՈՆԳ	Ցուցիչներ դեպի այն բլոկները, որոնցում գրված են ֆայլի տվյալները (ուղղակի և անուղղակի հասցեավորման օրինակ Նկար 1-ում)
I_տարբերակ	ՈՒԼՈՆԳ	Ֆայլի տարբերակը (NFS-ի համար)
I_file_acl	ՈՒԼՈՆԳ	ACL ֆայլ
I_dir_acl	ՈՒԼՈՆԳ	տեղեկատու ACL
I_faddr	ՈՒԼՈՆԳ	Հատվածի հասցե
I_frag	ՈւՉԱՐ	Հատվածի համարը
I_fsize	ՈւՉԱՐ	Բեկորի չափը
I_pad1	ՈՒՇՈՐՏ	Լցնում
I_Reserved2	ՈՒԼՈՆԳ	Վերապահված է

Ֆայլի տեսակը և թույլտվությունների դաշտը երկու բայթանոց բառ է, որի յուրաքանչյուր բիթը ծառայում է որպես դրոշակ, որը ցույց է տալիս ֆայլի կապը որոշակի տեսակի հետ կամ սահմանում է մեկ ֆայլի հատուկ թույլտվություններ:

Նույնացուցիչ	Իմաստը	Դրոշի (դաշտի) նպատակը
S_IFMT	F000	Ֆայլի տիպի դիմակ
S_IFSOCK	A000	Դոմենի վարդակից
S_IFLNK	C000
S_IFREG	8000	Սովորական ֆայլ
S_IFBLK	6000	Բլոկի վրա հիմնված սարք
S_IFDIR	4000	Կատալոգ
S_IFCHR	2000	Բայթ ուղղված (նիշերի) սարք
S_IFIFO	1000	Անվանված խողովակ (fifo)
S_ISUID	0800	SUID - փոխել սեփականատիրոջ բիթը
S_ISGID	0400	SGID - խմբի փոփոխության բիթ
S_ISVTX	0200	Կպչուն բիթ
S_IRWXU	01C0	Ֆայլի սեփականատիրոջ իրավունքների դիմակ
S_IRUSR	0100	Կարդալու իրավունք
S_IWUSR	0080	Գրելու իրավունք
S_IXUSR	0040	Կատարելու իրավունք
S_IRWXG	0038	Խմբի իրավունքների դիմակ
S_IRGRP	0020	Կարդալու իրավունք
S_IWGRP	0010	Գրելու իրավունք
S_IXGRP	0008	Կատարելու իրավունք
S_IRWXO	0007	Այլ օգտվողների իրավունքների դիմակ
S_IROTH	0004	Կարդալու իրավունք
S_IWOTH	0002	Գրելու իրավունք
S_IXOTH	0001	Կատարելու իրավունք

Ինոդների շարքում կան մի քանիսը, որոնք վերապահված են հատուկ նպատակների համար և հատուկ դեր են խաղում ֆայլային համակարգում։ Սրանք հետևյալ բնութագրիչներն են

Նույնացուցիչ	Իմաստը	Նկարագրություն
EXT2_BAD_INO		Inode, որը թվարկում է սկավառակի վատ բլոկների հասցեները (Bad blocks inode)
EXT2_ROOT_INO		Արմատային ինոդ
EXT2_ACL_IDX_INO		ACL ինոդ
EXT2_ACL_DATA_INO		ACL ինոդ
EXT2_BOOT_LOADER_INO		Boot loader inode
EXT2_UNDEL_DIR_INO		Ջնջել inode գրացուցակը
EXT2_FIRST_INO		Առաջին անվերապահ ինոդ

Այս ցանկի ամենակարևոր նկարագրիչը արմատային գրացուցակի նկարագրիչն է: Այս նկարագրիչը մատնանշում է արմատային գրացուցակը, որը, ինչպես բոլոր գրացուցակները, բաղկացած է հետևյալ կառուցվածքով գրառումներից.

Դաշտի անվանումը	Մի տեսակ	Նկարագրություն
Ինոդ	ՈՒԼՈՆԳ	ֆայլի ինոդային համարը (ինդեքսը):
rec_len	ՈՒՇՈՐՏ	Այս մուտքի երկարությունը
անունը_լեն	ՈՒՇՈՐՏ	Ֆայլի անվան երկարությունը
Անուն	ՉԱՐ	Ֆայլի անունը

Գրացուցակի մեկ գրառումը չի կարող հատել բլոկի սահմանը (այսինքն, այն պետք է ամբողջությամբ տեղակայված լինի մեկ բլոկի ներսում): Հետևաբար, եթե հաջորդ գրառումն ամբողջությամբ չի տեղավորվում այս բլոկում, այն տեղափոխվում է հաջորդ բլոկ, և նախորդ գրառումը շարունակվում է այնպես, որ այն լրացնում է բլոկը մինչև վերջ։

Նկար 1 Ուղղակի և անուղղակի հասցեների բլոկները ինդեքսում

Նկար 2 Ֆայլի չափը բայթերով՝ 1 ԿԲ բլոկի չափով

Նկար 3. Սկավառակի նմուշի ինդեքս

Նկար 3-ը ցույց է տալիս ֆայլի սկավառակի ինդեքսը: Այս ինդեքսը պատկանում է սովորական ֆայլին, որը պատկանում է «mjb»-ին և որի չափը 6030 բայթ է։ Համակարգը թույլ է տալիս «mjb» օգտվողին կարդալ, գրել և կատարել ֆայլը; «os» խմբի անդամներին և բոլոր մյուս օգտատերերին թույլատրվում է միայն կարդալ կամ կատարել ֆայլը, բայց ոչ տվյալներ գրել դրան: Ֆայլը վերջին անգամ կարդացվել է 1984 թվականի հոկտեմբերի 23-ին, ժամը 13:45-ին, իսկ վերջին անգամ գրանցվել է 1984 թվականի հոկտեմբերի 22-ին, ժամը 10:30-ին: Ինդեքսը վերջին անգամ փոփոխվել է 1984 թվականի հոկտեմբերի 23-ին, ժամը 13:30-ին, թեև այդ պահին ֆայլում որևէ տեղեկություն չի գրվել: Միջուկը կոդավորում է ինդեքսի բոլոր վերը նշված տվյալները: Ուշադրություն դարձրեք ինդեքսի բովանդակության և ֆայլի բովանդակության սկավառակի վրա գրավոր տարբերությանը: Ֆայլի բովանդակությունը փոխվում է միայն այն ժամանակ, երբ ֆայլը գրված է: Ինդեքսի բովանդակությունը փոխվում է ինչպես ֆայլի բովանդակության փոփոխության ժամանակ, այնպես էլ երբ փոխվում են ֆայլի սեփականատերը, մուտքի իրավունքները և ցուցիչի հավաքածուն: Ֆայլի բովանդակությունը փոխելու դեպքում ինդեքսն ինքնաբերաբար կշտկվի, սակայն ինդեքսը թարմացնելը չի ​​նշանակում, որ ֆայլի բովանդակությունը փոխվել է:

Կատալոգներ

Գրացուցակները այն ֆայլերն են, որոնցից կառուցված է ֆայլային համակարգի հիերարխիկ կառուցվածքը. նրանք կարևոր դեր են խաղում ֆայլի անունը ինդեքսի համարի վերածելու գործում: Գրացուցակը ֆայլ է, որի բովանդակությունը մուտքերի մի շարք է, որը բաղկացած է ինդեքսի համարից և գրացուցակում ներառված ֆայլի անունից: Բաղադրյալ անունը դատարկ նիշերի տող է, որը բաժանված է առաջ կտրվածքով («/») մի քանի բաղադրիչների: Յուրաքանչյուր բաղադրիչ, բացի վերջինից, պետք է լինի գրացուցակի անուն, բայց վերջին բաղադրիչը կարող է լինել ոչ գրացուցակի ֆայլի անուն: UNIX-ի V տարբերակը սահմանափակված է 14 նիշով յուրաքանչյուր բաղադրիչի համար; Այսպիսով, ինդեքսի համարին հատկացված 2 բայթերի հետ միասին գրացուցակի մուտքի չափը 16 բայթ է:

Օֆսեթ բայթերով գրացուցակի ներսում	Ինդեքսային համարը (2 բայթ)	Անունֆայլ
	1798	սկզբում
	1276	fsck
		կլրի
	1268	motd
	1799	լեռը
		mknod
	2114	passwd
	1717	գումար
	1851	ստուգաթերթ
		fsdbld
		կազմաձևում
	1432	getty
		վթար
		mkfs

Նկար 4 / etc գրացուցակի ձևաչափը

Նկար 4-ը ցույց է տալիս «etc» գրացուցակի ձևաչափը: Յուրաքանչյուր գրացուցակ պարունակում է ֆայլեր, որոնց անունները նշված են մի կետով և երկու կետերով ("." և ".."), և որոնց ցուցիչի համարները համընկնում են համապատասխանաբար այս գրացուցակի և մայր գրացուցակի ինդեքսների համարներին: Ֆայլի ինդեքսի համարը "." գրացուցակում «/ etc» ունի հասցե 0 օֆսեթով և 83 արժեք: «..» ֆայլի ինդեքսի համարը գրացուցակի սկզբից ունի օֆսեթ 16 հասցե և 2 արժեք: Գրացուցակի գրառումները կարող են լինի դատարկ, իսկ ինդեքսի համարը լինի 0: Օրինակ, «/ etc» գրացուցակի 224 մուտքը դատարկ է, թեև այն ժամանակին պարունակում էր «crash» անունով ֆայլի մուտքի կետ: mkfs ծրագիրը սկզբնավորում է ֆայլային համակարգը այնպես, որ ֆայլերի ինդեքսի համարները լինեն «»: և «..»-ը արմատային գրացուցակում նույնն են, ինչ ֆայլային համակարգի արմատային ինդեքսի համարը:

Միջուկը պահում է տվյալները գրացուցակում, ինչպես դա անում է սովորական ֆայլում՝ օգտագործելով ինդեքսային կառուցվածք և արգելափակումներ՝ առաջ և անուղղակի հասցեների մակարդակներով: Գործընթացները կարող են կարդալ դիրեկտորիաների տվյալները այնպես, ինչպես կարդում են սովորական ֆայլերը, սակայն միջուկը տրամադրում է գրացուցակում գրելու բացառիկ մուտք՝ համոզվելու համար, որ գրացուցակի կառուցվածքը ճիշտ է: Գրացուցակի մուտքի իրավունքներն ունեն հետևյալ նշանակությունը. կարդալ իրավունքը գործընթացներին տալիս է գրացուցակից տվյալները կարդալու հնարավորություն; Գրելու թույլտվությունը գործընթացին թույլ է տալիս ստեղծել նոր գրառումներ գրացուցակում կամ ջնջել հինները (օգտագործելով համակարգի գործողությունները creat, mknod, link և unlink), ինչի արդյունքում գրացուցակի բովանդակությունը փոխվում է. execute թույլտվությունը թույլ է տալիս գործընթացին որոնել գրացուցակը ըստ ֆայլի անունով (քանի որ գրացուցակը «գործարկելը» իմաստ չունի):

Երբ գործընթացն օգտագործում է ֆայլի ուղի, միջուկը տեղեկագրքերում փնտրում է համապատասխան inode համարը: Այն բանից հետո, երբ ֆայլի անունը փոխարկվում է անոդային համարի, այդ նկարագրիչը տեղադրվում է հիշողության մեջ և այնուհետև օգտագործվում է հետագա հարցումներում:

Unix ֆայլային համակարգերի հայեցակարգը ներառում է կապի հասկացությունը: Մեկ inode-ը կարող է կապված լինել բազմաթիվ ֆայլերի անունների հետ: Նկարագրիչը պարունակում է դաշտ, որը պարունակում է այն համարը, որի հետ կապված է ֆայլը: Հղում ավելացնելը ներառում է գրացուցակի մուտքի ստեղծում, որտեղ ինոդի թիվը մատնանշում է մեկ այլ նկարագրիչ, և ավելացնում է հղումների քանակը նկարագրիչում: Հղումը հեռացնելիս միջուկը նվազեցնում է հղումների քանակը և հեռացնում նկարագրիչը, եթե այս հաշվիչը դառնում է զրո:

Նման հղումները կոչվում են կոշտ հղումներ և կարող են օգտագործվել միայն մեկ ֆայլային համակարգում (դուք չեք կարող ստեղծել ֆայլի հղում մեկ այլ ֆայլային համակարգից): Ավելին, կոշտ հղումը կարող է մատնանշել միայն ֆայլը (գրացուցակի կոշտ հղումը կարող է հանգեցնել ֆայլային համակարգում հանգույցի):

Unix համակարգերի մեծ մասում կա կապի մեկ այլ տեսակ: Այս հղումները, որոնք պարունակում են միայն ֆայլի անվանումը, կոչվում են խորհրդանշական հղումներ։ Միջուկի կողմից նման հղումները մշակելիս, ֆայլի ուղին ինոդի վերածելիս, միջուկը հղման անունը փոխարինում է նկարագրիչի բովանդակությամբ (այսինքն՝ նպատակակետ ֆայլի անվանումը) և վերաիմաստավորում է դեպի ֆայլ տանող ուղին: Քանի որ խորհրդանշական հղումը չի մատնանշում ինոդին, հնարավոր է ստեղծել հղումներ դեպի այլ ֆայլային համակարգում տեղակայված ֆայլեր: Այս հղումները կարող են մատնանշել ցանկացած տեսակի ֆայլ, նույնիսկ գոյություն չունեցող: Խորհրդանշական հղումները լայնորեն կիրառվում են, քանի որ դրանք չունեն նույն սահմանափակումները, ինչ կոշտ հղումները: Այնուամենայնիվ, նրանք որոշակի տեղ են զբաղեցնում սկավառակի վրա, որտեղ գտնվում են inode և տվյալների բլոկները: Դրանց օգտագործումը կարող է հանգեցնել ֆայլի ուղու ինոդի փոխակերպման որոշակի ուշացումների, ինչը պայմանավորված է նրանով, որ խորհրդանշական հղումը մշակելիս միջուկը պետք է վերաիմաստավորի ֆայլի ուղին։

Սարքի ֆայլեր

Unix-ի նման օպերացիոն համակարգերսարքերի մուտքն իրականացվում է հատուկ ֆայլերի միջոցով: Նման ֆայլը ֆայլային համակարգում տեղ չի զբաղեցնում: Դա միայն սարքի վարորդին հասանելիության կետն է:

Սարքի ֆայլերի երկու տեսակ կա՝ նիշ և բլոկ: Նիշերի տեսակն օգտագործելիս սարքի հետ տվյալների փոխանակումը հնարավոր է միայն նիշերի ռեժիմում, մինչդեռ բլոկի տիպի սարքի ֆայլերը թույլ են տալիս փոխանակել միայն բլոկները՝ օգտագործելով բուֆերը: Երբ սարքի ֆայլի համար I/O հարցում է արվում, այդ հարցումը վերահղվում է համապատասխան սարքի վարորդին: Յուրաքանչյուր նման ֆայլ համապատասխանում է հիմնական թվին, որը նույնականացնում է սարքի տեսակը, և փոքր թվին, որը նույնականացնում է հենց սարքը:

EXT2fs-ի լրացուցիչ հնարավորություններ

Ի լրումն ստանդարտ Unix հատկանիշների, EXT2fs-ը տրամադրում է որոշ լրացուցիչ հնարավորություններ, որոնք սովորաբար չեն աջակցվում Unix ֆայլային համակարգերի կողմից:

Ֆայլի ատրիբուտները թույլ են տալիս փոխել միջուկի պատասխանը ֆայլերի հավաքածուների հետ աշխատելիս: Դուք կարող եք ատրիբուտներ սահմանել ֆայլի կամ գրացուցակի համար: Երկրորդ դեպքում, այս գրացուցակում ստեղծված ֆայլերը ժառանգում են այս հատկանիշները:

Համակարգի մոնտաժման պահին ֆայլի ատրիբուտների հետ կապված որոշ գործառույթներ կարող են տեղադրվել: Mount տարբերակը թույլ է տալիս ադմինիստրատորին ընտրել, թե ինչպես են ստեղծվում ֆայլերը: BSD-ին հատուկ ֆայլային համակարգում ֆայլերը ստեղծվում են նույն խմբի ID-ով, ինչ մայր գրացուցակը: System V-ի առանձնահատկությունները որոշ չափով ավելի բարդ են: Եթե ​​գրացուցակը ունի setgid բիթ, ապա գեներացված ֆայլերը կվարակեն այդ գրացուցակի խմբի ID-ն, իսկ ենթադիրեկտորիաները ժառանգում են խմբի ID-ն և setgid բիթը: Հակառակ դեպքում, ֆայլերը և գրացուցակները ստեղծվում են զանգի գործընթացի առաջնային խմբի ID-ով:

EXT2fs համակարգը կարող է օգտագործել տվյալների համաժամանակյա փոփոխություն, որը նման է BSD համակարգին: Mount տարբերակը թույլ է տալիս ադմինիստրատորին նշել, որ բոլոր տվյալները (ինոդներ, բիթբլոկներ, անուղղակի բլոկներ և գրացուցակի բլոկներ) համաժամեցված գրվեն սկավառակի վրա, երբ դրանք փոփոխվում են: Սա կարող է օգտագործվել տվյալների գրման բարձր թողունակություն ձեռք բերելու համար, բայց նաև վատթարանում է կատարումը: Իրականում, այս գործառույթը սովորաբար չի օգտագործվում, քանի որ, ի լրումն նվաստացուցիչ կատարողականի, այն կարող է հանգեցնել օգտվողի տվյալների կորստի, որոնք նշված չեն ֆայլային համակարգը ստուգելիս:

EXT2fs-ը թույլ է տալիս ֆայլային համակարգ ստեղծելիս ընտրել տրամաբանական բլոկի չափը: Այն կարող է լինել 1024, 2048 կամ 4096 բայթ չափերով: Խոշոր բլոկների օգտագործումը հանգեցնում է ավելի արագ I/O գործողությունների (քանի որ սկավառակի հարցումների թիվը նվազում է), և, հետևաբար, գլխի ավելի քիչ շարժման: Մյուս կողմից, մեծ բլոկների օգտագործումը հանգեցնում է սկավառակի տարածության կորստի: Սովորաբար, ֆայլի վերջին բլոկը ամբողջությամբ չի օգտագործվում տեղեկատվության պահպանման համար, հետևաբար, բլոկի չափի մեծացմամբ, սկավառակի վատնված տարածքի քանակը մեծանում է:

EXT2fs-ը թույլ է տալիս օգտագործել արագացված սիմվոլիկ հղումներ: Նման հղումներ օգտագործելիս ֆայլային համակարգի տվյալների բլոկները չեն օգտագործվում: Նպատակային ֆայլի անունը պահվում է ոչ թե տվյալների բլոկում, այլ հենց inode-ում: Այս կառուցվածքը թույլ է տալիս խնայել սկավառակի տարածությունը և արագացնել խորհրդանշական հղումների մշակումը։ Իհարկե, նկարագրիչի համար վերապահված տարածքը սահմանափակ է, ուստի ոչ բոլոր հղումները կարող են ներկայացվել որպես արագացված: Ֆայլի անվան առավելագույն երկարությունը արագացված հղման մեջ 60 նիշ է: Մոտ ապագայում նախատեսվում է ընդլայնել այս սխեման փոքր ֆայլերի համար։

EXT2fs-ը վերահսկում է ֆայլային համակարգի վիճակը: Միջուկը սուպերբլոկում օգտագործում է առանձին դաշտ՝ ֆայլային համակարգի վիճակը ցույց տալու համար։ Եթե ​​ֆայլային համակարգը տեղադրված է կարդալու/գրելու ռեժիմում, ապա դրա վիճակը սահմանվում է «Not Clean»: Եթե ​​այն ապամոնտաժված է կամ նորից տեղադրվում է միայն կարդալու ռեժիմով, ապա դրա վիճակը սահմանվում է «Մաքուր»: Համակարգի բեռնման և ֆայլային համակարգի վիճակը ստուգելու ժամանակ այս տեղեկատվությունը օգտագործվում է որոշելու համար, թե արդյոք ֆայլային համակարգը պետք է ստուգվի: Միջուկը նաև որոշ սխալներ է դնում այս դաշտում: Երբ միջուկը հայտնաբերում է անհամապատասխանություն, ֆայլային համակարգը նշվում է որպես «Սխալ»: Ֆայլային համակարգի ստուգիչը ստուգում է այս տեղեկատվությունը համակարգը ստուգելու համար, նույնիսկ եթե դրա վիճակը իրականում «Մաքուր» է:

Ֆայլային համակարգի փորձարկման երկարաժամկետ անտեսումը երբեմն կարող է հանգեցնել որոշ դժվարությունների, հետևաբար EXT2fs-ը ներառում է համակարգը կանոնավոր ստուգելու երկու մեթոդ: Սուպերբլոկը պարունակում է համակարգի ամրացման հաշվիչ: Այս հաշվիչն ավելանում է ամեն անգամ, երբ համակարգը տեղադրվում է կարդալու/գրելու ռեժիմում: Եթե ​​դրա արժեքը հասնում է իր առավելագույն արժեքին (այն նաև պահվում է սուպերբլոկում), ապա ֆայլային համակարգի փորձարկման ծրագիրը սկսում է ստուգել այն, նույնիսկ եթե նրա վիճակը «Մաքուր» է։ Վերջին ստուգման ժամանակը և չեկերի միջև առավելագույն ընդմիջումը նույնպես պահվում են սուպերբլոկում: Երբ ստուգումների միջև առավելագույն միջակայքը հասնում է, ֆայլային համակարգի վիճակը անտեսվում է և սկսվում է դրա ստուգումը:

EXT2fs համակարգը պարունակում է գործիքներ այն կարգավորելու համար: tune2fs ծրագիրը կարող է օգտագործվել փոխելու համար.

• ինչ անել, եթե սխալ հայտնաբերվի: Երբ միջուկը հայտնաբերում է անհամապատասխանություն, ֆայլային համակարգը նշվում է որպես «Սխալ» և կարող է կատարվել հետևյալ երեք գործողություններից մեկը. շարունակել կատարումը, վերամիավորել ֆայլային համակարգը միայն կարդալու ռեժիմում՝ այն վնասելուց խուսափելու համար, վերագործարկել համակարգը։ ֆայլային համակարգը ստուգելու համար:
• ամրացման առավելագույն արժեքը:
• ստուգումների միջև առավելագույն ընդմիջում.
• արմատային օգտագործողի համար վերապահված տրամաբանական բլոկների քանակը:

Մոնտաժի ժամանակ նշված տարբերակները կարող են օգտագործվել նաև միջուկի վարքագիծը փոխելու համար, երբ սխալ է հայտնաբերվում:

Ատրիբուտների օգտագործումը թույլ է տալիս օգտվողներին ջնջել գաղտնի ֆայլերը: Նման ֆայլը ջնջելիս պատահական տեղեկատվությունը գրվում է այն բլոկների մեջ, որոնք նախկինում օգտագործվել են այս ֆայլը տեղադրելու համար: Սա թույլ չի տալիս կողմնակի անձանց մուտք գործել այս ֆայլի նախորդ բովանդակությունը՝ օգտագործելով սկավառակի խմբագրիչը:

Վերջերս EXT2fs համակարգում ավելացվել են ֆայլերի նոր տեսակներ՝ վերցված 4.4 BSD ֆայլային համակարգից: Առաջին տեսակի ֆայլերը կարող են օգտագործվել միայն կարդալու համար. ոչ ոք իրավունք չունի դրանք փոփոխել կամ ջնջել: Սա կարող է օգտագործվել կարևոր կազմաձևման ֆայլերը պաշտպանելու համար: Ֆայլի մեկ այլ տեսակ այն ֆայլերն են, որոնք կարող են բացվել գրելու ռեժիմում, և տվյալները կարող են կցվել միայն այդ ֆայլի վերջում: Այս տեսակի ֆայլերը նույնպես չեն կարող ջնջվել կամ վերանվանվել: Նրանք կարող են օգտագործվել որպես գրանցամատյանների ֆայլեր, որոնք կարող են աճել միայն չափերով:

Կատարման օպտիմիզացում

EXT2fs համակարգը պարունակում է բազմաթիվ գործառույթներ, որոնք օպտիմալացնում են դրա կատարումը, ինչը հանգեցնում է տեղեկատվության փոխանակման արագության բարձրացմանը ֆայլեր կարդալու և գրելու ժամանակ:

EXT2fs-ն ակտիվորեն օգտագործում է սկավառակի բուֆերը: Երբ բլոկը պետք է կարդալ, միջուկը տալիս է I/O հարցում մոտակա մի քանի բլոկների համար: Այսպիսով, միջուկը փորձում է համոզվել, որ հաջորդ ընթերցվող բլոկը արդեն բեռնված է սկավառակի բուֆերում: Նման գործողությունները սովորաբար կատարվում են ֆայլերի հաջորդական ընթերցմամբ:

EXT2fs համակարգը պարունակում է նաև տեղեկատվության տեղաբաշխման մեծ թվով օպտիմալացումներ: Բլոկ խմբերն օգտագործվում են համապատասխան ինոդների և տվյալների բլոկների համատեղման համար: Միջուկը միշտ փորձում է մեկ ֆայլի տվյալների բլոկները տեղադրել նույն խմբում, ինչպես նաև դրա նկարագրիչը։ Սա նախատեսված է նվազեցնելու շարժիչների գլխիկների շարժումը նկարագրիչը և համապատասխան տվյալների բլոկները կարդալիս:

Ֆայլի վրա տվյալներ գրելիս EXT2fs-ը նախապես հատկացնում է մինչև 8 հարակից բլոկներ նոր բլոկ հատկացնելիս: Այս մեթոդը թույլ է տալիս հասնել բարձր կատարողականության, երբ համակարգը ծանրաբեռնված է: Այն նաև թույլ է տալիս ֆայլերի հարակից բլոկներ հատկացնել, ինչը հետագա ընթերցումները դարձնում է ավելի արագ:

EXT2fs գրադարան

libext2fs գրադարանը մշակվել է EXT2fs ռեսուրսների օգտագործումը պարզեցնելու և այս ֆայլային համակարգի կառավարման կառուցվածքների վրա գործելու համար: Այս գրադարանը պարունակում է գործառույթներ, որոնք կարող են օգտագործվել EXT2 ֆայլային համակարգում տվյալներ սահմանելու և փոփոխելու համար՝ ուղղակիորեն մուտք գործելով ֆիզիկական սարք:

EXT2fs կոմունալ ծառայություններից շատերը (mke2fs, e2fsck, tune2fs, dumpe2fs, debugfs և այլն) օգտագործում են այս գրադարանը: Սա շատ ավելի հեշտ է դարձնում այս կոմունալ ծառայությունները փոփոխելը, քանի որ ցանկացած փոփոխություն պետք է մտցվի լրացուցիչ հնարավորություններ EXT2fs ֆայլային համակարգում պետք է արվի միայն EXT2fs գրադարանում:

Քանի որ EXT2fs գրադարանի ինտերֆեյսը բավականին լայն է և վերացական, այն կարող է օգտագործվել հեշտությամբ գրելու ծրագրեր, որոնք պահանջում են ուղղակի մուտք դեպի ֆայլային համակարգ: Օրինակ, EXT2fs գրադարանն օգտագործվել է 4.4 BSD աղբանոց փոխանցելիս և որոշ կոմունալ ծառայություններ վերականգնելիս: Այս գործիքները Linux-ին հարմարեցնելու համար շատ քիչ փոփոխություններ էին պահանջվում (անհրաժեշտ էր փոխարինել ֆայլային համակարգի հետ փոխազդող մի քանի ֆունկցիաներ EXT2fs գրադարանի զանգերով):

EXT2fs գրադարանն ապահովում է մի քանի դասերի գործողությունների հասանելիություն: Առաջին դասը ֆայլային համակարգի հետ կապված գործառնություններն են: Ցանկացած ծրագիր կարող է բացել կամ փակել ֆայլային համակարգ, կարդալ կամ գրել բիթերի բլոկ, ստեղծել նոր ֆայլային համակարգ սկավառակի վրա: Կան նաև գործառույթներ ֆայլային համակարգի վատ բլոկների ցանկում գործելու համար:

Գործողությունների երկրորդ դասը աշխատում է դիրեկտորիաներով: EXT2fs գրադարանն օգտագործող ծրագիրը կարող է ստեղծել կամ ընդլայնել գրացուցակ, ինչպես նաև ավելացնել կամ հեռացնել գրառումները գրացուցակում: Կան գործառույթներ՝ ֆայլի ուղին որոշելու inode նկարագրիչով, իսկ ֆայլի ուղին՝ նշված նկարագրիչով:

Գործողությունների վերջին դասը գործում է ինոդների վրա: Հնարավոր է կարդալ նկարագրիչի աղյուսակը, կարդալ կամ գրել նկարագրիչ, դիտել նշված նկարագրիչի բոլոր բլոկները: Հնարավոր է օգտագործել բլոկների և նկարագրիչների հատկացման և ազատման գործառույթները:

EXT2fs համակարգի հարմարություններ

EXT2fs համակարգի համար մշակվել են հզոր կառավարիչներ: Այս հարմարությունները օգտագործվում են EXT2fs ֆայլային համակարգերում ցանկացած անհամապատասխանություն ստեղծելու, փոփոխելու և ուղղելու համար: Mke2fs ծրագիրը օգտագործվում է սկավառակի բաժանման տեղադրման համար, որը պարունակում է դատարկ EXT2fs ֆայլային համակարգ:

tune2fs ծրագիրը կարող է օգտագործվել ֆայլային համակարգի պարամետրերը կարգավորելու համար: Այն կարող է օգտագործվել սխալների արձագանքը, համակարգի ամրացումների առավելագույն քանակը, համակարգի ստուգումների միջև առավելագույն ընդմիջումը և արմատային օգտվողին վերապահված տրամաբանական բլոկների քանակը փոխելու համար:

Թերևս ամենահետաքրքիր գործիքը ֆայլային համակարգի ստուգիչն է: E2fsck-ը նախատեսված է ֆայլային համակարգի անհամապատասխանությունները շտկելու համար՝ ամբողջ համակարգի ոչ ճշգրիտ անջատումից հետո: e2fsck ծրագրի նախնական տարբերակը հիմնված է Minix ֆայլային համակարգի Linus Torvald fsck ծրագրի վրա։ Այնուամենայնիվ, ծրագրի ընթացիկ տարբերակը վերաշարադրվել է EXT2fs գրադարանի միջոցով և ավելի արագ է և կարող է համակարգում ավելի շատ սխալներ շտկել այն ստուգելիս՝ համեմատած սկզբնական տարբերակի հետ:

E2fsck ծրագիրը նախատեսված էր առավելագույն արագությամբ աշխատելու համար: Քանի որ ֆայլային համակարգը ստուգելու ծրագրերը տանում են դեպի սկավառակի բեռնում, դուք պետք է օպտիմիզացնեք e2fsck ալգորիթմներն այնպես, որ ֆայլային համակարգի կառուցվածքների մուտքը շատ ավելի քիչ հաճախակի լինի: Եվ բացի այդ, ինոդների և տեղեկատուների ստուգման կարգը կկատարվեր ըստ բլոկի համարի, որպեսզի կրճատվի սկավառակակիրների գլխիկների տեղափոխման ժամանակը։

Առաջին անցումում e2fsck-ն անցնում է ֆայլային համակարգի բոլոր ինոդներով և ստուգում է յուրաքանչյուր նկարագրիչ՝ որպես համակարգի առանձին տարր: Այսպիսով, այս փորձարկումը չի ստուգում ֆայլային համակարգի այլ օբյեկտները: Նման ստուգումների նպատակներից մեկն է ստուգել ստուգվող ֆայլի տեսակի առկայությունը, ինչպես նաև նկարագրիչի բոլոր բլոկները համապատասխանեցնել գոյություն ունեցող թվերով բլոկներին: Առաջին անցումը ստուգում է բիթքարտեզները, որոնք ցույց են տալիս բլոկների և նկարագրիչների օգտագործումը:

Եթե ​​e2fsck-ը գտնում է տվյալների բլոկներ, որոնք համարակալված են մեկից ավելի նկարագրիչներով, ապա 1B-ից 1D անցումները գործարկվում են անհամապատասխանությունը պարզելու համար՝ կա՛մ ընդհանուր բլոկները մեծացնելով, կա՛մ մեկ կամ մի քանի նկարագրիչներ ջնջելով:

Առաջին անցումը ամենաշատ ժամանակն է պահանջում, քանի որ բոլոր ինոդները պետք է կարդալ հիշողության մեջ և ստուգել: Հետագա անցումներում I/O գործառնությունների ժամանակը նվազեցնելու համար բոլոր անհրաժեշտ տեղեկությունները մնում են բուֆերում: Այս սխեմայի բնորոշ առանձնահատկությունը ֆայլային համակարգի բոլոր գրացուցակների բլոկների որոնումն է: Այս տեղեկությունը ստանալու համար երկրորդ անցումում վերընթերցվում են ֆայլային համակարգի բոլոր գրացուցակների նկարագրիչ կառուցվածքները:

Երկրորդ անցումում գրացուցակները ստուգվում են որպես առանձին տարրերֆայլային համակարգ. Գրացուցակի յուրաքանչյուր բլոկ ստուգվում է առանձին՝ առանց հղումների այլ գրացուցակների բլոկների: Սա թույլ է տալիս e2fsck-ին տեսակավորել գրացուցակի բոլոր բլոկները ըստ բլոկի համարի և ստուգել դրանք աճման կարգով, այդպիսով նվազեցնելով սկավառակի մուտքի ժամանակը: Գրացուցակի բլոկները փորձարկվում են՝ համոզվելու համար, որ դրանց գրառումները վավեր են և պարունակում են հղումներ առկա թվերով նկարագրիչներին (ինչպես որոշվել է առաջին քայլում):

Յուրաքանչյուր գրացուցակի նկարագրիչի առաջին գրացուցակի բլոկի համար «» -ի առկայությունը: և «..» և ո՞րն է նկարագրիչի համարը, որը պետք է գրել «»-ին: համապատասխանում է ընթացիկ գրացուցակին: («..» գրելու նկարագրիչ համարը չի ստուգվում մինչև երրորդ անցումը:)

Երկրորդ անցման ժամանակ մայր գրացուցակին համապատասխան տեղեկատվությունը պահվում է բուֆերում:

Հարկ է նշել, որ երկրորդ անցման վերջում ավարտված են սկավառակի I/O-ի գրեթե բոլոր գործողությունները: Երրորդ, չորրորդ և հինգերորդ անցումների համար պահանջվող ամբողջ տեղեկատվությունը պահվում է հիշողության մեջ, սակայն մնացած անցումները բեռնում են պրոցեսորը և վերցնում e2fsck-ի ընդհանուր կատարման 5-10%-ից պակասը:

Երրորդ անցումում ստուգվում են գրացուցակի հղումները: E2fsck-ը ստուգում է յուրաքանչյուր գրացուցակի ճանապարհները դեպի արմատ՝ օգտագործելով երկրորդ անցման ընթացքում ստացված տեղեկատվությունը: Այստեղ նույնպես ստուգվում է «..» մուտքագրումը յուրաքանչյուր գրացուցակի համար: Սկանավորումից հետո հայտնաբերված բոլոր դիրեկտորիաները, որոնք կապ չունեն արմատական ​​գրացուցակի հետ, տեղադրվում են / lost + found գրացուցակում:

Չորրորդ անցումում e2fsck-ը ստուգում է հղումների քանակը յուրաքանչյուր ինոդի համար՝ դիտելով բոլոր նկարագրիչները և համեմատելով հղումների քանակը (այս տեղեկատվությունը պահպանվում է առաջին անցումից) ներքին հաշվիչների հետ, որոնք հաշվարկվել են երկրորդ անցումում։ Բոլոր չջնջված ֆայլերը զրոյական տեղեկանքների քանակով նույնպես տեղադրվում են / lost + found գրացուցակում:

Վերջապես, հինգերորդ անցումում e2fsck-ը ստուգում է, որ ֆայլային համակարգի մասին բոլոր տեղեկությունները համընկնում են: Այստեղ բլոկների և նկարագրիչների բիտ քարտեզները, որոնք ստացվել են նախորդ անցումներում, համեմատվում են իրական արժեքների հետ և, անհրաժեշտության դեպքում, համապատասխանաբար շտկվում են սկավառակի տեղեկատվությունը:

Մեկ այլ օգտակար գործիք ֆայլային համակարգի կարգաբերիչն է: Debugfs-ը հզոր ծրագիր է, որը թույլ է տալիս որոշել և սահմանել ֆայլային համակարգի վիճակը: Ըստ էության, այն EXT2fs գրադարանի ինտերակտիվ ինտերֆեյս է, այսինքն՝ մուտքագրված հրամանները վերածում է գրադարանի գործառույթների կանչերի։

Debugf-ները կարող են օգտագործվել ներքին ֆայլային համակարգի կառուցվածքը սահմանելու, վնասված համակարգը ձեռքով վերանորոգելու կամ e2fsck-ի համար պայմանական թեստեր ստեղծելու համար: Ցավոք, այս ծրագիրը կարող է վնասել ֆայլային համակարգը, եթե չգիտեք, թե ինչպես օգտագործել այն: Այս գործիքի միջոցով բավական է պարզապես ոչնչացնել ֆայլային համակարգը: Հետևաբար, debugfs-ը լռելյայն բացում է ֆայլային համակարգը միայն կարդալու ռեժիմով: Կարդալու/գրելու հասանելիության համար օգտագործեք -w տարբերակը:

Կատարման հաշվարկ

Բոնի թեստի արդյունքները կարելի է տեսնել հետևյալ աղյուսակից.

	Նիշերի ձայնագրմամբ (Կբ/վրկ)	Արգելափակել ձայնագրությունը (Կբ / վ)	Գրառում (Կբ / վ)	Կարդացեք ըստ գրանշանների (Kb/s)	Արգելափակման ընթերցում (Կբ / վ)
BSD Async
BSD Sync
Ext2 fs		1237			1033
Xia fs

Արդյունքները բավականին լավ են I/O բլոկի համար. EXT2fs-ը գերազանցում է մյուս համակարգերին կատարողականի առումով: Սա պայմանավորված է տեղաբաշխման ռեժիմում ներառված օպտիմալացումներով: Ձայնագրությունը նույնպես բավական արագ է, քանի որ այն կատարվում է gupp ռեժիմով։ Ընթերցանության բարձր արագությունը պայմանավորված է նրանով, որ բլոկները բաշխվել են ֆայլում, ուստի սկավառակի գլուխները չեն շարժվում երկու ընթերցումների միջև, և առաջ ընթերցման օպտիմալացումը լիովին աշխատում է:

Մյուս կողմից, FreeBSD համակարգն ավելի լավ կատարում է I/O կերպարների համար: Դա կարող է պայմանավորված լինել այն հանգամանքով, որ FreeBSD-ն և Linux-ը օգտագործում են տարբեր ընթացակարգեր համապատասխան C գրադարանների համար: Բացի այդ, FreeBSD-ն, ամենայն հավանականությամբ, կունենա ամենաօպտիմալացված սիմվոլիկ ընթերցանության գրադարանը և, հետևաբար, այստեղ որոշ չափով ավելի լավ աշխատի:

Էնդրյուի թեստի արդյունքները

Էնդրյուի թեստի արդյունքները կարելի է տեսնել հետևյալ աղյուսակից.

	Անցնել 1 Ստեղծել	Անցում 2 Պատճեն	Անցում 3 Ստուգեք կարգավիճակը	Traverse 4 բայթ ստուգում	Քայլ 5 Կազմում
	2203	7391	6319	17466	75314
BSD Sync	2330	7732	6317	17499	75681
Ext2 fs

Առաջին երկու անցումների արդյունքները ցույց են տալիս, որ Linux-ը հաղթում է ասինխրոն հաղորդակցությամբ: Երբ ստեղծվում են դիրեկտորիաներ և ֆայլեր, BSD համակարգը սինխրոն կերպով գրում է նկարագրիչներ և գրացուցակի գրառումներ: Ենթադրվում է, որ FreeBSD-ի ասինխրոն աջակցությունը դեռ ամբողջությամբ չի իրականացվել:

Երրորդ անցումում Linux-ի և BSD-ի արժեքները շատ նման են: Չնայած BSD-ն ավելի լավ կատարում ունի, Linux VFS-ին ֆայլի անվան բուֆեր ավելացնելը կլուծի այս խնդիրը:

Չորրորդ և հինգերորդ անցումներում Linux-ն ավելի արագ է, քան FreeBSD-ը՝ հիմնականում բուֆերային միասնական կառավարման կիրառման շնորհիվ: Բուֆերի չափը կարող է աճել ըստ անհրաժեշտության և ավելի շատ հիշողություն գրավել, քան FreeBSD-ն, որն օգտագործում է ֆիքսված չափ: EXT2fs և Xia fs համակարգերի արդյունքների համեմատությունը ցույց է տալիս, որ EXT2fs-ում ներառված օպտիմալացումն իրականում օգտագործվում է. այս համակարգերի միջև կատարողականի տարբերությունը մոտ 5-10% է:

Եզրակացություն

EXT2 ֆայլային համակարգը Linux-ի օգտագործողների շրջանում ամենաշատ օգտագործվող ֆայլային համակարգն է: Այն ապահովում է Unix-ի ստանդարտ հնարավորություններ և լրացուցիչ գործառույթներ: Ավելին, միջուկում ներառված օպտիմալացումների շնորհիվ այն ցույց է տալիս գերազանց կատարողական արդյունքներ։

EXT2fs համակարգը ներառում է նոր հնարավորություններ ավելացնելու գործառույթներ: Որոշ մարդիկ աշխատում են իրական ֆայլային համակարգի ընդլայնումների մշակման վրա՝ Posix ACL, վերականգնել ջնջված ֆայլերև իրական ժամանակի ֆայլերի սեղմում:

EXT2fs համակարգը սկզբում ինտեգրվել է Linux միջուկին, իսկ այժմ այն ​​ակտիվորեն տեղափոխվում է այլ օպերացիոն համակարգեր: EXT2fs-ը նաև Masix օպերացիոն համակարգի կարևոր մասն է, որը ներկայումս մշակվում է հեղինակներից մեկի կողմից։