דלגו לתוכן הראשי
גאמא קוד

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, ובצדה הימני הם מוצגים כתווים:

Bash
head -c 16 /usr/bin/cat | xxd
פלט
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000  .ELF............

בהקסדצימלי הרצף הוא 7F 45 4C 46: קודם הבית 0x7F (תו הבקרה DEL), ומיד אחריו הקודים של האותיות E, L ו-F. כדאי להכיר גם חתימות של פורמטים אחרים, כדי לזהות במהירות מה מונח מולכם:

רצף בתים בהקסדצימלימשמעות בתווי ASCIIסוג הקובץ
7F 45 4C 46DEL + ELFקובץ ELF של לינוקס ו-UNIX
4D 5AMZקובץ הרצה (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 כדי לקצר. התוצאה על תוכנית מערכת ועל ספרייה משותפת, מהרצה על אובונטו:

Bash
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 מסננת את השדות החשובים בלבד:

Bash
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, המציינים באיזה בית בקובץ מתחילה כל אחת משתי טבלאות המבנה.
אל תחפשו את כתובת ההתחלה בין שמות הפונקציות. היא שדה בכותרת ה-ELF עצמה ואין לה קשר ל-.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 HeadersSegments (טווחי מיפוי והרשאות)הליבה (execve) והטוען הדינמיreadelf -l
מבט הקישור (Linking)Section HeadersSections (חטיבות בעלות שם)המקשר, הדיבאגר, objdump, nmreadelf -S

בטבלת ה-program headers יש שלושה סוגי segments מרכזיים שכדאי להכיר:

  • PT_LOAD (בפלט: LOAD): רצועה שהליבה ממפה מהקובץ לזיכרון, וכל רצועה נושאת צירוף משלה של הרשאות R, W ו-E.
  • PT_INTERP (בפלט: INTERP): הנתיב של הטוען הדינמי שהליבה צריכה לצרף לטעינה.
  • PT_DYNAMIC (בפלט: DYNAMIC): הפניה לטבלאות הקישור הדינמי והספריות הנדרשות.

הנה ה-segments של cat בתצוגה רחבה (-W), כשהפלט מסונן לסוגים שנדון בהם בלבד (PHDR, NOTE ועוד נשמטו). שימו לב לעמודות FileSiz, MemSiz ו-Flg, שנחזור אליהן:

Bash
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, שבו המספרים סופרים גם שורות שהסינון הקודם השמיט:

Bash
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:

Assembly
    .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:

Assembly
    .data
grid:
    .long 7                    # non-zero initial value
    .zero 33554428             # the rest of the 32 MiB
    .text

אחרי הרכבה וקישור משווים את הקבצים ואת מקטעי ה-LOAD שלהם:

Bash
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 מהחלק הקודם. זו תוכנית שאינה משתמשת בספריות בכלל, ולכן היא המקרה הסטטי הפשוט ביותר:

Bash
file bss_prog
ldd bss_prog
פלט
bss_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 שהתוכנית דורשת ומקשר אליהן את הסמלים.

חזרה לתוכן העניינים

ספריות משותפות: .so, NEEDED ו-ldd

כלל אבטחה חשוב לפני בדיקת קבצים: לעולם אל תריצו ldd על קובץ ELF חשוד או ממקור לא מהימן. בחלק מהמערכות ldd עלול להפעיל קוד מתוך הקובץ הנבדק כדי לאסוף תלויות.

כדי לבדוק אילו ספריות משותפות קובץ לא מוכר דורש בלי שום סיכון שירוץ, משתמשים ב-readelf -d (או objdump -p). כלים אלה קוראים את הקובץ כנתונים פסיביים בלבד.

Bash
readelf -d /usr/bin/cat | grep NEEDED
פלט
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]

