Linux
ELF, Ext4, Inode
קבצי ELF, מערכת הקבצים ext4, Inode ופקודות כמו readelf, mount ו-ls -i.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
ELF, Ext4, Inode: פורמט התוכניות, מערכת הקבצים ורשומות הקבצים בלינוקס
מאחורי כל פקודה שמריצים בלינוקס או קובץ שנשמר בדיסק פועלות שלוש שכבות תשתית משלימות. בפרק הזה תכירו אותן מהבסיס ותלמדו לנתח מה קורה בזיכרון ובכונן בעזרת כלי המערכת.
- ELF: תבנית הקבצים הבינאריים של לינוקס עבור תוכניות, ספריות משותפות, קובצי אובייקט ומודולי ליבה. נלמד לזהות חתימות ולקרוא כותרות עם
fileו-readelf, ונענה על שתי שאלות: מה הליבה צריכה למצוא בקובץ לפני שהיא מריצה אותו, ומה אתם יכולים לקרוא ממנו בעצמכם. בדרך נבין גם למה קובץ קיים עלול להיכשל בהודעהNo such file or directory. - Ext4: מערכת הקבצים הסטנדרטית ברוב הפצות לינוקס. נבחן איך היומן מגן מפני כיבוי פתאומי, מה מבדיל בין שלושת מצבי היומן, איך משתמשים ב-
mkfs.ext4,e2fsck,tune2fsו-resize2fs, ומה תפקיד ה-superblock. - Inode: רשומת המטא-דאטה של כל קובץ ותיקייה. נבין מדוע שמות נשמרים בתיקיות ולא ב-inode, איך מחשבים מוני קישורים עם
lnו-ln -s, ולמהrmלא תמיד משחרר מקום פנוי מיד.
לסיום הפרק מצורף נספח קצר על שתי פעולות תחזוקה נפוצות: הסרת מודולי ליבה תלויים בעזרת rmmod וכיבוי הסביבה הגרפית למצב טקסט בעזרת systemctl isolate.
ls, ל-cat ול-rm. הפלטים בפרק הם תוצאות אמיתיות מאובונטו על ext4, ורק איור שהוכן ידנית מסומן כדוגמה.ELF: הפורמט של קבצי התוכנה בלינוקס
מה זה ELF ואיך מזהים אותו
אם תנסו להריץ קובץ .exe של Windows ישירות על לינוקס, הליבה תדחה אותו בדרך כלל מיד (אלא אם הוגדר כלי תאימות כמו Wine). הסיבה היא שכל מערכת הפעלה מצפה שקוד מכונה ונתונים ייארזו בתוך מעטפת תקנית משלה.
ב-Windows המעטפת הזו היא PE, ב-macOS היא Mach-O, ואילו בלינוקס ובמרבית מערכות UNIX התקן הוא ELF (Executable and Linkable Format). הפורמט נולד ב-UNIX System V Release 4 והחליף בלינוקס את הפורמט הוותיק a.out באמצע שנות ה-90.
קוד מכונה לבדו הוא רק רצף הוראות. כדי שמערכת ההפעלה תוכל להריץ אותו היא צריכה לדעת על איזה מעבד הוא נכתב, באיזו כתובת מתחילים, היכן שוכנים הנתונים ומאילו ספריות לוקחים פונקציות. ELF הוא המסמך שנצמד לקוד ועונה על כל השאלות האלה.
השם מצביע על שני שימושים: Executable, קובץ שמריצים ישירות, ו-Linkable, חומר גלם שהמקשר מחבר לקובץ גדול יותר.
ELF אינו קוד ביניים שמתורגם מחדש בכל הרצה, אינו תמונת דיסק או מערכת קבצים, ואינו ארכיון דחוס. בפנים יש הוראות מכונה שכבר הודרו, בצמוד לנתונים שהן צריכות.
ארבעת הבתים הראשונים של כל קובץ ELF קבועים, והם ה-magic number שמאפשר לזהות אותו מיד (ב-readelf -h הם מופיעים בשדה Magic). הדגימה הבאה מדפיסה את 16 הבתים הראשונים של cat, ובצדה הימני הם מוצגים כתווים:
head -c 16 /usr/bin/cat | xxd00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000 .ELF............בהקסדצימלי הרצף הוא 7F 45 4C 46: קודם הבית 0x7F (תו הבקרה DEL), ומיד אחריו הקודים של האותיות E, L ו-F. כדאי להכיר גם חתימות של פורמטים אחרים, כדי לזהות במהירות מה מונח מולכם:
| רצף בתים בהקסדצימלי | משמעות בתווי ASCII | סוג הקובץ |
|---|---|---|
7F 45 4C 46 | DEL + ELF | קובץ ELF של לינוקס ו-UNIX |
4D 5A | MZ | קובץ הרצה (PE) של Windows |
23 21 | #! | קובץ סקריפט טקסט עם shebang (כמו #!/bin/bash) |
CA FE BA BE | קבוע הקסדצימלי | קובץ .class מהודר של Java |
טעויות נפוצות
- קובצי ELF הם קובצי הרצה בלבד, או ארכיון שדוחס את התוכנית. ELF אינו דוחס דבר, ומשמש לא רק לתוכניות אלא גם לקובצי אובייקט (
.o), ספריות (.so), מודולי ליבה (.ko) וקובציcore. - הקוד שבקובץ ELF הוא קוד ביניים שמתפרש או מתקמפל מחדש בכל הרצה. המהדר כבר תרגם את הקוד להוראות מכונה של מעבד מוגדר, והמעבד מריץ אותן ישירות.
- קובצי ELF נפתחים באותיות
MZ(4D 5A). החתימהMZשייכת לקובצי Windows. כל קובץ ELF מתחיל ב-7F 45 4C 46.
בדקו את עצמכם
פתחתם קובץ בעורך הקסדצימלי וראיתם בראשיתו את הבתים 4D 5A 90 00. האם זהו קובץ ELF?
לא. הבתים 4D 5A הם האותיות MZ, שמזהות קובץ PE של Windows. קובץ ELF נפתח תמיד ברצף 7F 45 4C 46.
מה מייצגים ראשי התיבות ELF, ואיזה פורמט קודם החליף בלינוקס?
Executable and Linkable Format. הפורמט שנדחק ממנו בלינוקס היה a.out.
ארבעת הסוגים של קובצי ELF
במהלך בנייה והרצה של תוכנה ב-C נוצרים קבצים בעלי תפקידים שונים לחלוטין, אך כולם חולקים את אותו פורמט ELF. ההבדל ביניהם נשמר בשדה e_type שבראש הקובץ, שמקבל אחד מארבעה ערכים:
ערך e_type | משמעות ושימוש | סיומות וקבצים טיפוסיים | יכולת טעינה והרצה |
|---|---|---|---|
ET_REL | אובייקט בר-הזזה (Relocatable): תוצר ביניים של הידור | .o, מודולי ליבה .ko | חסר כתובות זיכרון סופיות; דורש שילוב על ידי המקשר (ld) או טעינה לליבה |
ET_EXEC | קובץ הרצה קלאסי (ללא PIE) | תוכניות שהודרו ללא PIE | נטען תמיד לכתובת קבועה מראש |
ET_DYN | אובייקט משותף (Shared Object) ותוכניות PIE | ספריות .so, תוכניות מערכת מודרניות | ניתן למיפוי בכל כתובת זיכרון פנויה |
ET_CORE | תמונת קריסה (Core File) | קובצי core | מנציח זיכרון של תהליך שקרס לצורך ניתוח בדיבאגר |
בהפצות לינוקס עכשוויות gcc מהדר תוכניות כברירת מחדל במצב PIE (Position-Independent Executable), כלומר קובץ שאפשר לטעון בכל כתובת אקראית בזיכרון. מסיבה זו גם פקודות מערכת רגילות מסווגות בכותרת ה-ELF כ-ET_DYN.
הפקודה file קוראת את הכותרות ומסכמת את זהות הקובץ בשורה אחת. כאן הוספנו -b (בלי שם הקובץ) ופיצול לפי פסיקים כדי שכל שדה יקבל שורה משלו, והסרנו את שורות ה-BuildID וה-interpreter כדי לקצר. התוצאה על תוכנית מערכת ועל ספרייה משותפת, מהרצה על אובונטו:
file -b /usr/bin/cat | tr ',' '
' | nl | grep -vE 'BuildID|interpreter'
file -b /lib/x86_64-linux-gnu/libm.so.6 | tr ',' '
' | nl | grep -vE 'BuildID|interpreter' 1 ELF 64-bit LSB pie executable
2 x86-64
3 version 1 (SYSV)
4 dynamically linked
7 for GNU/Linux 3.2.0
8 stripped
1 ELF 64-bit LSB shared object
2 x86-64
3 version 1 (GNU/Linux)
4 dynamically linked
6 for GNU/Linux 3.2.0
7 strippedכל שדה בפלט מספר פרט חשוב על הקובץ. ELF 64-bit מציין מחלקה של 64 סיביות, LSB מציין סדר בתים little endian (הבית הפחות משמעותי ראשון), ו-x86-64 מציין את המעבד.
הצירוף pie executable משמעו תוכנית ET_DYN. החלק dynamically linked אומר שהיא תלויה בספריות משותפות בזמן ריצה, ובפלט המלא של file מופיעה אחריו שורת interpreter עם נתיב הטוען (נפרט אותה בחלק על execve). המילה stripped, לעומת not stripped, מציינת אם .symtab הוסרה.
לעומת זאת, קובץ שהודר עם gcc -static יופיע כ-statically linked ללא שדה interpreter, וקובץ קריסה יוצג כ-core file. שימו לב שספרייה סטטית (.a) איננה קובץ ELF יחיד: זהו ארכיון (ar) המאגד קובצי .o, שהמקשר מעתיק ממנו קוד לתוך התוכנית הסופית בזמן הקישור.
תרחיש 1: ארבעה קבצים מתיקיית בנייה: מה עושים עם כל אחד
אחרי make נשארו בתיקייה util.o, libutil.so, tool ו-core. file מסווגת אותם בהתאמה כ-relocatable, shared object, pie executable ו-core file.
tool(pie executable): היחיד שאפשר להפעיל מהמעטפת בהקלדת./tool.util.o(relocatable): נוצר ב-gcc -cועדיין בלי כתובות סופיות, ולכן חייב לעבור קישור עם שאר המודולים.libutil.so(shared object): לא רץ בעצמו. תוכניות אחרות מבקשות אותו בזמן ההרצה.core(core file): צילום זיכרון של תהליך שקרס, שפותחים בדיבאגר כדי לתחקר את הקריסה.
טעויות נפוצות
- קובץ
relocatableהוא תוכנית בעלת כתובת טעינה קבועה, ספרייה משותפת או קובץ קריסה. כתובת קבועה היאET_EXEC, ספרייה משותפת היאET_DYN, וקובץ קריסה הואET_CORE.relocatable(ET_REL) הוא קובץ אובייקט שטרם עבר קישור. - הסיומת
.soשייכת לקובץ אובייקט לפני קישור, לספרייה סטטית או למודול ליבה. קובץ אובייקט לפני קישור מסתיים ב-.o, ספרייה סטטית ב-.a(ארכיון של.o), ומודול ליבה ב-.ko(נטען לליבה עםmodprobe). הסיומת.soמייצגת ספרייה משותפת.
בדקו את עצמכם
בדוח בנייה מופיע ET_REL ליד שם של קובץ. מה זה אומר על הכתובות שבו, ומי משלים אותן?
הכתובות הסופיות עוד לא נקבעו. המקשר (ld, בדרך כלל דרך gcc) מחבר את הקובץ לשאר המודולים וקובע אותן.
עמית מופתע ש-ls מוגדרת ET_DYN ולא ET_EXEC, כי זו הרי לא ספרייה. מה עונים לו?
ET_DYN משמש גם לתוכנית PIE. ls נבנתה כך שאפשר למפות אותה בכל כתובת פנויה, ולכן הכותרת רושמת לה DYN.
כותרת ה-ELF
לפני שלינוקס או כלי ניתוח יודעים איפה נמצאים מקטעי הזיכרון או טבלאות השמות בקובץ, הם חייבים לקרוא מפה ראשית קבועה. זו בדיוק כותרת ה-ELF (ELF Header), שיושבת בהיסט 0 בראש כל קובץ ELF וגודלה 64 בתים בארכיטקטורת 64 סיביות.
הפקודה readelf -h שולפת ומציגה את כל שדות הכותרת ורק אותם. כדי לקצר, הדוגמה האמיתית הזו על /usr/bin/cat מסננת את השדות החשובים בלבד:
readelf -h /usr/bin/cat | grep -E 'Class|Data|OS/ABI|Type|Machine|Entry|Start of' Class: ELF64
Data: 2's complement, little endian
OS/ABI: UNIX - System V
Type: DYN (Position-Independent Executable file)
Machine: Advanced Micro Devices X86-64
Entry point address: 0x3770
Start of program headers: 64 (bytes into file)
Start of section headers: 33296 (bytes into file)כדאי לחלק את שדות הכותרת לשלוש קבוצות לפי תפקידם:
- זיהוי וסביבה:
Class(ELF32אוELF64),Data(סדר הבתים:little endianאוbig endian),OS/ABI(ממשק מערכת ההפעלה) ו-Machine(המעבד המיועד, כמוX86-64או ARM). - תפקיד ונקודת התחלה:
Type(אחד מארבעת טיפוסי ה-ELF) ו-Entry point address(הכתובת שבה מתחילה הרצת התוכנית). - מפת הטבלאות:
Start of program headersו-Start of section headers, המציינים באיזה בית בקובץ מתחילה כל אחת משתי טבלאות המבנה.
.symtab, ולכן מחיקת הסמלים אינה משנה את המקום שבו הליבה מתחילה להריץ.טעויות נפוצות
readelf -hמציגה את טבלת הסמלים או את הספריות הדינמיות הנדרשות. הדגל-hמוגבל לכותרת הראשית בלבד. סמלים מוצגים בעזרת-s, וספריות דינמיות בעזרת-d.readelf -hמציגה את מקטעי הטעינה לזיכרון או מפרקת קוד מכונה ל-assembly. מקטעי הטעינה (program headers) מוצגים עםreadelf -l, ופירוק הוראות מכונה נעשה באמצעותobjdump -d.
בדקו את עצמכם
קיבלתם בינארי מכרטיס Raspberry Pi ורוצים לאשר שהוא בנוי ל-ARM ולדעת היכן הוא מתחיל. מה מריצים ומה קוראים בפלט?
מריצים readelf -h וקוראים את Machine (ארכיטקטורת המעבד) ואת Entry point address (כתובת ההתחלה).
הפרדת מבט ההרצה ממבט הקישור: Segments ו-Sections
אם תשחיתו או תמחקו את טבלת ה-sections של תוכנית ELF, האם הליבה תסרב להריץ אותה? התשובה היא לא, משום שקובץ ELF מחזיק שתי טבלאות נפרדות לשני קהלים שונים לחלוטין.
בזמן הרצה, הליבה והטוען הדינמי קוראים אך ורק את טבלת ה-program headers (מוצגת ב-readelf -l), שמתארת segments - רצועות זיכרון והרשאותיהן. לעומתם, המקשר (ld), הדיבאגר וכלי הניתוח (nm, objdump) עובדים מול טבלת ה-section headers (מוצגת ב-readelf -S), שמתארת sections - חטיבות לוגיות עם שמות כמו .text ו-.data.
| מבט על הקובץ | שם הטבלה | יחידת המבנה | מי משתמש בה | פקודה להצגה |
|---|---|---|---|---|
| מבט ההרצה (Execution) | Program Headers | Segments (טווחי מיפוי והרשאות) | הליבה (execve) והטוען הדינמי | readelf -l |
| מבט הקישור (Linking) | Section Headers | Sections (חטיבות בעלות שם) | המקשר, הדיבאגר, objdump, nm | readelf -S |
בטבלת ה-program headers יש שלושה סוגי segments מרכזיים שכדאי להכיר:
PT_LOAD(בפלט:LOAD): רצועה שהליבה ממפה מהקובץ לזיכרון, וכל רצועה נושאת צירוף משלה של הרשאותR,Wו-E.PT_INTERP(בפלט:INTERP): הנתיב של הטוען הדינמי שהליבה צריכה לצרף לטעינה.PT_DYNAMIC(בפלט:DYNAMIC): הפניה לטבלאות הקישור הדינמי והספריות הנדרשות.
הנה ה-segments של cat בתצוגה רחבה (-W), כשהפלט מסונן לסוגים שנדון בהם בלבד (PHDR, NOTE ועוד נשמטו). שימו לב לעמודות FileSiz, MemSiz ו-Flg, שנחזור אליהן:
readelf -lW /usr/bin/cat | grep -E 'Type|INTERP|LOAD|DYNAMIC' Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
INTERP 0x000318 0x0000000000000318 0x0000000000000318 0x00001c 0x00001c R 0x1
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x001478 0x001478 R 0x1000
LOAD 0x002000 0x0000000000002000 0x0000000000002000 0x003c36 0x003c36 R E 0x1000
LOAD 0x006000 0x0000000000006000 0x0000000000006000 0x0012c0 0x0012c0 R 0x1000
LOAD 0x007ae0 0x0000000000008ae0 0x0000000000008ae0 0x000588 0x0006d8 RW 0x1000
DYNAMIC 0x007c40 0x0000000000008c40 0x0000000000008c40 0x0001b0 0x0001b0 RW 0x8בסוף הפלט של readelf -l, תחת הכותרת Section to Segment mapping, רואים אילו sections נכללו בכל segment. הרבה sections מתקבצים לקומץ segments לפי הרשאות משותפות. הנה שתי שורות מהמיפוי של cat, שבו המספרים סופרים גם שורות שהסינון הקודם השמיט:
readelf -l /usr/bin/cat | grep -E '^ +0[35] ' 03 .init .plt .plt.got .plt.sec .text .fini
05 .ctors .dtors .data.rel.ro .dynamic .got .data .bssמי שמחפש היכן יושב הקוד מוצא אותו בשורה 03: זה ה-LOAD בעל R E, ובו .text, .init, .plt ו-.fini. הנתונים הניתנים לשינוי, .data ו-.bss, יושבים בשורה 05, ב-LOAD בעל RW. כך הקוד לא ניתן לכתיבה והנתונים לא ניתנים להרצה.
תרחיש 2: אילו דגלים באמת אוכפת הליבה
בודקת אבטחה צריכה לברר אם בקובץ gateway_d יש אזור שגם ניתן לכתיבה וגם להרצה. היא מתלבטת בין readelf -S ל-readelf -l.
ההכרעה היא readelf -l, כי ההרשאות שנאכפות בזיכרון נקבעות לפי דגלי ה-segments שבעמודה Flg. הפקודה readelf -S מציגה דגלים של sections לצורכי קישור ואינה משקפת מה הליבה מגדירה. הפקודות -s (סמלים) ו--d (מידע דינמי) אינן עונות על השאלה.
טעויות נפוצות
- הליבה קוראת את טבלת ה-sections כדי למפות תוכנית לזיכרון, ולכן טבלת sections פגומה תפיל את ההרצה. הליבה פועלת לפי ה-segments שב-program headers (
readelf -l) בלבד, ומתעלמת מטבלת ה-sections בזמן ריצה. - קיים יחס של אחד-לאחד בין section ל-segment. segment אחד מאגד בדרך כלל כמה sections בעלי הרשאות תואמות (למשל
.dataו-.bssיחד במקטעRW).
בדקו את עצמכם
באיזה סוג segment ובאילו דגלי הרשאה יימצא הסעיף .text?
ב-segment מסוג PT_LOAD (LOAD) בעל הרשאות R E (קריאה והרצה, ללא כתיבה).
מתי תעדיפו readelf -l ומתי readelf -S?
readelf -l מציגה את מבט ההרצה (segments והרשאות מיפוי עבור הליבה), ואילו readelf -S מציגה את מבט הקישור (רשימת ה-sections עבור המקשר והכלים).
הסעיפים החשובים ו-.bss
תרחיש 3: אותו נפח, שני מקומות: .bss מול .data
.data הוא אזור המשתנים הגלובליים עם ערך התחלתי שאינו אפס, והערכים שמורים בקובץ. .bss הוא אזור המשתנים בלי ערך התחלתי, מסוג NOBITS: מופיע בטבלה אך אין לו בתים בקובץ. נראה זאת בשתי תוכניות assembly שרק מקצות זיכרון, כך שאין צורך להכיר assembly.
נכתוב שתי תוכניות assembly קצרות שמקצות מערך של 32 MiB. בראשונה (bss.s) אין ערך התחלתי, ולכן המערך הולך ל-.bss:
.lcomm grid, 33554432 # 32 MiB, no initial value -> .bss
.text
.globl _start
_start:
movl $7, grid(%rip) # write to the array
movl $60, %eax # exit syscall number
xorl %edi, %edi # exit status 0
syscallבשנייה (dat.s) משאירים את אותו קוד, ורק מחליפים את שתי השורות הראשונות בהגדרה עם ערך התחלתי, ואז המערך הולך ל-.data:
.data
grid:
.long 7 # non-zero initial value
.zero 33554428 # the rest of the 32 MiB
.textאחרי הרכבה וקישור משווים את הקבצים ואת מקטעי ה-LOAD שלהם:
as bss.s -o bss.o && ld bss.o -o bss_prog
as dat.s -o dat.o && ld dat.o -o dat_prog
ls -l bss_prog dat_prog | awk '{print $5, $9}'
readelf -lW bss_prog | grep -E 'Type|LOAD'4752 bss_prog
33563256 dat_prog
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x0000000000400000 0x0000000000400000 0x0000e8 0x0000e8 R 0x1000
LOAD 0x001000 0x0000000000401000 0x0000000000401000 0x000013 0x000013 R E 0x1000
LOAD 0x000000 0x0000000000402000 0x0000000000402000 0x000000 0x2000000 RW 0x1000הקובץ עם .bss שוקל כ-4.7 KB, והקובץ עם .data שוקל יותר מ-33 מיליון בתים. ב-bss_prog ה-segment השלישי (RW) מציג FileSiz אפס ו-MemSiz של 0x2000000, כלומר 32 MiB.
אותו עיקרון חל על static int grid[8388608]; ב-C, אבל רק בבנייה ללא אופטימיזציה (-O0). באופטימיזציה גבוהה מהדר רשאי להסיר לגמרי מערך שרק כותבים אליו, ואז אין .bss גדול כלל.
אפסים לא צריך לאחסן: משתנה שלא אותחל מתחיל מאפס ממילא, ולכן הקובץ שומר רק כתובת וגודל והליבה ממלאת אפסים בעת הטעינה. ההשפעה נראית בשני שדות הגודל של ה-segment הניתן לכתיבה:
FileSiz: כמה בתים מה-segment שמורים בפועל בקובץ. ב-LOADבעלRWשלcatלמעלה זה0x588, ובתוכניתbss_progזה אפס.MemSiz: כמה זיכרון הליבה מקצה בטעינה. אצלcatזה0x6d8, והפער של0x150בתים הוא אפסים שהליבה מוסיפה, ורובם.bss(קצת ריפוד יישור כלול). אצלbss_progהפער הוא 32 MiB.
שאר הסעיפים המרכזיים בטבלת ה-sections מתחלקים בין קוד ונתונים לזמן ריצה לבין מידע לקישור ולדיבאגר:
| שם הסעיף | מה נשמר בו | דוגמה מקוד C |
|---|---|---|
.text | קוד המכונה המהודר (נטען לקריאה והרצה, ללא כתיבה) | המימוש של main ופונקציות אחרות |
.rodata | נתונים לקריאה בלבד שאינם משתנים | מחרוזת מילולית כמו "ready" |
.data | גלובליים וסטטיים שאותחלו בערך שאינו אפס, וערכיהם נשמרים בקובץ | int retries = 3; |
.bss | משתנים גלובליים וסטטיים ללא אתחול או מאותחלים לאפס (NOBITS) | char buf[8192]; |
.symtab, .strtab | טבלת הסמלים המלאה של התוכנית ומחרוזות השמות | השמות main ו-retries |
.dynsym, .dynstr | טבלת הסמלים הדינמיים עבור הטוען הדינמי | ייבוא של printf מ-libc.so.6 |
.plt, .got | טבלאות ניתוב והפניה לקריאות לספריות משותפות | פתרון כתובת הקריאה ל-printf |
.debug_* | מידע לדיבאגר (מספרי שורות, טיפוסים) | נוצר בהידור עם gcc -g |
טעויות נפוצות
- הקובץ קטן כי הליבה פורסת בזמן ההרצה גרסה מכווצת של
.bssשנשמרה בו. ב-ELF אין דחיסה של segments. ל-.bssאין בתים בקובץ בכלל, והליבה יוצרת עבורו דפי זיכרון מאופסים. - ההפרש בין
MemSizל-FileSizהוא שטח שהוקצה מראש לערימה (heap). הערימה גדלה בנפרד בזמן ריצה. ההפרש הוא בעיקר אפסים של.bss. - הליבה טוענת את שאר ה-segment מהדיסק בהדרגה, לפי הצורך. אין מה לקרוא מהדיסק: החלק הזה ריק בקובץ.
- משתנה גלובלי בלי אתחול נשמר ב-
.data, ב-.rodata, ב-.textאו ב-.symtab..dataשמור לערכים שאינם אפס,.rodataלקבועים,.textלקוד ו-.symtabלשמות. משתנה בלי אתחול הולך ל-.bss.
בדקו את עצמכם
בהנחה שההגדרות הבאות הן גלובליות, היכן ישבו const char banner[] = "v2";, int hits; ו-int limit = 9;?
banner ב-.rodata, hits ב-.bss ו-limit ב-.data.
בפלט readelf -l על segment מסוג LOAD בעל RW מופיעים FileSiz של 0x588 ו-MemSiz של 0x6d8. כמה בתים מאופסים הליבה מוסיפה, ואיזה סעיף ממלא את רובם?
הפער הוא 0x150 (336 בתים) של זיכרון מאופס, ורובו .bss, שהליבה מאפסת בטעינה. חלק קטן ממנו הוא ריפוד ליישור.
תהליך הטעינה: execve והטוען הדינמי ld-linux
אחת מתקלות הלינוקס המבלבלות ביותר קורה כך: אתם רואים את הקובץ ./probe מול העיניים עם הרשאות הרצה (-rwxr-xr-x), מריצים אותו, וה-shell מחזיר No such file or directory. איך קובץ שקיים בתיקייה יכול להיכשל בהודעה שהוא אינו נמצא?
כדי להבין, נעקוב אחרי מה שקורה כשה-shell קורא ל-execve. שלושה גורמים מעורבים, כל אחד בתורו:
- הליבה: בודקת שהבתים הראשונים הם
7F 45 4C 46ושהכותרת תקינה, ממפה את ה-segments מסוגPT_LOADלפי ההרשאות שלהם ומאפסת את.bss. כשקייםPT_INTERP, היא טוענת לזיכרון גם את הטוען הנקוב שם ומוסרת לו את השליטה. בליPT_INTERPהיא קופצת ישר לנקודת הכניסה של התוכנית. - הטוען הדינמי: מביא את כל קובצי ה-
.soשרשומים כ-NEEDED, ממלא כתובות של סמלים ואז קופץ לקוד התוכנית. - התוכנית: מתחילה ב-
_start, שמכינה את הסביבה וקוראת ל-mainשבתוכנית עצמה.
הנתיב של הטוען התקני בלינוקס x86-64 הוא /lib64/ld-linux-x86-64.so.2. המילה interpreter מטעה: ה-ld-linux לא מפרש קוד כמו מפרש סקריפטים שנקרא דרך #!. הוא תוכנית רגילה שרצה מחוץ לליבה, ותפקידו לאסוף את הספריות שהתוכנית צריכה ולחבר אותן אליה, בלי קומפילציה ובלי בדיקת חתימות.
תוכנית שנבנתה עם gcc -static נושאת את קוד הספריות בתוך עצמה, ולכן אין לה PT_INTERP והיא אינה זקוקה לטוען. שתי הפקודות הבאות מאשרות זאת על bss_prog מהחלק הקודם. זו תוכנית שאינה משתמשת בספריות בכלל, ולכן היא המקרה הסטטי הפשוט ביותר:
file bss_prog
ldd bss_progbss_prog: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
not a dynamic executableהמצב ההפוך מבלבל יותר: אם הנתיב הכתוב ב-PT_INTERP לא קיים בדיסק, execve נכשלת ב-ENOENT וה-shell מדפיס No such file or directory. האשמה בטוען החסר, לא בקובץ שהקלדתם.
הודעת שגיאה בהרצת ./app | הגורם המיידי |
|---|---|
Permission denied | חסרה הרשאת הרצה (x) על הקובץ |
No such file or directory (כשהקובץ קיים) | הטוען הדינמי שנקוב ב-PT_INTERP אינו קיים במערכת |
Exec format error | ארכיטקטורה לא תואמת (כגון קובץ ARM על x86-64) או פורמט לא מוכר |
error while loading shared libraries | הטוען הדינמי עצמו רץ, אך חסרה אחת מספריות ה-.so שהתוכנית דורשת |
תרחיש 4: כלי 32 סיביות על שרת 64 סיביות
העברתם כלי בקרה ישן בשם plc_ctl לשרת לינוקס 64 סיביות שהליבה שלו תומכת בהרצת 32 סיביות, אך לא הותקנו בו ספריות 32 סיביות. לקובץ יש הרשאות -rwxr-xr-x, ובכל זאת הרצת ./plc_ctl מחזירה No such file or directory.
הרצת file ./plc_ctl חושפת שזהו קובץ בינארי של 32 סיביות (Intel 80386) שמקושר דינמית ומבקש את הנתיב /lib/ld-linux.so.2 בתור interpreter. מכיוון שהטוען הזה אינו מותקן במערכת, הליבה מחזירה ENOENT.
אותו מצב קורה כשמעתיקים בינארי x86-64 שנבנה ב-Alpine Linux (הוא מבקש interpreter /lib/ld-musl-x86_64.so.1) לשרת Ubuntu או Debian. אפשר להתקין בשרת את הטוען והספריות שהקובץ מבקש, או לבנות את התוכנית מחדש עבור המערכת שבה תרוץ.
טעויות נפוצות
- ה-
interpreterהוא מפרש שורות כמו#!, רכיב ליבה שממפה מקטעים, מהדר, או מנגנון בדיקת חתימות. הליבה היא שממפה אתPT_LOAD. ה-interpreter(ld-linux) הוא תוכנית במרחב המשתמש שטוענת ספריות ופותרות סמלים עבור קוד מכונה מוכן. - הודעת
No such file or directoryעל קובץ קיים נובעת מחוסר בהרשאת הרצה, או מזה ש-PT_INTERPקיים בתוכנית סטטית. חוסר הרשאה מחזירPermission denied.PT_INTERPקיים רק בתוכניות דינמיות (ולא בסטטיות, ב-.oאו ב-.ko), וחסרונו בדיסק גורם ל-ENOENT.
בדקו את עצמכם
בפלט readelf -l על קובץ הרצה לא מופיע מקטע INTERP. מה ניתן להסיק על הקובץ?
שהתוכנית קושרה סטטית (gcc -static), ולכן היא מכילה את קוד הספריות בתוכה ואינה זקוקה לטוען דינמי.
אילו פעולות מבצע ld-linux אחרי שהליבה סיימה לטעון את ה-segments?
בסיום הוא מעביר את השליטה ל-_start של התוכנית, שמפעילה את main. לפני כן הוא מביא את ספריות ה-.so שהתוכנית דורשת ומקשר אליהן את הסמלים.
ארגז הכלים: file, readelf, objdump, nm
readelf רק קורא ומציג. מי שצריך הוראות assembly פונה ל-objdump -d, חיבור של קובצי אובייקט שייך ל-ld או ל-gcc, ושינוי הקובץ שייך ל-strip. כדי לא להתבלבל, מיינו את הפקודות לפי השאלה שאתם מנסים לפתור:
| קטגוריה | פקודה | מה היא מציגה או מבצעת |
|---|---|---|
| זיהוי כללי | file prog | שורה מסכמת: 32/64 סיביות, סוג ELF, ארכיטקטורה, דינמי/סטטי, stripped |
| זיהוי כללי | stat prog | מטא-דאטה של ה-inode ממערכת הקבצים (גודל, הרשאות, זמנים) - לא בודקת תוכן |
| זיהוי כללי | strings prog | חילוץ רצפי תווים קריאים מתוך קובץ בינארי |
מבנה ELF (readelf) | readelf -h prog | שדות הכותרת הראשית: סוג הקובץ, המעבד וכתובת ההתחלה |
מבנה ELF (readelf) | readelf -l prog | טבלת ה-program headers (ה-segments שהליבה ממפה) |
מבנה ELF (readelf) | readelf -S prog | טבלת ה-section headers (רשימת ה-sections) |
מבנה ELF (readelf) | readelf -s prog | טבלאות הסמלים |
מבנה ELF (readelf) | readelf -d prog | הסעיף הדינמי (רשומות NEEDED לספריות) |
מבנה ELF (readelf) | readelf -a prog | כל מבנה ה-ELF במבט אחד (כותרות, סעיפים, מקטעים, סמלים, דינמי) בלי פירוק קוד |
| קוד וסמלים | objdump -d prog | תרגום קוד המכונה בחזרה להוראות assembly קריאות |
| קוד וסמלים | objdump -h prog | הצגת רשימת ה-sections |
| קוד וסמלים | nm prog | הסמלים מתוך .symtab והכתובות שלהם |
| תלויות ועריכה | ldd prog | תלויות ספריות משותפות ונתיביהן (עלול להריץ את הקובץ) |
| תלויות ועריכה | strip prog | משנה את הקובץ: מוחקת את .symtab ואת סעיפי .debug_* |
תרחיש 6: תשאול מלא של קובץ שירות ללא הרצה
קיבלתם קובץ בינארי בשם auth_gw ויש לכם ארבע שאלות ממוקדות בלי להריץ אותו:
- אילו פונקציות מוגדרות בתוכו (אם לא עבר
strip)? מריציםnm auth_gw. - מהן הוראות ה-assembly של פונקציה בכתובת
0x4012a0? מריציםobjdump -d auth_gw. - איך לראות את כל הכותרות, הסעיפים, המקטעים והסמלים יחד בלי לפרק קוד? מריצים
readelf -a auth_gw. - האם מדובר בקובץ ELF ולאיזה מעבד? מריצים
file auth_gw.
טעויות נפוצות
readelfמפרקת קוד ל-assembly, מקשרת קובצי אובייקט או משנה את נקודת הכניסה.readelfקוראת ומציגה מבנה ELF בלבד. פירוק קוד הוא תפקידobjdump -d, וקישור הוא תפקידld/gcc.nm -a,ldd -vאוstrip -sמציגות את כלל הכותרות והטבלאות של ELF.nm -aמציגה סמלים בלבד,ldd -vמציגה ספריות וגרסאות, ו-stripמסירה סמלים מהקובץ. המבט הכולל הואreadelf -a.stat progתזהה שמדובר בקובץ ELF של 64 סיביות.statמציגה נתוני inode ממערכת הקבצים ואינה קוראת את תוכן הקובץ; זיהוי התוכן נעשה עםfile.
בדקו את עצמכם
באילו שתי פקודות תשתמשו אם תרצו באחת לראות את כל כותרות ה-ELF והטבלאות בלי assembly, ובשנייה לפרק את קוד המכונה להוראות assembly?
readelf -a להצגת כל המבנה בלי לפרק קוד, ו-objdump -d לפירוק קוד המכונה להוראות assembly.
strip: מה נמחק ומה ממשיך לעבוד
אם תריצו nm /usr/bin/cat, תיתקלו בהודעה no symbols, אף שברור שהתוכנית רצה וקוראת לפונקציות מתוך libc.so.6. ההסבר טמון בהבדל שבין סמלים למפתחים לבין סמלים להרצה, ובפעולת הפקודה strip.
strip מקטינה קובץ ELF: היא זורקת את .symtab יחד עם .strtab, ואת סעיפי .debug_*, שהם מידע שנועד למפתחים. בגלל זה כמעט כל קובצי ההפצה מגיעים stripped. שלושה מרכיבים נשארים שלמים, והם אלה שמאפשרים לקובץ להמשיך לרוץ:
- כותרת ה-ELF: שומרת בתוכה את
Entry point address, כך שהתוכנית יודעת מאיפה להתחיל. - טבלת ה-program headers: נותרת ללא שינוי, ולכן הליבה ממשיכה למפות את ה-segments בדיוק כמו קודם.
- הסעיפים הדינמיים
.dynsymו-.dynamic: נשמרים בקובץ, ולכן הטוען הדינמי ממשיך לטעון ספריות משותפות ולפתור סמלים.
המחיר של strip מורגש רק בניפוי שגיאות ובניתוח סטטי: הדיבאגר מציג כתובות זיכרון גולמיות במקום שמות פונקציות ומספרי שורות, ופקודת nm רגילה (שקוראת את .symtab) מדווחת שאין סמלים. כדי לצפות בסמלים הדינמיים ששרדו ב-.dynsym, יש להוסיף את הדגל -D:
nm /usr/bin/cat
nm -D /usr/bin/cat | head -n 4nm: /usr/bin/cat: no symbols
w _ITM_deregisterTMCloneTable
w _ITM_registerTMCloneTable
U __ctype_b_loc@GLIBC_2.3
U __ctype_get_mb_cur_max@GLIBC_2.2.5תרחיש 7: שני עותקים של תוכנית קטנה: לפני ואחרי strip
ניקח את bss_prog, הקובץ שנבנה בחלק על .bss, ונעתיק אותו לשני עותקים ונריץ strip על אחד מהם. אז נשווה גודל, רשימת sections, סמלים והרצה:
cp bss_prog prog_full; cp bss_prog prog_slim; strip prog_slim
ls -l prog_full prog_slim | awk '{print $5, $9}'
for f in prog_full prog_slim; do readelf -SW $f | grep -oE '\] \.[a-z_.]+' | tr -d '] ' | tr '\n' ' '; echo; done
nm prog_slim
./prog_slim; echo "exit=$?"4752 prog_full
4400 prog_slim
.text .bss .symtab .strtab .shstrtab
.text .bss .shstrtab
nm: prog_slim: no symbols
exit=0העותק הרזה קטן יותר, ומרשימת ה-sections שלו נעלמו .symtab ו-.strtab, ולכן nm לא מוצאת בו סמלים. הוא ממשיך לרוץ ולסיים בהצלחה. בדיבאגר, מחסנית קריאות של עותק כזה תציג כתובות במקום שמות פונקציות.
טעויות נפוצות
- אחרי
stripהתוכנית תיכשל בטעינה כי נקודת הכניסה ב-.symtabאו מידע המיפוי ב-.debug_*נמחקו. נקודת הכניסה שמורה בכותרת ה-ELF, והליבה ממפה לפי ה-program headers. שניהם אינם נפגעים מ-strip. - בקובץ שעבר
stripאין יותר צורך בספריות משותפות, או ש-nmתציג אוטומטית סמלים דינמיים / תיכשל בשגיאת פורמט. הקובץ נשאר ELF תקין והספריות נטענות כרגיל דרך.dynsymו-.dynamic.nmבלי-Dקוראת רק את.symtabולכן מדווחתno symbols.
בדקו את עצמכם
אילו חלקים בקובץ ELF דינמי נותרים שלמים אחרי strip ומאפשרים לו להמשיך לרוץ, ואיך תראו בכל זאת את הסמלים הדינמיים שלו?
נשארים כותרת ה-ELF (כולל נקודת הכניסה), ה-program headers (ה-segments), והסעיפים הדינמיים .dynsym ו-.dynamic. את הסמלים הדינמיים רואים בעזרת nm -D.
ext4: מערכת הקבצים של לינוקס
ext4 במבט ראשון: מה היא, מאיפה באה ואיפה היא לא שייכת
נניח שחיברתם דיסק חדש ואתם רוצים לשמור עליו את הקובץ report.txt. הדיסק עצמו מכיר רק בלוקים עם מספרים, בלי שמות ובלי תיקיות. מי שמחליט איפה כל קובץ יושב, אילו בלוקים עוד ריקים ואיך קוראים לכל דבר הוא מערכת הקבצים.
ext4 (קיצור של Fourth Extended File System) היא מערכת הקבצים שרוב מחשבי לינוקס משתמשים בה על הכונן המקומי שלהם. הליבה סימנה אותה כיציבה בגרסה 2.6.28, בדצמבר 2008, ובהפצות כמו Debian ו-Ubuntu היא בחירת ברירת המחדל.
היא הדור הרביעי במשפחה, וכל דור נבנה על הקודם לו:
| דור | מה הוסיף | מה עדיין חסר בו |
|---|---|---|
ext2 | מבנה קבצים שמבוסס על inodes, הבסיס של כל המשפחה | בלי יומן: אחרי הפסקת חשמל חייבים לבדוק את הנפח כולו |
ext3 | יומן (journal) שהוצמד למבנה של ext2 | מצביע נפרד לכל בלוק, ותקרות נמוכות יחסית לנפח ולקובץ |
ext4 | extents, הקצאה מאוחרת, תקרות גבוהות בהרבה וביצועים טובים יותר | אין דחיסה שקופה ואין תמונות מצב (snapshots) |
כמה מונחים יחזרו לאורך הפרק, ולכן כדאי להכיר אותם כבר עכשיו. כל אחד מהם יוסבר לעומק בהמשך:
- inode: רשומה בדיסק שמתארת קובץ אחד, עם הגודל, ההרשאות והמקום של הנתונים שלו. שם הקובץ אינו חלק ממנה.
- extent: רשומה שמתארת טווח של בלוקים צמודים, בערך 'מבלוק כך וכך, כל כך בלוקים', במקום לפרט בלוק אחר בלוק.
- superblock: הרשומה הכללית של מערכת הקבצים, עם גודל הבלוק, מספר הבלוקים וה-inodes והמצב הנוכחי.
- RAID: חיבור של כמה כוננים פיזיים כך שהנתונים נשמרים בעותקים או עם יתירות, והמערכת שורדת תקלה בכונן אחד.
אל תניחו ש-ext4 נבחרת בכל התקנה. הפצות ממשפחת RHEL מגרסה 7 ואילך מתקינות כברירת מחדל את XFS, ו-Fedora Workstation מתקינה את btrfs.
חשוב להבחין גם בין ext4 לבין שני דברים שנשמעים קרובים. מערכות קבצים רשתיות כמו NFS ו-SMB נותנות למחשבים לגשת לתיקיות שיושבות על שרת אחר, ואזור swap הוא מקום שבו הליבה מחזיקה דפי זיכרון כשה-RAM מלא. ext4 מנהלת קבצים ותיקיות על התקן שמחובר למחשב עצמו, ותו לא.
כדי לראות אילו מערכות מחוברות ובאילו אפשרויות, מסננים את הפלט של mount. בדוגמה החיבור הוא של קובץ תמונה דרך התקן loop, שמתנהג כמו דיסק (האפשרות -o loop נחוצה רק בגלל זה):
mount -o loop ledger.img /srv/ledger
mount | grep ledger/root/lab/ledger.img on /srv/ledger type ext4 (rw,relatime)בסוגריים מופיעות אפשרויות החיבור. אין שם data=, וזה אומר שמצב היומן הוא ברירת המחדל ordered. בליבות ישנות יותר הפלט כולל את data=ordered במפורש.
טעויות נפוצות
ext4מאפשרת לכמה שרתים לעבוד יחד על תיקייה משותפת. שיתוף כזה נעשה בעזרת NFS או SMB.ext4שייכת למחשב אחד ולכונן שמחובר אליו.ext4קיימת עוד מימי FAT32: אין בה יומן והיא נעצרת ב-4 GB לקובץ. זה תיאור של FAT32. ב-ext4יש יומן, וקובץ בודד יכול להגיע ל-16 TiB כשהבלוק הוא 4 KiB.- כשה-RAM נגמר,
ext4משמשת מקום לגלוש אליו. גלישה של דפי זיכרון לדיסק היא תפקיד של אזורswap, ואילוext4מחזיקה קבצים ותיקיות. - בכל התקנה חדשה של לינוקס
ext4תהיה ברירת המחדל. זה תלוי בהפצה: RHEL מגרסה 7 בוחרת ב-XFS, ו-Fedora Workstation ב-btrfs.
בדקו את עצמכם
מה כל אחד משלושת הדורות במשפחה, ext2, ext3 ו-ext4, הוסיף?
ext2 היא הבסיס המבוסס על inodes, בלי יומן. ext3 הוסיפה יומן. ext4 הוסיפה extents, הקצאה מאוחרת, תקרות גודל גבוהות בהרבה ושיפורי ביצועים.
חבר טוען ש-ext4 היא ברירת המחדל בכל הפצה מודרנית. תנו שתי דוגמאות נגדיות.
ב-RHEL (מגרסה 7) ברירת המחדל היא XFS, ובהפצה Fedora Workstation היא btrfs.
היומן (journal): למה אחרי קריסה לא צריך לסרוק את כל הדיסק
הדמיינו שהחשמל נופל באמצע שמירה של קובץ חדש. בדיסק נשארים כמה שינויים שהספיקו להיכתב ועוד כמה שלא, והמבנה נשאר בחצי הדרך. לקובץ חדש נדרשים ארבעה עדכונים נפרדים, וכל אחד מהם, לבדו, משאיר סתירה:
| רק זה הספיק להיכתב | הסתירה שנוצרת |
|---|---|
| שם הקובץ בתיקייה | שם שמוביל לקובץ שעדיין אין לו inode או נתונים |
| הקצאת ה-inode | inode שמסומן כתפוס ואף שם בתיקייה לא מצביע אליו |
| סימון בלוקים כתפוסים | בלוקים שנחשבים תפוסים בלי שקובץ כלשהו משתמש בהם |
| כתיבת התוכן | תוכן שיושב בדיסק ואין שום inode שמתאר אותו |
במערכת בלי יומן, כמו ext2, אין לליבה דרך לדעת איזו סתירה קרתה ואיפה. לכן fsck עובר על כל המבנים של הנפח וכל פעם בודק אותם מחדש, וככל שהדיסק גדול יותר השרת נשאר מחוץ לשירות זמן ארוך יותר.
היומן (journal) פותר את זה בדרך שמזכירה פנקס כוונות: לפני שמשנים משהו במקומו האמיתי, רושמים את השינוי באזור ייעודי בדיסק. אחרי נפילה הליבה לא סורקת את הנפח אלא קוראת רק את היומן.
שינוי שנרשם עד הסוף מבוצע שוב (replay) במקומו, ושינוי שהרישום שלו נקטע מושלך כאילו לא התחיל. כך המבנה חוזר להיות עקבי תוך שניות.
ב-ext4 גם לרשומות היומן יש סכומי ביקורת (journal checksums). רשומה ביומן שנפגמה לא תעבור את הבדיקה, והליבה לא תחיל אותה ולא תפיץ את הפגיעה למערכת הקבצים.
מה היומן אינו נותן, בסדר מהחשוב לפחות חשוב:
- אין הבטחה שכל פעולה אחרונה שורדת. כתיבה שהתבצעה רגע לפני הנפילה ועוד לא נרשמה יכולה ללכת לאיבוד. היומן מבטיח מבנה עקבי, לא שהצעד האחרון נשמר.
- אין הגנה מכשל פיזי של כונן. מי שצריך עמידות כזו משתמש ב-RAID, שמחזיק את הנתונים על כמה כוננים.
- אין שחזור של קבצים שנמחקו. היומן אינו גיבוי, והוא מתעד שינויים תלויים ועומדים ולא היסטוריה.
- אין חיסכון במקום. היומן לא דוחס את תוכן הקבצים.
טעויות נפוצות
- מחקתי קובץ ב-
rmבטעות, ואפשר לשלוף אותו בחזרה מהיומן. ביומן נמצאים רק שינויים שעוד לא הושלמו. אחרי שהמחיקה הושלמה אין בו עותק של התוכן. - היומן שומר כל בלוק בשני עותקים, למקרה שהכונן יתקלקל. עותק שני על כונן אחר הוא מירור של RAID, כמו RAID 1, ולא יומן.
- עותקי הגיבוי של ה-superblock הם מה שמרים את המערכת אחרי הפסקת חשמל. העותקים האלה מועילים רק כש-superblock הראשי נפגע. אחרי נפילה רגילה היומן עושה את העבודה.
- חותמות זמן של ננו-שניות מתעדות את סדר השינויים כדי לשחזר, ו-
e4defragמחזיר עקביות. חותמות הזמן רק מדייקות את זמני הקובץ, ו-e4defragרק מאחה קבצים מפוצלים. אף אחד מהם אינו מנגנון התאוששות. - היומן דוחס את הנתונים ולכן חוסך מקום. ל-
ext4אין דחיסה שקופה, והיומן לא שייך לעניין הזה.
בדקו את עצמכם
שני שרתים נפלו באותה הפסקת חשמל. אחד על ext2 נשאר מנותק שעות בזמן ש-fsck עבד, והשני על ext4 חזר אחרי רגע. למה?
ב-ext4 השינויים נרשמים מראש, ולכן הליבה קוראת רק את היומן וסיימה בשניות. ל-ext2 אין מה לקרוא, ולכן היא נאלצת לבדוק את הנפח כולו.
בזמן הנפילה ביומן יש טרנזקציה אחת שנרשמה עד הסוף ועוד אחת שנקטעה. מה קורה לכל אחת באתחול הבא?
הטרנזקציה השלמה מבוצעת שוב (replay) במקומה, והטרנזקציה שנקטעה נזרקת.
מצבי היומן: ordered, journal ו-writeback
נניח שהוספתם 4 KB לסוף קובץ. בדיסק משתנים שני דברים: התוכן החדש עצמו, שהוא נתונים (data), ופנקס הניהול של הקובץ, שכולל את הגודל, רשימת הבלוקים, ה-inode ורשומת התיקייה, שהוא מטא-דאטה (metadata). השאלה היא מה מהם מגיע ראשון לדיסק, ומה נכנס ליומן.
את התשובה קובעת אפשרות החיבור data=, ויש לה שלושה ערכים:
| מצב | מה מגיע ראשון | מה אפשר לאבד או לראות אחרי קריסה | המחיר |
|---|---|---|---|
data=ordered (ברירת מחדל) | בלוקי התוכן נשמרים במקומם, ורק אז המטא-דאטה נרשם ביומן. ביומן עצמו יש מטא-דאטה בלבד | כתיבה אחרונה שלא הספיקה פשוט חסרה. הקובץ אף פעם לא מצביע על בלוקים עם תוכן זר | ביצועים טובים, ולכן זו ברירת המחדל |
data=journal | התוכן והמטא-דאטה נרשמים שניהם ביומן, ורק אז מועתקים למקומם הסופי | ההגנה הגבוהה ביותר על התוכן, כי הכתיבה כולה נשמרת או נזרקת כיחידה אחת | האיטי ביותר: לכל בלוק יש עותק ביומן ועותק ביעד, כלומר כפל בנפח הכתיבה |
data=writeback | אין סדר מובטח, והמטא-דאטה עלול להיכנס ליומן לפני שהתוכן הגיע לבלוקים שלו | קובץ שגדל עלול להציג בקצה שלו תוכן ישן שישב באותם בלוקים קודם | המהיר ביותר |
חשוב לזכור שבכל אחד משלושת המצבים היומן עובד ורושם מטא-דאטה. לכן המבנה עצמו, כלומר תיקיות, inodes וגדלים, חוזר עקבי אחרי קריסה בכל שלושתם, בלי fsck מלא, והוויכוח הוא רק על התוכן של קבצים שנכתבו ממש לפני הכיבוי.
בוחרים מצב בעזרת אפשרות חיבור, בפקודה או בקובץ /etc/fstab. הדוגמה מחברת את אותה מערכת במצב data=journal ומציגה מה mount מדפיס:
mount -o loop,data=journal ledger.img /srv/ledger
mount | grep ledger/root/lab/ledger.img on /srv/ledger type ext4 (rw,relatime,nodioread_nolock,nodelalloc,data=journal)האפשרויות הנוספות בפלט, כמו nodelalloc, הן התאמות שהליבה עושה בעצמה במצב הזה. הגדרה קבועה נראית כך בשורת /etc/fstab:
/dev/sdb1 /srv/ledger ext4 defaults,data=journal 0 2שורת mount ללא data= כלל פירושה שרצה ברירת המחדל data=ordered. noatime היא אפשרות מעולם אחר: היא מונעת מהליבה לרשום את שעת הקריאה האחרונה בכל גישה לקובץ, וכך חוסכת כתיבות, ואינה משפיעה על מה שהיומן מגן עליו.
תרחיש 8: תוכן זר בסוף קובץ אחרי הפסקת חשמל
בבוקר אחרי הפסקת חשמל מנהלת מערכת מגלה שבסוף orders.csv יש שורות שנראות כמו קטע מייצוא ישן. השרת עלה מהר ובלי fsck מלא, ובשורת ה-/etc/fstab של המחיצה רשום defaults,data=writeback.
הקובץ הורחב ברגע שלפני הנפילה, וזה מה שקרה לפי הסדר:
- המערכת הקצתה לקובץ את בלוק 8800, שהחזיק בעבר תוכן של קובץ שנמחק.
- המטא-דאטה, עם הגודל החדש וההפניה לבלוק 8800, נרשם ביומן ואושר.
- החשמל נפל לפני שהתוכן החדש נכתב לבלוק 8800.
- בהפעלה הבאה היומן שוחזר: הגודל והבלוק כבר חלק מהקובץ, והתוכן שנקרא הוא מה שישב שם קודם.
תוצאות המצבים השונים על אותה נפילה:
ordered: שלב 2 לא יכול להקדים את כתיבת התוכן, ולכן הסוף החדש פשוט לא מופיע, והקובץ נקי מתוכן זר.journal: התוכן והמטא-דאטה נשמרים או נזרקים יחד, וזה מה שמתאים כשצריך את ההגנה המרבית על התוכן, במחיר כתיבה איטית יותר.writeback: זה מה שקרה כאן, מבנה תקין אבל תוכן שנשאר מהעבר.
טעויות נפוצות
- ב-
writebackהיומן כבוי, ולכן אחרי נפילה צריךfsckמלא. המטא-דאטה נכנס ליומן בכל שלושת המצבים, ולכן המבנה חוזר עקבי בלי סריקה מלאה. מה שאינו מובטח הוא רק הסדר שבו התוכן נכתב. - ב-
writebackה-inode או רשומת התיקייה עלולים להיפגע, כי המטא-דאטה לא מתועד. ה-inode, הגודל ורשומות התיקייה הם מטא-דאטה, והם נרשמים ביומן. הסיכון הוא רק בתוכן של בלוקים שהוקצו לאחרונה. - ב-
orderedגם תוכן הקבצים עובר דרך היומן. ב-orderedביומן יש מטא-דאטה בלבד, ומה שמיוחד בו הוא ההתחייבות לכתוב את התוכן קודם. רקdata=journalמעביר את התוכן ביומן. - ב-
writebackהתוכן והמטא-דאטה נרשמים ביומן יחד. זו התנהגות שלdata=journal. ב-writebackנרשם מטא-דאטה בלבד, בלי התחייבות לסדר. noatimeשומרת על התוכן של הקבצים כשהחשמל נופל. היא רק חוסכת עדכוני זמן גישה, ואין לה קשר לשיטת הרישום ביומן.
בדקו את עצמכם
בשורת mount אין data= בכלל. מה זה אומר על המצב, מה נרשם ביומן ומה מובטח לגבי סדר הכתיבה?
המצב הוא ברירת המחדל ordered. ביומן נרשם מטא-דאטה בלבד, ומובטח שבלוקי התוכן נכתבים לפני המטא-דאטה שמצביע אליהם.
אילו שני מצבים מונעים תוכן זר בסוף קובץ שהורחב, ומה המחיר של כל אחד?
ordered מבטל אותה במחיר קטן מאוד, כי התוכן נכתב לפני המטא-דאטה. journal מבטל אותה במחיר כתיבה כפולה.
איזה מצב כותב כל בלוק תוכן פעמיים, ולאן?
data=journal: פעם אחת ליומן ופעם אחת למקומו הסופי במערכת הקבצים.
מה ext4 שיפרה לעומת ext3
בואו נתחיל מהמחיר של קובץ גדול. קובץ של 1 GiB בבלוקים של 4 KiB מורכב מ-262,144 בלוקים, וב-ext3 ה-inode צריך מצביע נפרד לכל אחד מהם, וכשהקובץ גדול גם בלוקים עקיפים (indirect blocks) שכל תוכנם מצביעים. כך תיאור של קובץ אחד גדל לכמה מאות אלפי רשומות.
ext4 מחליפה את זה ב-extents: רשומה אחת אומרת, למשל, 'החל מבלוק 120000, שלושים אלף בלוקים ברצף'. כשיש הרבה טווחים הם מסודרים בעץ שנקרא extent tree. התיאור קצר בהרבה, הגישה לקובץ גדול מהירה יותר, ו-ext4 גם מעדיפה להקצות לקובץ בלוקים צמודים, מה שמקטין את הפיצול (fragmentation).
אפשר לראות את זה על קובץ אמיתי. בדוגמה נכתב קובץ של 1 GiB לתוך מערכת ext4 חדשה, והכלי filefrag מציג איך הוא מפוזר בדיסק (בין שתי הפקודות בוצע sync, ושורות הסטטיסטיקה ש-dd מדפיס ל-stderr הושמטו מהפלט):
dd if=/dev/zero of=/srv/ledger/dump.bin bs=1M count=1024
sync
filefrag -v /srv/ledger/dump.binFilesystem type is: ef53
File size of /srv/ledger/dump.bin is 1073741824 (262144 blocks of 4096 bytes)
ext: logical_offset: physical_offset: length: expected: flags:
0: 0.. 63487: 34816.. 98303: 63488:
1: 63488.. 126975: 100352.. 163839: 63488: 98304:
2: 126976.. 190463: 165888.. 229375: 63488: 163840:
3: 190464.. 253951: 231424.. 294911: 63488: 229376:
4: 253952.. 262143: 296960.. 305151: 8192: 294912: last,eof
/srv/ledger/dump.bin: 5 extents foundfilefrag מדווח על חמישה טווחים, אבל הוא ממזג טווחים סמוכים. ברשומות שעל הדיסק המספר גדול יותר, לפחות שמונה, כי רשומה אחת מכילה לכל היותר 32768 בלוקים, ועדיין זה זעום לעומת מעל 260,000 המצביעים ש-ext3 הייתה צריכה.
השיפור הגדול השני הוא הקצאה מאוחרת (delayed allocation). נניח שתוכנה כותבת קובץ במאה קריאות write קטנות. אם הליבה בוחרת בלוקים בכל קריאה, הבחירות מתפזרות, ואילו כשהיא ממתינה לשטיפה, כבר ידוע כמה נתונים נאספו והיא בוחרת להם מקום אחד רציף בפעולה אחת.
| הקצאה מיידית | הקצאה מאוחרת | |
|---|---|---|
| מתי נבחרים הבלוקים | בכל קריאת write | ברגע ששוטפים את הנתונים לדיסק |
| מה הליבה יודעת בשלב הבחירה | רק את הקטע שנכתב כרגע | את כל מה שנאסף עד עכשיו |
| התוצאה בדיסק | סיכוי גבוה יותר לפיצול | טווח רציף וכתיבות מעטות יותר |
| הסיכון | אין | כתיבות אחרונות שעוד לא נשטפו עלולות לאבוד בקריסה |
רשימת השיפורים הנוספים:
- מקצה מרובה בלוקים (multiblock allocator): מקצה כמה בלוקים בבת אחת, במקום להקצות כל בלוק לחוד.
- הקצאה מראש מתמשכת (persistent preallocation, עם
fallocate): שומרת לקובץ שטח מראש, ומנסה להשיג אותו רציף, בלי לכתוב לתוכו אפסים. - חותמות זמן: דיוק של ננו-שניות ותמיכה בתאריכים אחרי שנת 2038, כש-inode בגודל 256 בתים.
- בדיקה מהירה יותר:
fsckמדלג על אזורים שאיש לא השתמש בהם, כמו קבוצות בלוקים וטבלאות inodes ריקות. - איחוי בזמן עבודה:
e4defragמסדר מחדש קבצים שהתפזרו לחתיכות, בלי לנתק את המערכת.
התקרות השתנו גם הן. הערכים מתייחסים לבלוקים של 4 KiB:
| מגבלה | ext3 | ext4 |
|---|---|---|
| גודל מערכת הקבצים | 16 TiB | 1 EiB |
| גודל קובץ בודד | 2 TiB | 16 TiB |
| מספר תתי-תיקיות בתיקייה | 32,000 | אין את המגבלה הזו |
ומה ext4 לא כוללת, גם אם מערכות קבצים אחרות כוללות?
| יכולת | המצב ב-ext4 |
|---|---|
| דחיסה שקופה ותמונות מצב (snapshots) | אין. את אלה מציעות מערכות כמו btrfs ו-ZFS |
| הגדלה אוטומטית של מספר ה-inodes | אין. המספר נקבע פעם אחת, בעת היצירה |
| היכן נשמר שם הקובץ | ברשומת התיקייה, ולא ב-inode |
| מבנה בסיסי | עדיין inodes. אין מעבר ל-B-tree כמו ב-NTFS, וגם לא לטבלת אשכולות מרכזית כמו ב-FAT |
| רישום תוכן הקבצים ביומן | לא בברירת המחדל, שרושמת רק מטא-דאטה |
תרחיש 9: העתקת גיבוי של 20 GiB
מנהל מערכת מעתיק קובץ גיבוי של 20 GiB אל מחיצה שפורמטה זה עתה כ-ext4, בלי לשנות אף הגדרה. הנה מה שקורה בשלבים:
- תוכנת ההעתקה כותבת הרבה מקטעים קטנים, והליבה לא בוחרת להם בלוקים מיד אלא מחזיקה אותם בזיכרון.
- כשהנתונים נשטפים לדיסק, ההקצאה כבר רואה כמה מקום הקובץ דורש ובוחרת טווחים רציפים ארוכים.
- ב-inode ובעץ נרשמות רשומות extent, כל אחת עם בלוק התחלה ואורך, ומספרן קטן בהרבה ממספר הבלוקים.
הספירה: 20 GiB בבלוקים של 4 KiB הם 5,242,880 בלוקים. ב-ext3 כל אחד מהם היה צריך מצביע, ואילו ב-FAT יש טבלה מרכזית אחת, שמקצה שורה לכל אשכול (cluster) של המחיצה, שיטה אחרת לגמרי.
טעויות נפוצות
ext4נסוגה מ-extents חזרה למצביעים עקיפים. הכיוון הפוך:ext3השתמשה במצביעים ישירים ועקיפים, ו-ext4החליפה אותם ב-extents.- מי שמתאר את הקובץ כטווחים רציפים הוא
delayed allocation. את הטווחים מתאר ה-extent tree.delayed allocationהיא דחיית הבחירה של הבלוקים עד רגע השטיפה. - את מיקום הנתונים
ext4שומרת בקובץ נפרד בתוך היומן. המיקום נמצא ב-inode ובעץ ה-extents. היומן הוא מנגנון אחר לגמרי. journal checksumמקטין פיצול. סכום הביקורת מגן על היומן מפני רשומות פגומות, ואינו משפיע על פריסת הקבצים.- גודל הבלוק ברירת המחדל הוא 64 KB. ברירת המחדל היא 4 KiB.
ext4מאיצה כתיבה על ידי כתיבה סינכרונית מיידית של כל בלוק. כתיבה סינכרונית מאטה. השיפור מגיע דווקא מהקצאה מאוחרת.ext4תומכת בדחיסה שקופה, ב-snapshots או בהגדלת מספר ה-inodes תוך כדי עבודה. אלה יכולות שלbtrfsו-ZFS. ב-ext4מספר ה-inodes קבוע מרגע היצירה.
בדקו את עצמכם
במה שונים extent tree ו-delayed allocation, ואיזו בעיה פותר כל אחד מהם?
extent tree הוא מבנה שמתאר את מיקום הקובץ כטווחים רציפים. delayed allocation היא תזמון: בחירת הבלוקים נדחית עד לשטיפה לדיסק.
מהי התקרה לגודל קובץ בודד ב-ext3 ובאיזו תקרה עלתה ext4, בבלוקים של 4 KiB?
ב-ext3 עד 2 TiB, וב-ext4 עד 16 TiB.
תאימות בין ext2, ext3 ו-ext4: מי מחבר את מי
הכלל קצר: מערכת חדשה יודעת לעבוד עם מבנה ישן, אבל מערכת ישנה לא מכירה את התכונות של החדשה. התאימות במשפחת ext היא לכן חד-כיוונית.
בכיוון הראשון, מערכת ext3 או ext2 שכבר קיימת ניתנת לחיבור דרך הדרייבר של ext4, לקריאה ולכתיבה, בלי פרמוט ובלי המרת נתונים. הדוגמה הבאה מחברת קובץ תמונה של ext3 כ-ext4, כותבת אליו, מנתקת, בודקת אילו תכונות הוא מכיל (שורת הגרסה ש-dumpe2fs מדפיס ל-stderr הושמטה) ומחברת אותו שוב כ-ext3:
mount -t ext4 -o loop legacy.img /srv/legacy && echo 'mounted as ext4'
echo 'ledger 2026' > /srv/legacy/note.txt
umount /srv/legacy
dumpe2fs -h legacy.img | grep 'Filesystem features'
mount -t ext3 -o loop legacy.img /srv/legacy && cat /srv/legacy/note.txtmounted as ext4
Filesystem features: has_journal ext_attr resize_inode dir_index filetype sparse_super large_file
ledger 2026ברשימת התכונות אין extent, כלומר החיבור כ-ext4 לא שינה דבר בדיסק. לכן אפשר לחזור ולחבר אותו כ-ext3, והקובץ שנכתב בינתיים קריא. המרה אמיתית דורשת צעד מכוון בעזרת tune2fs שמפעיל את התכונות החדשות.
הכיוון ההפוך נכשל. מערכת שנוצרה עם mkfs.ext4 רושמת מיקומי בלוקים ב-extents, ו-ext3 לא מכירה את המבנה הזה:
mount -t ext3 -o loop fresh.img /srv/legacy
dmesg | tail -1mount: /srv/legacy: wrong fs type, bad option, bad superblock on /dev/loop0, missing codepage or helper program, or other error.
[ 34.959459] EXT4-fs (loop0): couldn't mount as ext3 due to feature incompatibilitiesהודעת הליבה מצביעה על הסיבה: אי-התאמה בתכונות של מערכת הקבצים, ולא למשל על יומן חסר.
תרחיש 10: שני כוננים ושני שרתים
בחברה יש שרת חדש ושרת ישן. כונן ארכיון ישן עם מערכת ext3 וכונן חדש שמפורמט עם mkfs.ext4 עוברים בין השרתים, והנה כל המקרים:
| הכונן | מי מחבר אותו | התוצאה | הסיבה |
|---|---|---|---|
ארכיון ישן (ext3) | השרת החדש, כ-ext4 | מצליח, קריאה וכתיבה | הדרייבר של ext4 מכיר את המבנה הישן |
| אותו ארכיון, אחרי שחזר | השרת הישן, כ-ext3 | מצליח | החיבור הקודם לא הפעיל שום תכונה של ext4 |
כונן חדש (mkfs.ext4) | השרת החדש, כ-ext4 | מצליח | הדרייבר מכיר את המבנה שהכלי mkfs.ext4 יצר |
| אותו כונן חדש | השרת הישן, כ-ext3 | נכשל | הוא משתמש ב-extents, ש-ext3 לא יודעת לקרוא |
טעויות נפוצות
- כדי לחבר
ext3כ-ext4צריך קודם למחוק אותה וליצור מחדש. היא מתחברת כפי שהיא, עם כל הנתונים. - אחרי חיבור כ-
ext4המערכת הקודמת הופכת לקריאה בלבד. הכתיבה פתוחה כרגיל, כמו שהראתה הדוגמה. - החיבור כ-
ext4ממיר את המערכת באופן סופי, ואז אי אפשר לחזור ל-ext3. שום תכונה חדשה לא מופעלת בחיבור. המרה היא פעולה יזומה בעזרתtune2fs. - אפשר לחבר
ext4רגילה כ-ext3, כיext3תתרגם את ה-extents תוך כדי עבודה.ext3לא מכירה extents ואינה מתרגמת אותם. התאימות פועלת בכיוון אחד בלבד. - החיבור כ-
ext3נכשל כי חסר יומן. ל-ext4יש יומן כברירת מחדל. הכשל נובע ממבנה ה-extents.
בדקו את עצמכם
האם מערכת ext3 מתחברת כ-ext4, והאם מערכת שנוצרה עם mkfs.ext4 מתחברת כ-ext3?
הראשונה כן, בלי המרה. השנייה לא, כי היא משתמשת ב-extents.
הכלים של e2fsprogs: mkfs.ext4, e2fsck, tune2fs ואחרים
כל הכלים בחלק הזה מגיעים מהחבילה e2fsprogs, והם מכסים את כל מחזור החיים של מערכת קבצים ממשפחת ext: יצירה, בדיקה, כוונון ושינוי גודל.
| פקודה | מה היא עושה | מה חשוב לדעת עליה |
|---|---|---|
mkfs.ext4 (או mkfs -t ext4) | בונה מערכת קבצים חדשה וריקה בתוך מחיצה | מה שהיה במחיצה מפסיק להיות נגיש. היא לא בודקת, לא ממירה, לא מגדילה ולא מוסיפה יומן למערכת קיימת |
e2fsck (או fsck.ext4) | סורק את מערכת הקבצים ומתקן סתירות | מריצים אותה על מערכת מנותקת. -f מכריחה בדיקה מלאה גם כשהמערכת מסומנת כתקינה |
tune2fs | משנה הגדרות של מערכת קבצים קיימת | -m אחוז שמור ל-root, -L תווית, -c ו--i מרווחי בדיקה, -l הצגת פרטי ה-superblock. הוא לא משנה גודל |
dumpe2fs | מדפיס את ה-superblock ופרטים על קבוצות הבלוקים | -h מציג את ה-superblock בלבד. הוא רק קורא |
resize2fs | משנה את גודל מערכת הקבצים | -P רק מעריך את הגודל המזערי להקטנה ואינו משנה דבר |
debugfs | עיון ועריכה במבנים של מערכת הקבצים ברמה נמוכה | כלי למומחים |
e4defrag | מסדר מחדש קבצים שהתפזרו לחתיכות | אפשר להריץ אותו בזמן שהמערכת מחוברת ופעילה |
שתי ברירות מחדל חוזרות הרבה בשאלות. הראשונה: 5% מהבלוקים שמורים ל-root, כך שגם כשהדיסק מלא מבחינת המשתמשים, שירותי המערכת עדיין מצליחים לכתוב. את האחוז משנים עם tune2fs -m.
השנייה: מספר ה-inodes נקבע ברגע היצירה. mkfs.ext4 -i קובע כמה בתים של שטח מקבלים inode אחד, ו--N קובע ישירות כמה inodes ייווצרו, ואחר כך המספר קבוע.
בדוגמה נוצרת מערכת של 256 MiB עם תווית, ואז מציגים את פרטיה ומשנים את האחוז השמור:
mkfs.ext4 -q -L reports q.img
tune2fs -l q.img | grep -E 'volume name|Inode count|Block size|Reserved block count'
tune2fs -m 1 q.img
tune2fs -l q.img | grep 'Reserved block count'Filesystem volume name: reports
Inode count: 65536
Reserved block count: 3276
Block size: 4096
tune2fs 1.46.5 (30-Dec-2021)
Setting reserved blocks percentage to 1% (655 blocks)
Reserved block count: 6553276 מתוך 65536 הבלוקים הם 5%, ואחרי -m 1 נשאר אחוז אחד בלבד. אפשר לקבוע את מספר ה-inodes ביצירה, וזה מה שמתקבל עם mkfs.ext4 -N 2000 על מערכת קטנה:
mkfs.ext4 -q -N 2000 n.img
tune2fs -l n.img | grep 'Inode count'Inode count: 2000הכנת דיסק חדש מורכבת משלושה שלבים, ולכל אחד כלי משלו:
fdiskיוצר מחיצה בטבלת המחיצות, ועדיין אין בה מערכת קבצים.mkfs.ext4בונה בתוך המחיצה את מערכת הקבצים.mountמחבר את המערכת שכבר קיימת לעץ התיקיות, ואינו יוצר אותה.
תרחיש 11: פרמוט של המחיצה הלא נכונה
מנהל מערכת רצה לפרמט כונן USB חדש, אבל מקלידה בטעות את שם המחיצה של כונן אחר, זה שמכיל קבצי פרויקט ואינו מחובר כרגע. הכלי mkfs.ext4 לא ישאל הרבה: לפעמים הוא מבקש אישור כשהוא מזהה מערכת קיימת, אבל עם -F או בסקריפט הוא ממשיך בלי לשאול, ואי אפשר להסתמך על האזהרה.
הקוד הבא מדמה את המקרה על קובץ תמונה: קובץ אחד נכתב, אחר כך מריצים עליו mkfs.ext4, ובודקים מה נשאר:
mount -o loop vault.img /srv/vault
echo 'q3 report' > /srv/vault/report.txt
ls /srv/vault
umount /srv/vault
mkfs.ext4 -q -F vault.img
mount -o loop vault.img /srv/vault
ls -A /srv/vault
ls -A /srv/vault/lost+found | wc -llost+found
report.txt
lost+found
0הקובץ נעלם מהעץ. גם lost+found החדשה ריקה, כי mkfs.ext4 לא מעבירה לשם דבר: מערכת חדשה נבנתה מאפס, והישנה כבר אינה נגישה. לפני פרמוט מאמתים את שם ההתקן עם lsblk או blkid.
טעויות נפוצות
mkfs.ext4שומרת על הקבצים, ממירה מערכת קיימת או מעבירה אותם ל-lost+found. היא בונה מערכת ריקה. המרה נעשית עםtune2fs, ו-lost+foundמשמשת אתe2fsckלשמירת מקטעים שנמצאו.mkfs.ext3יוצרתext4, או ש-fsck.ext4ו-mount -t ext4יוצרות מערכת קבצים.mkfs.ext3יוצרתext3.fsck.ext4בודקת ומתקנת, ו-mountרק מחברת מערכת שכבר קיימת.resize2fs -Pאוdumpe2fs -hמתקנות שגיאות.resize2fs -Pרק מדווחת על הגודל המזערי, ו-dumpe2fs -hרק מדפיסה את ה-superblock.mkfs.ext4מדפיסה את גודל הבלוק ואת מספר ה-inodes של מערכת קיימת, או מותחת אותה עד סוף המחיצה. הצגת פרטים היא שלtune2fs -lאוdumpe2fs -h, והגדלה היא שלresize2fs.
בדקו את עצמכם
אתם רוצים רק להציץ בגודל הבלוק ובמספר ה-inodes של /dev/vdc1, בלי שום סיכון לשינוי. מה מריצים?
אחת משתי פקודות קריאה בלבד: tune2fs -l /dev/vdc1 או dumpe2fs -h /dev/vdc1.
המחיצה /dev/vdc1 מנותקת ומסומנת כתקינה, ובכל זאת אתם רוצים סריקה מלאה. מה מריצים?
e2fsck -f /dev/vdc1, כי הדגל -f כופה את הסריקה.
שינוי גודל מערכת קבצים עם resize2fs
הגדלתם מחיצה בכלי המחיצות, אבל df -h ממשיך להציג את הגודל הישן. הסיבה היא שמחיצה ומערכת הקבצים שבתוכה הן שתי ישויות נפרדות, ושינוי של הראשונה לא נוגע בשנייה.
resize2fs שמורץ בלי ארגומנט של גודל מותח את המערכת עד קצה המחיצה. בדוגמה הקובץ שמאחורי ההתקן הוגדל קודם, ואז הופעל resize2fs על מערכת מחוברת, ופלט df מראה את ההפרש. פקודות truncate ו-losetup -c שהגדילו את ההתקן הושמטו מהדוגמה:
df -h /srv/grow | tail -n 1
resize2fs /dev/loop1
df -h /srv/grow | tail -n 1/dev/loop1 56M 24K 52M 1% /srv/grow
resize2fs 1.46.5 (30-Dec-2021)
Filesystem at /dev/loop1 is mounted on /srv/grow; on-line resizing required
old_desc_blocks = 1, new_desc_blocks = 1
The filesystem on /dev/loop1 is now 32768 (4k) blocks long.
/dev/loop1 120M 24K 116M 1% /srv/growאת ההגדלה אפשר לעשות תוך כדי עבודה: ext4 מתרחבת בעודה מחוברת (online), ואין צורך ב-umount. את ההקטנה אפשר לעשות רק על מערכת שאינה מחוברת (offline), וניסיון להקטין מערכת מחוברת נדחה (זו הרצה נפרדת, על התקן אחר):
resize2fs /dev/loop0 40Mresize2fs 1.46.5 (30-Dec-2021)
Filesystem at /dev/loop0 is mounted on /srv/grow; on-line resizing required
resize2fs: On-line shrinking not supportedהסדר הנכון להקטנה הוא ניתוק, בדיקה ורק אז שינוי הגודל:
umountשל המערכת.e2fsck -fעל ההתקן, כדי לוודא שהמערכת תקינה לפני שמזיזים נתונים.resize2fsעם הגודל החדש.- רק בסוף מקטינים את המחיצה עצמה, ולעולם לא מתחת לגודל שנשאר למערכת הקבצים.
אם מדלגים על הבדיקה, resize2fs יסרב ויבקש להריץ אותה קודם. הוא דורש זאת כשהמערכת שומשה (למשל חוברה) מאז הבדיקה המלאה האחרונה שלה, וזה המצב הרגיל. בדוגמה החיבור קרה אחרי היצירה, ולכן הבקשה הופיעה:
resize2fs s.img 40M
e2fsck -f s.img
resize2fs s.img 40Mresize2fs 1.46.5 (30-Dec-2021)
Please run 'e2fsck -f s.img' first.
e2fsck 1.46.5 (30-Dec-2021)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
s.img: 12/16384 files (8.3% non-contiguous), 2066/16384 blocks
resize2fs 1.46.5 (30-Dec-2021)
Resizing the filesystem on s.img to 10240 (4k) blocks.
The filesystem on s.img is now 10240 (4k) blocks long.גם resize2fs משנה רק את נפח מערכת הקבצים. גודל הבלוק נקבע ביצירה ולא משתנה, ואת התווית משנים עם tune2fs -L.
תרחיש 12: הגדלה בזמן עבודה והקטנה בחלון תחזוקה
בשרת קבצים הוגדלה המחיצה /dev/vdb1 מ-150 GB ל-300 GB, אבל df -h /srv/files עדיין מציג 150. מנהל המערכת מריץ resize2fs /dev/vdb1 בלי לעצור את השירות, ותוך שניות df -h מציג 300 GB.
הוא לא צריך כאן e2fsck -f, כי זה כלי בדיקה ולא מגדיל, וגם לא tune2fs -l, שרק מציג, ובוודאי לא mkfs.ext4, שהייתה מוחקת את הכול.
בשבוע שאחרי כן הוא צריך להקטין מחיצה אחרת, /dev/vdc1, מ-90 GB ל-55 GB. הפעם הוא מתאם חלון תחזוקה, מנתק את המחיצה, מריץ e2fsck -f ורק אחרי זה resize2fs /dev/vdc1 55G.
טעויות נפוצות
- אפשר להקטין מערכת
ext4מחוברת, ולהריץe2fsck -fאחרי ההקטנה. הקטנה אפשרית רק על מערכת מנותקת, והבדיקה צריכה להקדים אתresize2fs. - אפשר להריץ את
resize2fsלהקטנה ורק אחר כך לנתק. ההקטנה דורשת מערכת מנותקת מראש, והשגיאה בדוגמה לעיל מראה מה קורה אחרת. - את גודל מערכת הקבצים משנים עם
tune2fs.tune2fsמכוון הגדרות כמו תווית ואחוז שמור, ושינוי גודל הוא עבודה שלresize2fs. resize2fsיכול לשנות גם את גודל הבלוק או את התווית. גודל הבלוק קבוע מהיצירה, ואת התווית משנים עםtune2fs -L.
בדקו את עצמכם
מערכת ext4 מחוברת ל-/data ופעילה. איזה שינוי גודל resize2fs מסוגל לבצע בה עכשיו, ואיזה לא?
הוא מסוגל להגדיל אותה. הוא לא יכול להקטין אותה לפני umount ובדיקה עם e2fsck -f.
ה-superblock ושחזור מעותקי הגיבוי
מה קורה כשהמידע על מערכת הקבצים עצמה נהרס? ה-superblock הוא הרשומה הראשונה שהליבה קוראת כשהיא מחברת מחיצה. היא מכילה את גודל הבלוק, את סך הבלוקים וה-inodes, את הכמות הפנויה מכל אחד ואת מצב המערכת, ואם היא פגומה החיבור נכשל.
כדי שהרשומה הזו לא תהיה נקודת כשל יחידה, מערכת הקבצים מתחלקת לקבוצות בלוקים (block groups) ועותקי גיבוי של ה-superblock נשמרים בכמה מהן. העותק הראשון יושב בתחילת הקבוצה השנייה, ולכן המיקום שלו תלוי בגודל הקבוצה, וזה תלוי בגודל הבלוק.
| גודל בלוק | בלוקים בקבוצה | העותק הראשון |
|---|---|---|
| 4 KiB (ברירת מחדל) | 32,768 | בלוק 32768 |
| 1 KiB | 8,192 | בלוק 8193 |
אפשר לראות את המיקומים האמיתיים. הכלי dumpe2fs מציג אותם, וכדאי להשוות בין שתי מערכות עם גדלי בלוק שונים (שורת הגרסה ש-dumpe2fs מדפיס ל-stderr הושמטה מהפלט):
dumpe2fs sb4.img | grep 'Backup superblock'
dumpe2fs sb1.img | grep 'Backup superblock' Backup superblock at 32768, Group descriptors at 32769-32769
Backup superblock at 8193, Group descriptors at 8194-8194
Backup superblock at 24577, Group descriptors at 24578-24578בשורה הראשונה הבלוק הוא 4 KiB והעותק הראשון ב-32768. בשתי השורות האחרונות הבלוק הוא 1 KiB, והעותק הראשון ב-8193 והשני ב-24577.
כש-superblock הראשי פגום, מנתקים את המחיצה ומפנים את e2fsck לעותק בעזרת -b. בדוגמה מאפסים בכוונה את ה-superblock הראשי של תמונה ניסיונית (שורות הסטטיסטיקה של dd הושמטו מהפלט), ובודקים איך -n מתנהג לעומת -y:
dd if=/dev/zero of=sb4.img bs=1024 seek=1 count=1 conv=notrunc
mount -o loop sb4.img /srv/vault
e2fsck -fn -b 32768 sb4.img
e2fsck -fy -b 32768 sb4.img
mount -o loop sb4.img /srv/vault && echo mounted-okmount: /srv/vault: wrong fs type, bad option, bad superblock on /dev/loop0, missing codepage or helper program, or other error.
e2fsck 1.46.5 (30-Dec-2021)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
Inode bitmap differences: Group 1 inode bitmap does not match checksum.
IGNORED.
sb4.img: ********** WARNING: Filesystem still has errors **********
sb4.img: 11/65536 files (0.0% non-contiguous), 8268/65536 blocks
e2fsck 1.46.5 (30-Dec-2021)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
Inode bitmap differences: Group 1 inode bitmap does not match checksum.
FIXED.
sb4.img: ***** FILE SYSTEM WAS MODIFIED *****
sb4.img: 11/65536 files (0.0% non-contiguous), 8268/65536 blocks
mounted-okהחיבור הראשון נכשל כי ה-superblock הראשי פגום. ההרצה עם -n רק דיווחה על הבעיות, כי כל תיקון נדחה, והמערכת נשארה במצבה. ההרצה עם -y תיקנה, כולל ה-superblock הראשי, והחיבור אחריה הצליח.
שורות ה-bitmap בפלט הן תופעת לוואי רגילה של עבודה עם תיאורי הקבוצות מהגיבוי, ולא נזק נוסף.
בגרסאות חדשות e2fsck מנסה לבדוק עותקי גיבוי גם בלי שמבקשים, והאפשרות -b משמשת לבחירה ידנית של עותק מסוים.
תרחיש 13: מחיצת ארכיון שלא מתעגנת
אחרי תקלת חומרה, החיבור של /dev/vde1 נכשל, ו-e2fsck רגיל מתלונן על superblock לא תקין. בגרסאות חדשות הוא מנסה גיבוי בעצמו, אבל מנהלת המערכת לא רוצה להסתמך על ניסיון אוטומטי ובוחרת עותק בעצמה. היא יודעת שהמחיצה פורמטה בבלוקים של 4 KiB, ולכן היא מחפשת עותק בבלוק 32768.
היא מנתקת את המחיצה אם היא מחוברת ומריצה e2fsck -b 32768 /dev/vde1. הכלי קורא את העותק ומשחזר ממנו את המערכת ואת ה-superblock הראשי.
אם הייתה מריצה -b 8193, הכלי היה מחפש עותק במקום שמתאים לבלוקים של 1 KiB, ושם במערכת הזו אין superblock. ואם הייתה מוסיפה -n, הבדיקה הייתה רק מדווחת ולא מתקנת.
טעויות נפוצות
- העותק הראשון של ה-superblock תמיד נמצא בבלוק 8193. 8193 שייך למערכת עם בלוק של 1 KiB. כשהבלוק הוא 4 KiB, העותק הראשון יושב בבלוק 32768.
e2fsck -nמתקן שגיאות בלי לשאול שאלות.-nפירושו 'אל תשנה': כל הצעת תיקון נדחית והמערכת נפתחת לקריאה בלבד, ולכן שום דבר לא מתוקן.- עותקי הגיבוי של ה-superblock מונעים סריקה מלאה אחרי כל הפסקת חשמל. החזרה המהירה אחרי הפסקת חשמל היא עבודת היומן. העותקים נחוצים רק כשה-superblock הראשי עצמו נפגע.
בדקו את עצמכם
מחיצה מנותקת בנויה בבלוקים של 1 KiB, והרשומה הראשית של ה-superblock שלה התקלקלה. איזו פקודה משחזרת אותה מהעותק הראשון, ובאיזה בלוק הוא יושב?
e2fsck -b 8193 על התקן המחיצה. העותק הראשון יושב בבלוק 8193.
Inode: הרשומה שמתארת קובץ
מה גר ב-inode ומה נשאר מחוץ לו
שורת ls -l מציגה בעלים, הרשאות וגודל, אבל את הנתונים האלה המערכת לא שולפת מהשם של הקובץ. הם שמורים ברשומה נפרדת בדיסק שנקראת inode (קיצור של index node): במערכות ext2, ext3 ו-ext4 לכל קובץ יש רשומה אחת כזו, והיא מזוהה במספר.
דמיינו ספרייה עירונית. כרטיס הקטלוג של ספר רושם את המחבר, את מספר העמודים ואת המדף, אבל אינו מכיל את תוכן הספר, וגם לא את הכינוי שבו הקוראים מכנים אותו. ה-inode הוא הכרטיס, התוכן יושב על המדף (בלוקי הנתונים), והשמות רשומים בנפרד, בתיקיות.
| פריט | היכן הוא שמור |
|---|---|
| סוג הקובץ: רגיל, תיקייה, קישור סימבולי, התקן, FIFO או socket | ב-inode |
הרשאות (mode), למשל rw-r--r-- | ב-inode |
מזהה הבעלים UID ומזהה הקבוצה GID | ב-inode |
| הגודל בבתים ומספר הבלוקים שהוקצו | ב-inode |
מונה הקישורים (link count) | ב-inode |
ארבע חותמות הזמן (זמן היצירה, Birth, נשמר רק ב-ext4) | ב-inode |
מיקום הנתונים: מצביעי בלוקים ב-ext2 וב-ext3, extents ב-ext4 | ב-inode |
| שם הקובץ והסיומת שלו | ברשומת התיקייה שמכילה אותו |
| הנתיב המלא ושם תיקיית האב | אינם נשמרים כשדה; הם נגזרים מרשומות התיקיות לאורך העץ |
| התוכן הבינארי | בבלוקי נתונים נפרדים, וה-inode רק מצביע אליהם |
| מי מחזיק את הקובץ פתוח כרגע | בזיכרון של הליבה (נחשף תחת /proc/<PID>/fd), לא בדיסק |
שניים מהפריטים האלה הם מלכודות מוכרות. סיומת כמו .log היא סתם עוד תווים בשם, ולכן היא יושבת בתיקייה יחד איתו. ורשימת התהליכים שפתחו את הקובץ היא מצב זמני של הליבה, שאין לו מקום בדיסק.
אפשר לראות את השדות במו עיניכם. בדוגמה נוצר קובץ קטן, ההרשאות שלו נקבעות ל-640, ו-stat עם תבנית פלט מדפיסה רק שדות של ה-inode:
printf 'alpha\n' > report.md
chmod 640 report.md
stat -c 'type=[%F] mode=%a uid=%u gid=%g size=%s blocks=%b links=%h inode=%i' report.mdtype=[regular file] mode=640 uid=1000 gid=1000 size=6 blocks=8 links=1 inode=20038הגודל הוא 6 בתים, אבל blocks=8 נספר ביחידות של 512 בתים, כלומר בלוק אחד של 4 KiB: גודל ושטח מוקצה הם שני שדות נפרדים. מספר ה-inode שבסוף השורה הוא המפתח שבאמצעותו המערכת מאתרת את הרשומה.
בלי תבנית, stat מדפיס דוח מלא. שורת File: בראשו חוזרת על השם שהקלדתם (והוא לא נתון של ה-inode), שורת Device: מציינת באיזו מערכת קבצים הרשומה יושבת, ומתחתיהן באים הגודל, הבלוקים, הסוג, מספר ה-inode, Links, ההרשאות, Uid/Gid וארבע חותמות הזמן: Access, Modify, Change, Birth.
שלוש פקודות אחרות מציגות פרט אחד בלבד: ls -i מדפיסה את מספר ה-inode, du מדווחת על שטח הדיסק שהקובץ תופס, ו-file מזהה את סוג התוכן לפי הבתים הראשונים שלו.
טעויות נפוצות
- שם הקובץ, הנתיב שלו או הסיומת נשמרים ב-inode. כל אלה שייכים לשם, והשם רשום בתיקייה. בזכות ההפרדה הזו אפשר לתת לאותו קובץ כמה שמות.
- ה-inode מכיל את הנתונים של הקובץ. הוא רשומה קטנה שמצביעה לבלוקים (או ל-extents) שבהם הנתונים יושבים.
- רשימת הקבצים של תיקייה נמצאת ב-inode של התיקייה. הרשימה היא התוכן של התיקייה ויושבת בבלוקים שלה. ה-inode של התיקייה רק מצביע אליהם.
- ה-inode מתעד אילו תהליכים פתחו את הקובץ. מידע כזה חי בזיכרון של הליבה בזמן ריצה, ואין לו שדה בדיסק.
fileמדפיסה גודל וחותמות זמן.fileרק מזהה את פורמט התוכן. את הגודל ואת החותמות מדפיסהstat.
בדקו את עצמכם
מבין הפריטים הבאים: מונה הקישורים, שם תיקיית האב, מזהה הבעלים, סוג הקובץ, שם הקובץ. אילו נשמרים ב-inode?
מונה הקישורים, מזהה הבעלים וסוג הקובץ. שם הקובץ ושם תיקיית האב נגזרים מרשומות התיקיות.
בראש הדוח של stat מופיעה שורת File:. האם זה מוכיח שהשם שמור ב-inode?
לא. השורה רק מהדהדת את הנתיב שהעברתם לפקודה, והנתונים שמתחתיה נקראים מה-inode.
איפה גרים השמות, ואיך מוצאים inode
תיקייה היא קובץ שהמערכת קוראת כטבלה, ובה כל שורה מצמידה שם למספר inode. אפשר להציץ בטבלה הזו עם ls -a, ועם -i מתווספים המספרים:
mkdir proj
touch proj/main.c
mkdir proj/lib
ls -ai proj20038 .
19952 ..
20045 lib
20044 main.cהשורה . מצביעה על התיקייה עצמה, ו-.. על תיקיית האב. לכל פריט אחר יש מספר משלו, וזה כל מה שהתיקייה יודעת עליו: הרשאות וגודל נמצאים ב-inode שאליו המספר מוביל.
כך הליבה פותחת את הנתיב /srv/shop/orders.csv:
- היא מתחילה בתיקיית השורש. בכל מערכת ext זה תמיד inode מספר
2, ולכן אין צורך לחפש אותו. - היא קוראת את הבלוקים של השורש ומחפשת בהם את השורה
srv, ומוצאת את מספר ה-inode שלה. - אותה פעולה חוזרת בתוך
srvעבורshop, ואחר כך בתוךshopעבורorders.csv. - ה-inode האחרון נותן את ההרשאות ואת מיקום הנתונים, וממנו קוראים את התוכן.
הטבלה הבאה מרכזת את הפקודות שנוגעות ב-inodes, ולצידן דגלים של ls שקל לבלבל איתם:
| פקודה | מה היא מדפיסה |
|---|---|
ls -i <file> | את מספר ה-inode לצד כל שם |
ls -li <file> | את הפלט הארוך של -l, עם מספר ה-inode בתחילת כל שורה |
stat <file> | דוח מלא של כל שדות ה-inode |
find /mnt -xdev -inum <N> | את כל השמות ששייכים ל-inode מספר N, בלי לצאת ממערכת הקבצים שבה החיפוש התחיל (-xdev) |
df -i | לכל מערכת קבצים מחוברת: כמה inodes קיימים, כמה תפוסים וכמה פנויים |
ls -s | את גודל הקובץ ביחידות בלוקים, בלי מספר inode |
ls -n | בעלים וקבוצה כמספרי UID ו-GID במקום שמות |
ls -lh | גדלים קריאים לאדם, כמו 12K או 4.0M |
האות -i מופיעה בשני כלים עם משמעות שאינה קשורה: ב-grep היא מבטלת הבחנה בין אותיות גדולות לקטנות, וב-ls היא מוסיפה מספרי inode. מונה הקישורים אינו צריך דגל בכלל, כי הוא העמודה השנייה בכל שורה של ls -l.
טעויות נפוצות
- הפקודה
ls -iמראה כמה קישורים קשיחים יש לקובץ, או מה גודלו בבלוקים. היא מדפיסה אך ורק את מספר ה-inode. את הקישורים רואים בעמודה השנייה שלls -l, ואת הגודל בבלוקים עםls -s. - הדגל
-iשלlsמתעלם מהבדל בין אותיות גדולות לקטנות בשמות. התנהגות כזו שייכת ל-grep. ב-lsהדגל מוסיף מספרי inode. ls -iמוסיפה לשם גם סימני הרשאה, תאריכים וגדלים. מעבר למספר ה-inode היא אינה מוסיפה שום מידע.- מספר inode מזהה קובץ באופן חד-ערכי בכל הדיסקים של המחשב. הייחודיות חלה רק בתוך מערכת קבצים אחת. בגלל זה
find -inumנשלחת בדרך כלל יחד עם-xdev.
בדקו את עצמכם
בתוך /srv מצאתם קובץ במספר inode 4412. אילו שמות מובילים אליו, בלי לבדוק מחיצות אחרות שמחוברות לתוך /srv? איזו פקודה תריצו?
find /srv -xdev -inum 4412.
שני קבצים במחיצות שונות מציגים את אותו מספר ב-ls -i. האם הם אותו קובץ?
לא. מספרי inode נספרים בנפרד בכל מערכת קבצים, ולכן התאמה בין מחיצות אינה מעידה על אותו קובץ.
ארבע חותמות הזמן: מה מזיז כל אחת
לכל inode יש ארבע חותמות זמן, ו-stat מדפיס את כולן. הדרך הטובה להבין מה מזיז כל אחת היא להפעיל פעולה אחת בכל פעם ולמדוד מה זז. בדוגמה כל חותמת נמדדת בשניות מרגע היצירה, עם sleep בין הצעדים:
show() { stat -c '%X %Y %Z %W' "$1" | awk '{ printf "Access=+%d Modify=+%d Change=+%d\n", $1-$4, $2-$4, $3-$4 }'; }
echo one > t.log
B=$(stat -c %W t.log)
show t.log # just created
sleep 2; chmod 600 t.log; show t.log # metadata only
sleep 2; echo two >> t.log; show t.log # content changes
sleep 2; cat t.log > /dev/null; show t.log # first read
sleep 2; cat t.log > /dev/null; show t.log # second read
[ "$(stat -c %W t.log)" = "$B" ] && echo "Birth unchanged"Access=+0 Modify=+0 Change=+0
Access=+0 Modify=+0 Change=+2
Access=+0 Modify=+4 Change=+4
Access=+6 Modify=+4 Change=+4
Access=+6 Modify=+4 Change=+4
Birth unchangedקראו את הפלט שורה אחרי שורה. chmod הזיז רק את Change, הוספת הטקסט הזיזה את Modify ואת Change יחד, הקריאה הראשונה הזיזה את Access, אבל הקריאה השנייה לא. ו-Birth, שהייתה כאן נקודת האפס, לא זזה בכלל.
שם ב-stat | קיצור | מה מעדכן אותה |
|---|---|---|
Access | atime | קריאת התוכן. עם relatime (הנפוץ כיום) העדכון קורה רק אם Access לא חדשה יותר מ-Modify או מ-Change, או שעברה יממה |
Modify | mtime | שינוי תוכן הקובץ, ורק הוא |
Change | ctime | כל שינוי ב-inode עצמו: הרשאות, בעלים, מונה קישורים, שם, וגם שינוי תוכן |
Birth | crtime | רגע היצירה, פעם אחת בלבד (נשמרת ב-ext4) |
זו ההבחנה שנבחנים עליה: Modify מול Change. כתיבה לקובץ משנה את התוכן, ובעקבותיו גם את הגודל ואת mtime, שהם שדות של ה-inode, ולכן Change זזה איתה. לעומת זאת chmod ו-chown נוגעים בשדות של ה-inode בלבד, ולכן רק Change זזה.
והאות c ב-ctime באה מ-change ולא מ-creation. את רגע היצירה מציגה Birth.
relatime קריאות חוזרות אינן גורמות לכתיבה מחודשת של ה-inode לדיסק, וזה חוסך עבודה. האפשרות noatime של הטעינה מוותרת על עדכוני Access לגמרי.תרחיש 14: יום עבודה של קובץ audit.csv
הקובץ audit.csv נוצר ב-07:30, וכל ארבע החותמות שלו מציגות 07:30. מה קורה להן במהלך הבוקר?
# 08:10
ln audit.csv audit.copy
# 09:45
echo "row" >> audit.csv
# 11:20
wc -l audit.csv
# 11:25
wc -l audit.csv08:10, יצירת הקישור: התוכן לא נקרא ולא נכתב, אבל מונה הקישורים ב-inode עלה ל-2. לכן רקChangeעוברת ל-08:10.09:45, הוספת שורה: התוכן ו-mtimeהשתנו, ולכןModifyו-Changeעוברות יחד ל-09:45.11:20, קריאה:Accessעדיין מציגה07:30, כלומר ישנה מ-Modify, ולכןrelatimeמרשה עדכון ל-11:20.11:25, קריאה נוספת:Access(11:20) כבר חדשה מ-Modifyומ-Change, ולא עבר יום, ולכן אין עדכון.
בסוף הבוקר: Access היא 11:20, Modify ו-Change הן 09:45, ו-Birth נשארת 07:30.
טעויות נפוצות
ctimeהיא זמן היצירה של הקובץ. האותcהיא change. החותמת מציינת את השינוי האחרון ב-inode, וזמן היצירה הואBirth.chmodמעדכנת אתModifyאו אתAccess. היא משנה שדה של ה-inode בלבד: התוכן לא שונה ולא נקרא, ולכן רקChangeזזה.chmod,chownאוlnמזיזים אתBirth.Birthנקבעת ברגע היצירה ואינה משתנה אחר כך.
בדקו את עצמכם
הרצתם ln report.txt report.old בלי לגעת בתוכן. איזו חותמת של report.txt זזה, ולמה?
רק Change: מונה הקישורים הוא שדה של ה-inode, והתוכן לא נקרא ולא נכתב.
איזו משלוש חותמות הזמן הנוספות נשארת קבועה לכל חיי הקובץ?
Birth, זמן היצירה.
קישור קשיח ומונה הקישורים
אם השם הוא רק שורה בתיקייה, שום דבר לא מונע משתי שורות, אפילו בתיקיות שונות באותה מחיצה, להצביע על אותו מספר inode. כל שורה כזו נוספת נקראת קישור קשיח (hard link), ויוצרים אותה בפקודה ln בלי דגלים, בצורה ln קיים חדש.
בדוגמה הבאה נוצר קישור, נכתבת שורה נוספת דרך אחד השמות, נמחק השם המקורי, ובכל שלב מודפסים מספר ה-inode ומונה הקישורים:
echo v1 > ledger.txt
ln ledger.txt ledger.bak
stat -c '%i links=%h %n' ledger.txt ledger.bak
echo v2 >> ledger.bak
cat ledger.txt
rm ledger.txt
stat -c '%i links=%h %n' ledger.bak
cat ledger.bak19956 links=2 ledger.txt
19956 links=2 ledger.bak
v1
v2
19956 links=1 ledger.bak
v1
v2שלושה דברים בולטים בפלט: לשני השמות אותו מספר inode והמונה הוא 2, והשורה שנוספה דרך ledger.bak נראית גם דרך ledger.txt, כי זה אותו קובץ. אחרי rm ledger.txt נשאר שם אחד, המונה 1, וכל הנתונים שלמים, כי אף אחד מהשמות לא היה "המקור".
המונה סופר שמות בתיקיות ותו לא, ולא פתיחות, בלוקים או עותקים. rm מורידה אותו ב-1, והנתונים משתחררים רק כשהוא מתאפס ובו בזמן שום תהליך לא שומר את הקובץ פתוח. את הערך רואים בעמודה השנייה של ls -l.
לקישור קשיח יש שתי מגבלות. הוא לא עובר בין מערכות קבצים, כי מספר inode מוכר רק בתוך אחת מהן, ובדרך כלל הליבה חוסמת אותו לתיקייה כדי שלא ייווצרו מעגלים בעץ:
ln ledger.bak /dev/shm/ledger.link
mkdir folder
ln folder folder.linkln: failed to create hard link '/dev/shm/ledger.link' => 'ledger.bak': Invalid cross-device link
ln: folder: hard link not allowed for directory| פקודה | מה נוצר | מה קורה ל-inode ולמונה |
|---|---|---|
ln sales.csv sales.alias | שם נוסף לאותו קובץ | אותו inode, והמונה עולה ב-1 |
ln -s sales.csv sales.alias | קובץ קטן שמכיל נתיב | inode חדש, והמונה של היעד אינו משתנה |
cp sales.csv sales.alias | עותק עצמאי של הנתונים (כשהיעד חדש) | inode חדש עם מונה 1, ושינוי באחד לא ישפיע על השני |
mv sales.csv sales.alias | החלפת שם באותה מחיצה | אותו inode, והמונה לא משתנה |
תרחיש 15: מונה הקישורים אחרי חמש פקודות ln ושתי מחיקות
בתיקייה ריקה על ext4 מריצים את הרצף הבא, ועוקבים אחרי ה-inode שנוצר בשורה הראשונה:
echo k > n1
ln n1 n2
ln n2 n3
ln -s n3 n4
ln n1 n5
rm n3
rm n1
stat -c '%n links=%h inode=%i' n2 n5 n4n2 links=2 inode=19956
n5 links=2 inode=19956
n4 links=1 inode=20038echo k > n1: נוצר inode עם שם אחד, והמונה 1.ln n1 n2: שורה שנייה מצביעה על אותו inode, והמונה 2.ln n2 n3: אין הבדל אם מקשרים דרךn1או דרךn2, כי שניהם מובילים לאותו inode, והמונה 3.ln -s n3 n4: הקישור הסימבולי מקבל inode משלו, והמונה נשאר 3.ln n1 n5: המונה 4.rm n3: נעלם שם אחד והמונה 3. הקישורn4נשאר, אבל הוא מצביע על שם שכבר אינו קיים.rm n1: המונה 2.
לכן בשורות האחרונות של הפלט ל-n2 ול-n5 יש אותו inode ו-links=2, ואילו ל-n4 יש inode משלו ו-links=1.
טעויות נפוצות
- מונה הקישורים סופר כמה תהליכים פתחו את הקובץ או כמה בלוקים הוא תופס. הוא סופר רק שמות, כלומר רשומות בתיקיות שמצביעות על ה-inode.
- אחרי
rmשל אחד השמות, הנתונים נמחקים או מועתקים ל-inode חדש עבור השם האחר. ה-inode נשאר כפי שהוא.rmרק מסירה שורה אחת ומורידה את המונה ב-1. - כשמוחקים את השם המקורי, הקישור הקשיח שנשאר נשבר. שבירה היא תכונה של קישור סימבולי. קישור קשיח הוא שם שווה זכויות לכל שם אחר.
ln -sו-cpמוסיפות שם לאותם נתונים, כמוln.ln -sיוצרת קובץ נפרד שמכיל נתיב, ו-cpיוצרת קובץ עם נתונים משלו. רקlnבלי דגלים מוסיפה שם.
בדקו את עצמכם
לקובץ יש שני שמות, a ו-b. מוחקים את a ואז מריצים ln -s b c. מה מונה הקישורים של b?
1. המחיקה הורידה אותו מ-2, והקישור הסימבולי c אינו נספר.
איך תוודאו ש-x ו-y הם שני שמות לאותו קובץ ולא שני עותקים?
בעזרת ls -li או stat: אותו מספר inode ומונה של 2 לפחות.
קישור סימבולי: קיצור דרך לפי שם
תקלה קלאסית: ls מראה שהקישור קיים, אבל cat עליו מחזיר No such file or directory. הדוגמה הבאה יוצרת גם קישור קשיח וגם סימבולי לאותו קובץ, מוחקת את השם המקורי ובודקת מי שורד:
echo cfg > app.conf
ln app.conf app.hard
ln -s app.conf app.soft
stat -c '%A size=%s %N' app.soft
rm app.conf
cat app.hard
cat app.softlrwxrwxrwx size=8 'app.soft' -> 'app.conf'
cfg
cat: app.soft: No such file or directoryהקישור הקשיח שורד, כי הוא שם נוסף ל-inode שעדיין קיים. הקישור הסימבולי הוא קובץ נפרד עם inode משלו, ותוכנו הוא מחרוזת הנתיב app.conf (בגלל זה size=8, אורך המחרוזת). בכל פתיחה הליבה קוראת את המחרוזת ומחפשת לפי שם מחדש, ושם כזה כבר אין.
מכאן נגזרות התכונות של קישור סימבולי: הוא אינו מעלה את מונה הקישורים של היעד, כי אינו שורה שמצביעה על ה-inode של היעד. הוא יכול לחצות מערכות קבצים ולהצביע על תיקיות, כי נתיב אינו תלוי במספרי inode. וב-ls -l מזהים אותו לפי האות l בתחילת ההרשאות ולפי חץ אל היעד.
חציית מערכות קבצים אפשר לראות בפועל, עם קישור שמונח ב-/dev/shm (מערכת קבצים אחרת) והולך אל קובץ בתיקייה הנוכחית:
ln -s "$PWD/app.hard" /dev/shm/other.soft
cat /dev/shm/other.softcfg| קריטריון | Hard link (ln) | Symbolic link (ln -s) |
|---|---|---|
| מספר inode | אותו מספר כמו היעד | inode משלו |
| מונה הקישורים של היעד | עולה ב-1 | אינו משתנה |
| אחרי שמוחקים את השם שממנו יצרתם אותו | ממשיך לעבוד כרגיל | נשבר ומחזיר שגיאת קובץ חסר |
| מעבר בין מערכות קבצים | אסור | מותר |
| יעד שהוא תיקייה | בדרך כלל חסום | מותר |
טעויות נפוצות
- הקישור הסימבולי ממשיך לעבוד אחרי מחיקת היעד אם נשאר hard link אחר לאותם נתונים. הקישור הסימבולי תלוי בשם שרשום בו ולא בנתונים. כשהשם נעלם הנתיב מוביל לשום מקום, בלי קשר למה שקורה ל-inode.
ln -sמוסיפה שם נוסף לנתונים של היעד. היא יוצרת קובץ חדש שכל תוכנו הוא נתיב.- אחרי
rmשל הקובץ המקורי, גם הקישור הקשיח מפסיק לעבוד. הקישור הקשיח הוא שם של ה-inode עצמו, ולכן הנתונים שורדים כל עוד לפחות שם אחד קיים.
בדקו את עצמכם
הנתיב /usr/local/bin/lint צריך להוביל לקובץ /data/tools/lint, שיושב על דיסק אחר. איזה קישור תיצרו, ולמה?
קישור סימבולי עם ln -s, כי קישור קשיח אינו יכול לחצות גבולות של מערכת קבצים.
איך מזהים ב-ls -l שקובץ הוא קישור סימבולי?
לפי האות l בתחילת שורת ההרשאות ולפי החץ -> אחרי השם, שמצביע אל היעד.
מונה הקישורים של תיקייה
גם תיקייה היא קובץ, ולכן יש לה מונה קישורים, אבל הערך שלו גבוה מ-1 גם כשיצרתם אותה לבדה. כדי לחשב אותו שואלים: מי מצביע על ה-inode של התיקייה? בדוגמה הבאה נספר על עץ אמיתי:
mkdir -p tree/a tree/b tree/c tree/d tree/e tree/d/deep tree/d/deeper
touch tree/f1 tree/f2 tree/f3
stat -c '%h %n' tree tree/a tree/d
mkdir empty
stat -c '%h %n' empty7 tree
2 tree/a
4 tree/d
2 emptyשלוש קבוצות של שמות מצביעות על ה-inode של תיקייה, ומהן נגזר הכלל:
- השם של התיקייה בתוך תיקיית האב: 1.
- הרשומה
.שבתוך התיקייה עצמה: 1. - הרשומה
..שבתוך כל תת-תיקייה ישירה, שמצביעה כלפי מעלה אל האב: 1 לכל תת-תיקייה.
לכן המונה הוא 2 + מספר תתי-התיקיות הישירות. ב-tree יש חמש תתי-תיקיות ישירות (a עד e), ולכן 7. ב-tree/d יש שתיים (deep ו-deeper), ולכן 4, ותיקייה ריקה מראה 2.
שלושה דברים אינם נספרים: הקבצים הרגילים f1 עד f3, כי אין בהם ..; התיקיות deep ו-deeper, שה-.. שלהן מצביע על tree/d ולא על tree; וה-.. שבתוך tree עצמה, שמצביע על האב שלה ולכן שייך למונה של האב.
1, כלומר "לא נספר". בשאלות מבחן מניחים את הכלל הרגיל.טעויות נפוצות
- המונה של תיקייה הוא תמיד 2, או 1 ועוד מספר תתי-התיקיות. הערך 2 נכון רק כשאין תתי-תיקיות. כל תת-תיקייה ישירה מוסיפה 1, והבסיס הוא 2 ולא 1, כי גם הרשומה
.נספרת. - המונה הוא 3 ועוד תתי-התיקיות, כי גם ה-
..של התיקייה נספר. ה-..שבתוך התיקייה מצביע על האב שלה, ולכן הוא נספר שם ולא אצלה. - קבצים רגילים, או תתי-תיקיות בעומק שני, מגדילים את המונה. רק ה-
..של תת-תיקייה ישירה מצביע על התיקייה.
בדקו את עצמכם
בתיקייה יש 8 תתי-תיקיות ישירות ו-300 קבצים. מה המונה שלה, ומה ישתנה בו אם תיצרו חמש תיקיות בתוך אחת מתתי-התיקיות?
10. הוא לא ישתנה: התיקיות החדשות מצביעות עם .. על תת-התיקייה ולא על התיקייה.
rm, קובץ פתוח ומתי המקום באמת חוזר
תקלה מוכרת מהשטח: המחיצה מלאה, מוחקים לוג ענק, ו-df לא זזה. בו בזמן du מדווחת על נפח קטן בהרבה ממה ש-df אומרת.
הסיבה לפער: du מטיילת על רשומות התיקיות ומחברת את הקבצים שיש להם שם, וקובץ מחוק אין לו רשומה, בעוד df סופרת את הבלוקים שמוקצים בפועל. פער גדול כזה הוא הסימן לקובץ שנמחק אבל עדיין פתוח אצל תהליך.
ההסבר נובע מהאופן ש-rm עובדת. היא קוראת לקריאת המערכת unlink, שמסירה רשומה אחת מהתיקייה ומורידה את מונה הקישורים ב-1, ואין לה "פח אשפה" ברמת מערכת הקבצים. את ה-inode ואת הבלוקים הליבה משחררת רק כששני תנאים מתקיימים יחד: המונה הגיע לאפס, ובמקביל אין תהליך שפתח את הקובץ וטרם סגר אותו.
אפשר לשחזר את המצב בקטן. המעטפת עצמה ($$ הוא מספר התהליך שלה) משמשת כתהליך ששומר קובץ פתוח:
exec 7> spool.log # this shell keeps the file open as descriptor 7
echo "entry 1" >&7
rm spool.log # the name is gone, the open file is not
readlink /proc/$$/fd/7
stat -L -c 'links=%h size=%s' /proc/$$/fd/7
lsof -a -p $$ +L1 | awk '{print $1, $2, $4, $5, $8, $9, $10, $11}'
: > /proc/$$/fd/7 # truncate through the descriptor
stat -L -c 'size after truncate=%s' /proc/$$/fd/7
exec 7>&- # close it/tmp/w44c_g7/spool.log (deleted)
links=0 size=8
COMMAND PID FD TYPE NLINK NODE NAME
bash 791 7w REG 0 19956 /tmp/w44c_g7/spool.log (deleted)
size after truncate=0הפלט מראה את כל העובדות. readlink מציגה את הנתיב עם התוספת (deleted), מונה הקישורים הוא 0 והגודל נשאר. lsof +L1 מציגה קבצים פתוחים שמונה הקישורים שלהם קטן מ-1 (כאן צומצמה לתהליך הנוכחי עם -a -p, ועמודות USER, DEVICE ו-SIZE/OFF הושמטו): FD הוא 7w כלומר מתאר 7 לכתיבה, NLINK הוא 0, והשם נושא את התגית (deleted).
בשרת אמיתי מריצים lsof +L1 כמות שהיא, או lsof | grep deleted. כדאי לא להוסיף אחריה נתיב של תיקייה: בבדיקה ב-WSL נתיב כזה הרחיב את הרשימה לרשומות שאינן קובץ מחוק.
יש שתי דרכים להחזיר את המקום. מפעילים מחדש את השירות (או גורמים לו לסגור את הקובץ), או חותכים את הקובץ דרך /proc/<PID>/fd/<FD>, כמו בדוגמה. כדי שזה לא יקרה מלכתחילה, מרוקנים לוג פעיל בפקודה > logfile, שחותכת את אותו inode ומחזירה את הבלוקים מיד, ולא מוחקים אותו עם rm.
תרחיש 16: חיפוש המקום האבוד בשרת הנתונים
המחיצה /data מלאה ב-97%. אתם מוחקים את /data/queue/dump.log בנפח 18 GB, אבל df -h /data ממשיכה להציג 97%, ואילו du -sh /data מסכמת רק 6 GB.
lsof +L1הפער של כ-18 GB מכוון אל הקובץ שנמחק. הפלט הצפוי של lsof +L1 מכיל תהליך בשם collector שמחזיק את dump.log (deleted) עם NLINK של 0.
| צעד | האם הוא עוזר |
|---|---|
sync | לא: הוא מוציא נתונים מהמטמון לדיסק, והבעיה היא קובץ פתוח ולא מטמון |
fsck | לא: הוא נועד למערכת שאינה מחוברת, ואין כאן שגיאה לתקן |
e4defrag | לא: הוא מסדר מחדש קטעי קובץ ואינו משחרר בלוקים |
הפעלה מחדש של collector | כן: התהליך סוגר את הקובץ, והבלוקים מתפנים מיד |
אחרי ההפעלה מחדש df -h /data יורדת בהתאם.
טעויות נפוצות
rmשולחת את הקובץ לפח או ל-lost+found, ולכן הבלוקים עדיין תפוסים. אין פח במערכת הקבצים. את התיקייהlost+foundממלאתe2fsckבקבצים יתומים שהיא מוצאת בזמן בדיקה, ולאrm.dfקוראת נתונים שנשארו במטמון, או שיומן ext4 מחזיק גיבוי של הקובץ שנמחק. הבלוקים תפוסים באמת, כי תהליך שומר את הקובץ פתוח, ואין ביומן גיבוי של קבצים מחוקים.- הבלוקים משתחררים רק אחרי
sync, אחרי רישום היומן הבא או אחריe2fsck. שום מנגנון כזה אינו מעורב. הבלוקים חוזרים ברגע שהקובץ נסגר או נחתך. fsckאוe4defragיחזירו את המקום. שום כלי חיצוני אינו סוגר קובץ במקום התהליך. רק סגירה או חיתוך משחררים אותו.
בדקו את עצמכם
למה du אינה מציגה קובץ מחוק ופתוח, ו-df כן?
du מחברת קבצים שהיא פוגשת בטיול על השמות בתיקיות, ולקובץ הזה אין שם. df קוראת מהמערכת כמה בלוקים מוקצים, והם נשארים מוקצים עד שהקובץ נסגר.
יש לוג פעיל וענק ואתם צריכים לפנות ממנו מקום. מה עדיף, rm או > file, ולמה?
> file, כי היא חותכת את אותו inode והמקום חוזר מיד. rm רק מסירה שם, והבלוקים נשארים תפוסים כל עוד התהליך כותב.
mv ו-cp: מי שומר על ה-inode
נתחיל ב-cp, והתוצאה תלויה ביעד. כשהיעד שם חדש, נוצר קובץ חדש עם inode משלו והעתק עצמאי של הבלוקים. כשהיעד כבר קיים, cp כותבת את התוכן החדש לתוכו, וה-inode של היעד נשאר כמו שהיה:
echo old > keep.cfg
echo new > fresh.cfg
stat -c 'keep.cfg inode=%i' keep.cfg
cp fresh.cfg keep.cfg
stat -c 'keep.cfg after cp onto it: inode=%i' keep.cfg
cat keep.cfg
cp fresh.cfg copy.cfg
stat -c '%n inode=%i' fresh.cfg copy.cfgkeep.cfg inode=19956
keep.cfg after cp onto it: inode=19956
new
fresh.cfg inode=20038
copy.cfg inode=20045keep.cfg נשאר באותו inode ותוכנו הוחלף, ואילו copy.cfg קיבל inode חדש. אם היעד הוא קישור קשיח לאותו קובץ מקור, cp מסרבת בהודעה are the same file.
עכשיו mv. בדוגמה נוצר קובץ של 3 MB, והוא עובר פעם אחת אל תיקייה שיושבת על אותה מחיצת ext4 ופעם אחת אל /dev/shm, שהיא מערכת קבצים אחרת (tmpfs). הקוד מדפיס את מספר ה-inode לפני ואחרי כל מעבר:
mkdir src dst
head -c 3000000 /dev/zero > src/big.bin
stat -c 'before: inode=%i' src/big.bin
mv src/big.bin dst/
stat -c 'after mv, same filesystem: inode=%i' dst/big.bin
df --output=fstype dst /dev/shm
mv dst/big.bin /dev/shm/big.bin
stat -c 'after mv to tmpfs: inode=%i' /dev/shm/big.bin
rm /dev/shm/big.binbefore: inode=20142
after mv, same filesystem: inode=20142
Type
ext4
tmpfs
after mv to tmpfs: inode=3בתוך מערכת קבצים אחת mv מחליפה כתובת ולא נוגעת בנתונים: שורה אחת נמחקת בתיקיית המקור, ושורה חדשה נרשמת ליד אותו מספר inode בתיקיית היעד. לכן הבלוקים נשארים והפעולה מסתיימת מיד, בלי קשר לגודל.
בין מערכות קבצים אין ברירה, כי מספר inode קיים רק בתוך מערכת אחת. mv יוצרת inode חדש ביעד, מעתיקה אליו את הנתונים ורק בסוף מוחקת את המקור, ולכן זמן הפעולה גדל עם הקובץ.
| פעולה | מספר inode | מה קורה לנתונים | זמן |
|---|---|---|---|
mv בתוך מערכת קבצים אחת | ללא שינוי | נשארים במקומם | מיידי |
mv למערכת קבצים אחרת | inode חדש ביעד | מועתקים, ואז המקור נמחק | יחסי לגודל |
cp ליעד חדש | inode חדש | מועתקים, והמקור נשאר | יחסי לגודל |
cp על קובץ קיים | נשאר ה-inode של היעד | התוכן שלו נכתב מחדש במקום | יחסי לגודל |
תרחיש 17: שני מעברים של סרט גדול
הקובץ master.mov בנפח 40 GB נמצא ב-/srv/render/out. הנתיב /srv יושב על מערכת ext4 אחת, ו-/mnt/vault הוא דיסק חיצוני נפרד.
mv /srv/render/out/master.mov /srv/render/done/
mv /srv/render/done/master.mov /mnt/vault/הפקודה הראשונה חוזרת מיד, ו-ls -i מציג את אותו מספר לפני ואחרי. בפקודה השנייה הליבה כותבת 40 GB לקובץ חדש בדיסק החיצוני ומוחקת את המקור, וה-inode ביעד שונה, ולכן היא אורכת זמן רב.
טעויות נפוצות
mvבאותה מחיצה מהירה כי היא מעתיקה ברקע, משתמשת ב-extents או יוצרת קישור סימבולי. אין שום העתקה ואין קישור סימבולי. רק רשומות בתיקיות משתנות.- מספר ה-inode משתנה כשקובץ עובר בין תיקיות באותה מערכת קבצים. המספר שייך לקובץ ולא לתיקייה, ולכן הוא נשאר.
cpתמיד יוצרת inode חדש. רק כשהיעד אינו קיים. על יעד קיים היא דורסת את התוכן ושומרת על ה-inode שלו.
בדקו את עצמכם
הקובץ app.cfg קיים עם inode מספר 500. מריצים cp new.cfg app.cfg. מה מספר ה-inode של app.cfg אחר כך, ומה קרה לתוכן?
500: ה-inode של היעד נשמר, והתוכן נדרס במקום.
מתי mv של קובץ אחד תסתיים בשנייה, ומתי תיקח דקות?
בתוך מערכת קבצים אחת היא מסתיימת מיד, כי רק רשומות בתיקיות משתנות. בין מערכות קבצים היא נמשכת כזמן ההעתקה.
כשנגמרים ה-inodes
מספר ה-inodes ב-ext4 הוא פרמטר שנקבע בזמן mkfs.ext4: יחס ברירת מחדל בין נפח ל-inodes, או ערך שאתם בוחרים עם -i. כל קובץ, תיקייה או קישור סימבולי לוקחים inode אחד, אפילו כשאין בהם תוכן.
כך זה נראה בשתי מערכות קבצים בנות 64 MB שנוצרו עם יחס שונה, אחת עם inode לכל 16 KiB ואחת עם inode לכל 4 KiB. בהמשך הוגדלה הראשונה ל-300 MB עם resize2fs, והנתונים הודפסו שוב:
truncate -s 64M sparse16k.img dense4k.img
mkfs.ext4 -q -F -i 16384 sparse16k.img
mkfs.ext4 -q -F -i 4096 dense4k.img
echo '== one inode per 16 KiB'
dumpe2fs -h sparse16k.img 2>/dev/null | grep -E '^(Inode count|Block count)'
echo '== one inode per 4 KiB'
dumpe2fs -h dense4k.img 2>/dev/null | grep -E '^(Inode count|Block count)'
truncate -s 300M sparse16k.img
e2fsck -fy sparse16k.img > /dev/null 2>&1
resize2fs sparse16k.img > /dev/null 2>&1
echo '== first image after growing'
dumpe2fs -h sparse16k.img 2>/dev/null | grep -E '^(Inode count|Block count)'== one inode per 16 KiB
Inode count: 4096
Block count: 16384
== one inode per 4 KiB
Inode count: 16384
Block count: 16384
== first image after growing
Inode count: 12288
Block count: 76800בגודל זהה, יחס צפוף יותר נותן פי ארבעה inodes (16384 מול 4096). הגדלת מערכת הקבצים הוסיפה inodes יחד עם קבוצות הבלוקים החדשות. מה שאינו מוסיף inodes הוא כל דבר אחר: ext4 אינה מקצה אותם לפי דרישה, ו-tune2fs ו-e2fsck אינם מסוגלים להוסיף אותם.
כשהם נגמרים, יצירת קובץ חדש נכשלת עם No space left on device, אף שרוב הבלוקים פנויים. ההודעה זהה לזו של דיסק מלא, ולכן df -h לבדה מטעה.
הבדיקה הנכונה היא df -i. היא מציגה לכל מערכת קבצים את Inodes (הסך הכול), את IUsed (תפוסים), את IFree (פנויים) ואת IUse%, וכש-IUse% מגיע ל-100% אי אפשר ליצור אפילו קובץ ריק.
- מיידית: למחוק קבצים מיותרים שאינם פתוחים בתהליך, למשל
find /var/lib/sessions -type f -mtime +7 -delete. כל קובץ שנמחק מחזיר inode. - לטווח ארוך: לגבות וליצור את מערכת הקבצים מחדש עם יחס צפוף יותר, כמו
mkfs.ext4 -i 4096, או להגדיל את מערכת הקבצים כך שתתווסף לה קבוצת בלוקים.
שלוש פקודות מפתות לא יעזרו כאן. e2fsck -f בודקת ומתקנת מבנים בלי להגדיל אותם, e4defrag מסדרת מחדש קטעי קבצים, ו-tune2fs -m 0 מפנה את הבלוקים השמורים ל-root (ו-Avail ב-df -h כבר לא סופרת אותם בכל מקרה).
| הודעה | משמעות |
|---|---|
No space left on device, ו-df -h מציגה הרבה מקום ב-Avail | נגמרו ה-inodes, ומאמתים עם df -i |
No space left on device, ו-df -h מציגה 100% | נגמרו בלוקי הנתונים |
Read-only file system | המערכת הוטענה לקריאה בלבד, למשל אחרי שגיאת חומרה כש-errors=remount-ro מוגדר |
Disk quota exceeded | המשתמש הגיע לתקרת המכסה שלו |
תרחיש 18: שרת קבצי session שנתקע
אתר כותב קובץ session קטן לכל ביקור בתיקייה /var/lib/sessions על מערכת ext4 בנפח 80 GB. יום אחד touch /var/lib/sessions/probe נכשל עם No space left on device בעוד df -h מדווחת על שימוש של 12% בלבד.
df -i /var/lib/sessions
find /var/lib/sessions -type f -mtime +7 -delete88% פנויים אומרים שהבלוקים אינם הבעיה, וההודעה אינה Read-only file system או Disk quota exceeded, ולכן בודקים df -i. הוא מציג IFree של 0 ו-IUse% של 100%, בגלל מיליוני קובצי ה-session. מחיקת הישנים מחזירה inodes מיד, ו-touch עובד שוב.
טעויות נפוצות
- ext4 מקצה inodes לפי דרישה, או ש-
e2fsck -fמגדילה את הטבלה. המספר נקבע בזמן היצירה. רק מערכת קבצים גדולה יותר (resize2fs) אוmkfsמחדש מוסיפים inodes. - הבלוקים השמורים ל-
rootחוסמים את הכתיבה, ולכןtune2fs -m 0יפתור.Availב-df -hכבר מחסירה אותם, והפקודה משחררת בלוקים ולא inodes. - היומן התמלא ולכן אי אפשר ליצור קבצים חדשים. היומן הוא אזור בגודל קבוע שנכתב ומתנקז כל הזמן, ואין לו קשר למספר הקבצים המותר. כש-
IUse%הוא 100% הסיבה כבר ידועה. - כל
No space left on deviceמעידה על דיסק שהבלוקים בו נגמרו. אותה שגיאה מופיעה גם כשנגמרים ה-inodes. מבדילים בין שני המקרים לפיdf -hמולdf -i. df -lמציגה את תפוסת ה-inodes.-lרק מגבילה אתdfלמערכות קבצים מקומיות. ל-inodes משתמשים ב-df -i.
בדקו את עצמכם
קיבלתם No space left on device, אבל df -h מראה שמחצית המקום פנויה. מה בודקים קודם, ואיך מבדילים ממחיצה לקריאה בלבד?
df -i. מחיצה לקריאה בלבד מחזירה Read-only file system, ולא No space left on device.
למה מחיקת קבצים ישנים עוזרת כשנגמרו ה-inodes, ו-tune2fs -m 0 לא?
מחיקה מחזירה inodes. tune2fs -m 0 משחררת רק בלוקים שמורים, והם לא היו הבעיה.
נספח: שתי שאלות מפרק הליבה
rmmod ומודול שנמצא בשימוש
קובץ .ko הוא מודול ליבה, כלומר ELF מסוג relocatable שהליבה הרצה מסוגלת לטעון ולפרוק בלי אתחול. lsmod מדפיסה את המודולים הטעונים כרגע, והקטע הבא נלקח ממערכת WSL עם kmod גרסה 29:
lsmod | grep -E '^(Module|br_netfilter|bridge|stp|llc) 'Module Size Used by
br_netfilter 28672 0
bridge 286720 1 br_netfilter
stp 12288 1 bridge
llc 12288 2 bridge,stpבעמודה Used by מופיע קודם מונה השימוש, ואחריו שמות המודולים שמשתמשים במודול. כאן bridge בשימוש של br_netfilter, ל-stp יש משתמש אחד (bridge), ול-llc יש שניים (bridge ו-stp). עכשיו ננסה להסיר את llc:
rmmod llcrmmod: ERROR: Module llc is in use by: bridge stpהפקודה נכשלת מיד ומונה את המודולים שמחזיקים את llc. ההרצה כאן הייתה בלי הרשאות root, והודעת השימוש הופיעה בכל זאת. הסרה מוצלחת מחייבת root, ולכן לא ביצענו אחת.
הפקודה פועלת אך ורק על השם שציינתם: היא לא תסיר את bridge ואת stp בשבילכם. כדי להסיר את llc מפנים את השרשרת מלמעלה, בסדר br_netfilter, אחר כך bridge, אחריו stp ורק אז llc.
גם המתנה אינה חלק מהפקודה. ב-rmmod של הכלי הישן module-init-tools הייתה אפשרות -w (--wait) שביקשה להמתין עד שהמודול יתפנה. ב-kmod, החבילה שמספקת את הפקודה בהפצות של היום, האפשרות לא קיימת, ובבדיקה על kmod 29 התקבל:
rmmod --wait llcrmmod: unrecognized option '--wait'ברירת המחדל בכל הגרסאות היא סירוב מיידי. אפשרות החירום להסיר מודול שבשימוש היא -f, ובה הפקודה כופה את ההסרה, אבל היא פועלת רק אם הליבה נבנתה עם תמיכה בהסרה כפויה, וההסבר של הכלי עצמו מזהיר שהיא מסוכנת ועלולה להקריס את המחשב.
גם modprobe -r לא עוקפת את המגבלה: היא מסירה את המודול שביקשתם ואת התלויות שלו שכבר אינן בשימוש, אבל לא מודולים שמשתמשים בו. את Invalid module format מקבלים בטעינה של מודול שנבנה עבור גרסת ליבה אחרת, ולא בהסרה.
טעויות נפוצות
- הסרת מודול ב-
rmmodגוררת אחריה את כל המודולים שתלויים בו. היא מסרבת ונכשלת כל עוד מונה השימוש גדול מ-0. rmmodממתינה עד שהמודול יתפנה. ב-kmod אין המתנה, והפקודה נכשלת מיד. גם בכלי הישן ההמתנה הייתה צריכה לבקש אותה במפורש עם-w.- ניסיון להסיר מודול שבשימוש מסתיים ב-
Invalid module format. את ההודעה הזו מקבלים כשטוענים מודול שאינו מתאים לגרסת הליבה. בהסרה של מודול בשימוש ההודעה אומרת שהמודול בשימוש, ומי משתמש בו.
בדקו את עצמכם
לפי הקטע של lsmod למעלה, באיזה סדר מסירים את llc?
קודם br_netfilter (שמשתמש ב-bridge), אחר כך bridge, אחריו stp, ורק אז llc. כל מודול חייב להתפנות ממשתמשיו לפני שמסירים אותו.
שורה ב-lsmod מציגה Used by עם הערך 0. מה זה אומר על הסרה?
שאין שום משתמש במודול, ולכן rmmod (בהרשאת root) אמורה להצליח להסיר אותו.
עצירת הסביבה הגרפית בלי אתחול
הפקודה systemctl get-default מדפיסה באיזה מצב המערכת עולה כברירת מחדל:
systemctl get-defaultgraphical.targetמצבים כאלה נקראים targets ב-systemd. graphical.target מוסיף למערכת מנהל תצוגה וממשק חלונות, ואילו multi-user.target מסתפק במסוף טקסט עם כמה משתמשים (המקביל של runlevel 3 במערכות SysV הישנות).
דמיינו שדרייבר הגרפיקה קרס והמסך קפוא, אבל המחשב ממשיך לענות ברשת. אין סיבה לאתחל: עוברים למסוף טקסט נפרד (למשל עם Ctrl+Alt+F3), נכנסים, ויורדים מהמצב הגרפי בפקודה אחת.
| פקודה | מה היא עושה |
|---|---|
systemctl isolate multi-user.target | מחליפה את המצב הנוכחי במצב טקסט מיידית, ובדרך עוצרת את מנהל התצוגה ואת הממשק הגרפי |
systemctl set-default multi-user.target | רושמת את מצב הטקסט כיעד של האתחולים הבאים בלבד, והמצב הנוכחי נשאר כפי שהוא |
systemctl status display-manager | רק מדפיסה את מצב מנהל התצוגה |
systemctl list-units --failed | רק מונה יחידות שנכשלו, ואינה משנה אף שירות |
אחרי שתיקנתם או עדכנתם את הדרייבר חוזרים לממשק הגרפי בלי אתחול עם systemctl isolate graphical.target. הפקודות isolate ו-set-default דורשות הרשאות root, ולכן לא הרצנו אותן כאן.
טעויות נפוצות
systemctl set-default multi-user.targetעוצרת מיד את הממשק הגרפי. היא משנה רק את היעד שיעלה באתחול הבא. למעבר מיידי משתמשים ב-isolate.statusאוlist-units --failedעוצרות שירות. שתיהן פקודות קריאה בלבד, ואינן משנות שום שירות.
בדקו את עצמכם
אתם רוצים שהשרת יעלה מעכשיו בלי ממשק גרפי, אבל לא לעצור את הממשק הפעיל כרגע. איזו פקודה תריצו?
systemctl set-default multi-user.target.
הדרייבר תוקן, ואתם רוצים להחזיר את הממשק הגרפי בלי אתחול. איזו פקודה?
systemctl isolate graphical.target.
סיכום
שלושת הנושאים נשענים זה על זה: ELF מתאר איך תוכנית ארוזה בקובץ, ext4 מתאר איך קבצים נשמרים בדיסק, וה-inode מחבר בין השם שאתם רואים לבין מה שנשמר בפועל. הרשימות הבאות בנויות כשאלות שאתם אמורים לדעת לענות עליהן.
ELF: איך תוכנית ארוזה
- איך מזהים קובץ ELF? בבתים הראשונים
7F 45 4C 46, ו-fileמסכמת את סוגו בשורה אחת. - אילו סוגים יש? relocatable (
.o,.ko), executable, shared object (.soו-PIE) ו-core. - מה מצהירה כותרת הקובץ? סוג, ארכיטקטורה ונקודת כניסה, ומציגים אותה עם
readelf -h. - מה הליבה קוראת ומה הכלים קוראים? הליבה טוענת לפי ה-segments (
readelf -l), ואילו המקשר והכלים עובדים עם ה-sections (readelf -S). - מה יושב בכל section? קוד ב-
.text, משתנים מאותחלים ב-.data, קבועים ב-.rodata, ואפסים ב-.bss, שאינו תופס מקום בקובץ ולכן מנפח אתMemSizמעלFileSiz. - מי מפעיל תוכנית דינמית? הטוען
ld-linuxשנקוב ב-PT_INTERP: הוא טוען ספריות משותפות ופותר סמלים, וכשהוא חסר מקבליםNo such file or directoryאף שהקובץ קיים. - איך בודקים תלויות בבטחה? עם
readelf -d, שאינה מריצה דבר, בניגוד ל-lddשעלולה להריץ את הקובץ. - מה עושה
strip? מוחקת את.symtabואת הדיבוג בלי לפגוע בהרצה, ו-nmמדווחת אחר כך שאין סמלים.
ext4: איך הדיסק מנוהל
- ממה ext4 באה? ext3 הוסיפה יומן ל-ext2 ו-ext4 המשיכה אותה. היומן הוא שמחזיר עקביות במהירות אחרי קריסה.
- איך מצבי היומן נבדלים? ב-
data=ordered, ברירת המחדל, הנתונים נכתבים לפני רישום המטא-דאטה. ב-data=journalגם הנתונים עוברים ביומן, וזה הבטוח ביותר. ב-data=writebackאין סדר מובטח, ולכן קובץ עלול להציג תוכן ישן. - מה חדש ב-ext4? extents שמתארים טווח רציף במקום בלוק בלוק, הקצאה מאוחרת, קבצים עד
16 TiBונפחים עד1 EiB. - האם אפשר לחבר ביניהן? ext3 מתחברת כ-ext4 בלי המרה, אבל ext4 שמשתמשת ב-extents לא תתחבר כ-ext3.
- איזה כלי למה?
mkfs.ext4בונה מערכת ריקה מאפס,e2fsck -fבודק ומתקן, ו-tune2fsמתאים פרמטרים של מערכת קיימת. - מי משנה גודל?
resize2fs. הגדלה אפשרית גם בחיבור פעיל, והקטנה דורשת קודםumountו-e2fsck -f. - מה עושים כשה-superblock הראשי פגום? בבלוקים של
4 KiBקוראים את הגיבוי עםe2fsck -b 32768.
inode, שמות ומקום
- מה ב-inode ומה לא? סוג, הרשאות,
UIDו-GID, גודל, בלוקים, מונה קישורים, חותמות זמן ומיקום הנתונים כן. שם הקובץ לא, כי הוא ברשומת התיקייה, והמספר ייחודי רק בתוך מערכת קבצים אחת. - איך מציצים בו?
ls -i,stat,find -xdev -inumו-df -i. - איזו חותמת זזה מתי?
Changeזזה בכל שינוי ב-inode,chmodבכלל זה.Modifyזזה רק כשהתוכן משתנה, ו-Birthהיא רגע היצירה. - במה שונים שני סוגי הקישורים?
lnמוסיפה שם לאותו inode ומעלה את המונה, ואילוln -sיוצרת קובץ נפרד שמחזיק נתיב ונשבר ברגע שהיעד נעלם. - איך מחשבים מונה של תיקייה?
2 + מספר תתי-התיקיות הישירות. - מתי מקום חוזר אחרי
rm? כשהמונה התאפס וגם אין תהליך שפתח את הקובץ. עד אזdfנשארת מלאה ו-du, שמטיילת על שמות, לא רואה אותו. - מה
mvו-cpעושות ל-inode?mvבתוך מערכת קבצים אחת רק מחליפה רשומות, ולכן היא מיידית ושומרת על המספר.cpליעד חדש יוצרת inode חדש, ועל יעד קיים כותבת במקום ומשאירה את ה-inode שלו. - מה פירוש
No space left on deviceכשיש מקום ב-df -h? נגמרו ה-inodes, ומוודאים עםdf -i. היומן אינו הסיבה.
נספח הליבה
- למה
rmmodנכשלת? כל עודUsed byאינו0היא מסרבת מיד, ולכן מפנים קודם את המודולים שמשתמשים במודול. - איך יוצאים מגרפיקה תקועה בלי אתחול?
systemctl isolate multi-user.target.set-defaultמשנה רק את האתחול הבא.