שורות ה-NEEDED בפלט הן הדרך של ELF לנהל ספריות משותפות (.so מסוג ET_DYN), כמו ספריית C התקנית libc.so.6. במקום להעתיק את קוד הספרייה לכל קובץ, התוכנית מחזיקה הפניות בטבלאות ייעודיות:

  • במקטע PT_DYNAMIC יושבת הטבלה .dynamic, ובה שורת NEEDED לכל ספרייה שהתוכנית מבקשת בעצמה.
  • .dynsym (עם .dynstr) הוא רשימת השמות של הפונקציות והמשתנים שעוברים בין התוכנית לספריות, לשני הכיוונים.
  • .plt ו-.got הם המקום שבו הטוען רושם בזמן הריצה את הכתובות האמיתיות של פונקציות כמו printf.

היתרון: עותק אחד של ספרייה משרת הרבה תוכניות, ותיקון באג ב-libc.so.6 מספיק להחלפת קובץ אחד. הספרייה ממופה לתוך מרחב הכתובות של התהליך שביקש אותה, בידי משתמש רגיל, בלי root ובלי מכונה וירטואלית נפרדת.

שני הכלים נבדלים בעומק. readelf -d מראה רק מה שכתוב בקובץ: תלויות ישירות, בשמות בלבד. ldd פותר את כל העץ ומציג גם תלויות של תלויות ואת הנתיב בדיסק, ולכן מתאים רק לקבצים שבהם אתם בוטחים.

תרחיש 5: רשימת ספריות של קובץ שאסור להריץ

מתחנה שהושבתה הועתק לבדיקה הקובץ agent.bin, ו-file אישרה שהוא ELF דינמי. עליכם לרשום אילו ספריות הוא מבקש, והוא אסור שירוץ אפילו לרגע.

כל אחת מהפקודות הבאות נראית סבירה, אך רק אחת מהן עונה על השאלה בלי להריץ את הקובץ:

פקודהמה היא תעשה בפועלהאם מתאימה
readelf -d agent.binתקרא את .dynamic ותדפיס שורות NEEDED עם שמות הספריות, בלי להפעיל דברכן
ldd agent.binתפתור את העץ וייתכן שתריץ קוד מהקובץ כדי לעשות זאתלא: מסוכן
nm agent.binתציג סמלים של הקובץ, ואם הם הוסרו ב-strip לא תציג כמעט כלום. בכל מקרה אין בפלט שלה רשימת ספריותלא: לא עונה
readelf -h agent.binתדפיס את שדות הכותרת בלבד, ללא כל מידע על ספריותלא: לא עונה
טעויות נפוצות
  • ספרייה דינמית מועתקת במלואה לתוך קובץ ההרצה, רצה במנוע וירטואלי נפרד, או דורשת root לטעינה. העתקה מלאה מתרחשת רק בקישור סטטי. ספריות דינמיות ממופות למרחב הזיכרון של התהליך עצמו, וכל משתמש רגיל מריץ אותן.
  • אפשר להשתמש ב-ldd בבטחה על כל קובץ, או ב-nm / objdump -d / strip כדי לראות ספריות משותפות. ldd עלול להריץ קובץ חשוד; nm מציגה סמלים, objdump -d מפרקת הוראות מכונה, ו-strip מסירה סמלים.
בדקו את עצמכם
באיזה סעיף וברשומה מסוג מה מתועדת הדרישה ל-libc.so.6, ואיזו פקודה מציגה אותה בבטחה על קובץ לא מהימן?

בסעיף .dynamic ברשומת NEEDED. בודקים זאת בבטחה בעזרת readelf -d (שאינה מריצה את הקובץ).

חזרה לתוכן העניינים

ארגז הכלים: 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:

Bash
nm /usr/bin/cat
nm -D /usr/bin/cat | head -n 4
פלט
nm: /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, סמלים והרצה:

Bash
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מצביע נפרד לכל בלוק, ותקרות נמוכות יחסית לנפח ולקובץ
ext4extents, הקצאה מאוחרת, תקרות גבוהות בהרבה וביצועים טובים יותראין דחיסה שקופה ואין תמונות מצב (snapshots)

כמה מונחים יחזרו לאורך הפרק, ולכן כדאי להכיר אותם כבר עכשיו. כל אחד מהם יוסבר לעומק בהמשך:

  • inode: רשומה בדיסק שמתארת קובץ אחד, עם הגודל, ההרשאות והמקום של הנתונים שלו. שם הקובץ אינו חלק ממנה.
  • extent: רשומה שמתארת טווח של בלוקים צמודים, בערך 'מבלוק כך וכך, כל כך בלוקים', במקום לפרט בלוק אחר בלוק.
  • superblock: הרשומה הכללית של מערכת הקבצים, עם גודל הבלוק, מספר הבלוקים וה-inodes והמצב הנוכחי.
  • RAID: חיבור של כמה כוננים פיזיים כך שהנתונים נשמרים בעותקים או עם יתירות, והמערכת שורדת תקלה בכונן אחד.

אל תניחו ש-ext4 נבחרת בכל התקנה. הפצות ממשפחת RHEL מגרסה 7 ואילך מתקינות כברירת מחדל את XFS, ו-Fedora Workstation מתקינה את btrfs.

חשוב להבחין גם בין ext4 לבין שני דברים שנשמעים קרובים. מערכות קבצים רשתיות כמו NFS ו-SMB נותנות למחשבים לגשת לתיקיות שיושבות על שרת אחר, ואזור swap הוא מקום שבו הליבה מחזיקה דפי זיכרון כשה-RAM מלא. ext4 מנהלת קבצים ותיקיות על התקן שמחובר למחשב עצמו, ותו לא.

כדי לראות אילו מערכות מחוברות ובאילו אפשרויות, מסננים את הפלט של mount. בדוגמה החיבור הוא של קובץ תמונה דרך התקן loop, שמתנהג כמו דיסק (האפשרות -o loop נחוצה רק בגלל זה):

Bash
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 או נתונים
הקצאת ה-inodeinode שמסומן כתפוס ואף שם בתיקייה לא מצביע אליו
סימון בלוקים כתפוסיםבלוקים שנחשבים תפוסים בלי שקובץ כלשהו משתמש בהם
כתיבת התוכןתוכן שיושב בדיסק ואין שום 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 מדפיס:

Bash
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:

Text
/dev/sdb1  /srv/ledger  ext4  defaults,data=journal  0  2

שורת mount ללא data= כלל פירושה שרצה ברירת המחדל data=ordered. noatime היא אפשרות מעולם אחר: היא מונעת מהליבה לרשום את שעת הקריאה האחרונה בכל גישה לקובץ, וכך חוסכת כתיבות, ואינה משפיעה על מה שהיומן מגן עליו.

תרחיש 8: תוכן זר בסוף קובץ אחרי הפסקת חשמל

בבוקר אחרי הפסקת חשמל מנהלת מערכת מגלה שבסוף orders.csv יש שורות שנראות כמו קטע מייצוא ישן. השרת עלה מהר ובלי fsck מלא, ובשורת ה-/etc/fstab של המחיצה רשום defaults,data=writeback.

הקובץ הורחב ברגע שלפני הנפילה, וזה מה שקרה לפי הסדר:

  1. המערכת הקצתה לקובץ את בלוק 8800, שהחזיק בעבר תוכן של קובץ שנמחק.
  2. המטא-דאטה, עם הגודל החדש וההפניה לבלוק 8800, נרשם ביומן ואושר.
  3. החשמל נפל לפני שהתוכן החדש נכתב לבלוק 8800.
  4. בהפעלה הבאה היומן שוחזר: הגודל והבלוק כבר חלק מהקובץ, והתוכן שנקרא הוא מה שישב שם קודם.

תוצאות המצבים השונים על אותה נפילה:

  • 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 הושמטו מהפלט):

Bash
dd if=/dev/zero of=/srv/ledger/dump.bin bs=1M count=1024
sync
filefrag -v /srv/ledger/dump.bin
פלט
Filesystem 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 found

filefrag מדווח על חמישה טווחים, אבל הוא ממזג טווחים סמוכים. ברשומות שעל הדיסק המספר גדול יותר, לפחות שמונה, כי רשומה אחת מכילה לכל היותר 32768 בלוקים, ועדיין זה זעום לעומת מעל 260,000 המצביעים ש-ext3 הייתה צריכה.

השיפור הגדול השני הוא הקצאה מאוחרת (delayed allocation). נניח שתוכנה כותבת קובץ במאה קריאות write קטנות. אם הליבה בוחרת בלוקים בכל קריאה, הבחירות מתפזרות, ואילו כשהיא ממתינה לשטיפה, כבר ידוע כמה נתונים נאספו והיא בוחרת להם מקום אחד רציף בפעולה אחת.

הקצאה מיידיתהקצאה מאוחרת
מתי נבחרים הבלוקיםבכל קריאת writeברגע ששוטפים את הנתונים לדיסק
מה הליבה יודעת בשלב הבחירהרק את הקטע שנכתב כרגעאת כל מה שנאסף עד עכשיו
התוצאה בדיסקסיכוי גבוה יותר לפיצולטווח רציף וכתיבות מעטות יותר
הסיכוןאיןכתיבות אחרונות שעוד לא נשטפו עלולות לאבוד בקריסה

רשימת השיפורים הנוספים:

  • מקצה מרובה בלוקים (multiblock allocator): מקצה כמה בלוקים בבת אחת, במקום להקצות כל בלוק לחוד.
  • הקצאה מראש מתמשכת (persistent preallocation, עם fallocate): שומרת לקובץ שטח מראש, ומנסה להשיג אותו רציף, בלי לכתוב לתוכו אפסים.
  • חותמות זמן: דיוק של ננו-שניות ותמיכה בתאריכים אחרי שנת 2038, כש-inode בגודל 256 בתים.
  • בדיקה מהירה יותר: fsck מדלג על אזורים שאיש לא השתמש בהם, כמו קבוצות בלוקים וטבלאות inodes ריקות.
  • איחוי בזמן עבודה: e4defrag מסדר מחדש קבצים שהתפזרו לחתיכות, בלי לנתק את המערכת.

התקרות השתנו גם הן. הערכים מתייחסים לבלוקים של 4 KiB:

מגבלהext3ext4
גודל מערכת הקבצים16 TiB1 EiB
גודל קובץ בודד2 TiB16 TiB
מספר תתי-תיקיות בתיקייה32,000אין את המגבלה הזו
שלושה מספרי ברירת מחדל שכדאי לזכור: בלוק של 4 KiB, inode של 256 בתים ושם קובץ של עד 255 בתים.

ומה ext4 לא כוללת, גם אם מערכות קבצים אחרות כוללות?

יכולתהמצב ב-ext4
דחיסה שקופה ותמונות מצב (snapshots)אין. את אלה מציעות מערכות כמו btrfs ו-ZFS
הגדלה אוטומטית של מספר ה-inodesאין. המספר נקבע פעם אחת, בעת היצירה
היכן נשמר שם הקובץברשומת התיקייה, ולא ב-inode
מבנה בסיסיעדיין inodes. אין מעבר ל-B-tree כמו ב-NTFS, וגם לא לטבלת אשכולות מרכזית כמו ב-FAT
רישום תוכן הקבצים ביומןלא בברירת המחדל, שרושמת רק מטא-דאטה
תרחיש 9: העתקת גיבוי של 20 GiB

מנהל מערכת מעתיק קובץ גיבוי של 20 GiB אל מחיצה שפורמטה זה עתה כ-ext4, בלי לשנות אף הגדרה. הנה מה שקורה בשלבים:

  1. תוכנת ההעתקה כותבת הרבה מקטעים קטנים, והליבה לא בוחרת להם בלוקים מיד אלא מחזיקה אותם בזיכרון.
  2. כשהנתונים נשטפים לדיסק, ההקצאה כבר רואה כמה מקום הקובץ דורש ובוחרת טווחים רציפים ארוכים.
  3. ב-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:

Bash
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.txt
פלט
mounted 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 לא מכירה את המבנה הזה:

Bash
mount -t ext3 -o loop fresh.img /srv/legacy
dmesg | tail -1
פלט
mount: /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 עם תווית, ואז מציגים את פרטיה ומשנים את האחוז השמור:

Bash
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:     655

3276 מתוך 65536 הבלוקים הם 5%, ואחרי -m 1 נשאר אחוז אחד בלבד. אפשר לקבוע את מספר ה-inodes ביצירה, וזה מה שמתקבל עם mkfs.ext4 -N 2000 על מערכת קטנה:

Bash
mkfs.ext4 -q -N 2000 n.img
tune2fs -l n.img | grep 'Inode count'
פלט
Inode count:              2000

הכנת דיסק חדש מורכבת משלושה שלבים, ולכל אחד כלי משלו:

  1. fdisk יוצר מחיצה בטבלת המחיצות, ועדיין אין בה מערכת קבצים.
  2. mkfs.ext4 בונה בתוך המחיצה את מערכת הקבצים.
  3. mount מחבר את המערכת שכבר קיימת לעץ התיקיות, ואינו יוצר אותה.
תרחיש 11: פרמוט של המחיצה הלא נכונה

מנהל מערכת רצה לפרמט כונן USB חדש, אבל מקלידה בטעות את שם המחיצה של כונן אחר, זה שמכיל קבצי פרויקט ואינו מחובר כרגע. הכלי mkfs.ext4 לא ישאל הרבה: לפעמים הוא מבקש אישור כשהוא מזהה מערכת קיימת, אבל עם -F או בסקריפט הוא ממשיך בלי לשאול, ואי אפשר להסתמך על האזהרה.

הקוד הבא מדמה את המקרה על קובץ תמונה: קובץ אחד נכתב, אחר כך מריצים עליו mkfs.ext4, ובודקים מה נשאר:

Bash
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 -l
פלט
lost+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 שהגדילו את ההתקן הושמטו מהדוגמה:

Bash
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), וניסיון להקטין מערכת מחוברת נדחה (זו הרצה נפרדת, על התקן אחר):

Bash
resize2fs /dev/loop0 40M
פלט
resize2fs 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

הסדר הנכון להקטנה הוא ניתוק, בדיקה ורק אז שינוי הגודל:

  1. umount של המערכת.
  2. e2fsck -f על ההתקן, כדי לוודא שהמערכת תקינה לפני שמזיזים נתונים.
  3. resize2fs עם הגודל החדש.
  4. רק בסוף מקטינים את המחיצה עצמה, ולעולם לא מתחת לגודל שנשאר למערכת הקבצים.

אם מדלגים על הבדיקה, resize2fs יסרב ויבקש להריץ אותה קודם. הוא דורש זאת כשהמערכת שומשה (למשל חוברה) מאז הבדיקה המלאה האחרונה שלה, וזה המצב הרגיל. בדוגמה החיבור קרה אחרי היצירה, ולכן הבקשה הופיעה:

Bash
resize2fs s.img 40M
e2fsck -f s.img
resize2fs s.img 40M
פלט
resize2fs 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 KiB8,192בלוק 8193

אפשר לראות את המיקומים האמיתיים. הכלי dumpe2fs מציג אותם, וכדאי להשוות בין שתי מערכות עם גדלי בלוק שונים (שורת הגרסה ש-dumpe2fs מדפיס ל-stderr הושמטה מהפלט):

Bash
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:

Bash
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-ok
פלט
mount: /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:

Bash
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.md
פלט
type=[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 מתווספים המספרים:

Bash
mkdir proj
touch proj/main.c
mkdir proj/lib
ls -ai proj
פלט
20038 .
19952 ..
20045 lib
20044 main.c

השורה . מצביעה על התיקייה עצמה, ו-.. על תיקיית האב. לכל פריט אחר יש מספר משלו, וזה כל מה שהתיקייה יודעת עליו: הרשאות וגודל נמצאים ב-inode שאליו המספר מוביל.

כך הליבה פותחת את הנתיב /srv/shop/orders.csv:

  1. היא מתחילה בתיקיית השורש. בכל מערכת ext זה תמיד inode מספר 2, ולכן אין צורך לחפש אותו.
  2. היא קוראת את הבלוקים של השורש ומחפשת בהם את השורה srv, ומוצאת את מספר ה-inode שלה.
  3. אותה פעולה חוזרת בתוך srv עבור shop, ואחר כך בתוך shop עבור orders.csv.
  4. ה-inode האחרון נותן את ההרשאות ואת מיקום הנתונים, וממנו קוראים את התוכן.
מספר 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 בין הצעדים:

Bash
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קיצורמה מעדכן אותה
Accessatimeקריאת התוכן. עם relatime (הנפוץ כיום) העדכון קורה רק אם Access לא חדשה יותר מ-Modify או מ-Change, או שעברה יממה
Modifymtimeשינוי תוכן הקובץ, ורק הוא
Changectimeכל שינוי ב-inode עצמו: הרשאות, בעלים, מונה קישורים, שם, וגם שינוי תוכן
Birthcrtimeרגע היצירה, פעם אחת בלבד (נשמרת ב-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. מה קורה להן במהלך הבוקר?

Bash
# 08:10
ln audit.csv audit.copy
# 09:45
echo "row" >> audit.csv
# 11:20
wc -l audit.csv
# 11:25
wc -l audit.csv
  • 08: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, זמן היצירה.

חזרה לתוכן העניינים

rm, קובץ פתוח ומתי המקום באמת חוזר

תקלה מוכרת מהשטח: המחיצה מלאה, מוחקים לוג ענק, ו-df לא זזה. בו בזמן du מדווחת על נפח קטן בהרבה ממה ש-df אומרת.

הסיבה לפער: du מטיילת על רשומות התיקיות ומחברת את הקבצים שיש להם שם, וקובץ מחוק אין לו רשומה, בעוד df סופרת את הבלוקים שמוקצים בפועל. פער גדול כזה הוא הסימן לקובץ שנמחק אבל עדיין פתוח אצל תהליך.

ההסבר נובע מהאופן ש-rm עובדת. היא קוראת לקריאת המערכת unlink, שמסירה רשומה אחת מהתיקייה ומורידה את מונה הקישורים ב-1, ואין לה "פח אשפה" ברמת מערכת הקבצים. את ה-inode ואת הבלוקים הליבה משחררת רק כששני תנאים מתקיימים יחד: המונה הגיע לאפס, ובמקביל אין תהליך שפתח את הקובץ וטרם סגר אותו.

אפשר לשחזר את המצב בקטן. המעטפת עצמה ($$ הוא מספר התהליך שלה) משמשת כתהליך ששומר קובץ פתוח:

Bash
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.

Bash
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 של היעד נשאר כמו שהיה:

Bash
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.cfg
פלט
keep.cfg inode=19956
keep.cfg after cp onto it: inode=19956
new
fresh.cfg inode=20038
copy.cfg inode=20045

keep.cfg נשאר באותו inode ותוכנו הוחלף, ואילו copy.cfg קיבל inode חדש. אם היעד הוא קישור קשיח לאותו קובץ מקור, cp מסרבת בהודעה are the same file.

עכשיו mv. בדוגמה נוצר קובץ של 3 MB, והוא עובר פעם אחת אל תיקייה שיושבת על אותה מחיצת ext4 ופעם אחת אל /dev/shm, שהיא מערכת קבצים אחרת (tmpfs). הקוד מדפיס את מספר ה-inode לפני ואחרי כל מעבר:

Bash
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.bin
פלט
before: 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 הוא דיסק חיצוני נפרד.

Bash
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, והנתונים הודפסו שוב:

Bash
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% בלבד.

Bash
df -i /var/lib/sessions
find /var/lib/sessions -type f -mtime +7 -delete

88% פנויים אומרים שהבלוקים אינם הבעיה, וההודעה אינה 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:

Bash
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:

Bash
rmmod llc
פלט
rmmod: 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 התקבל:

Bash
rmmod --wait llc
פלט
rmmod: 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 מדפיסה באיזה מצב המערכת עולה כברירת מחדל:

Bash
systemctl get-default
פלט
graphical.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 משנה רק את האתחול הבא.