דילוג לתוכן
  • חוקי הפורום
  • פופולרי
  • לא נפתר
  • משתמשים
  • חיפוש גוגל בפורום
  • צור קשר
עיצובים
  • Light
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • ברירת מחדל (ללא עיצוב (ברירת מחדל))
  • ללא עיצוב (ברירת מחדל)
כיווץ
מתמחים טופ
  1. דף הבית
  2. מחשבים וטכנולוגיה
  3. מערכות הפעלה
  4. מדריך | מהי מערכת ההפעלה? מדריך על מערכת ההפעלה – חתיכה אחרי חתיכה

מדריך | מהי מערכת ההפעלה? מדריך על מערכת ההפעלה – חתיכה אחרי חתיכה

מתוזמן נעוץ נעול הועבר מערכות הפעלה
1 פוסטים 1 כותבים 127 צפיות 6 עוקבים
  • מהישן לחדש
  • מהחדש לישן
  • הכי הרבה הצבעות
תגובה
  • תגובה כנושא
התחברו כדי לפרסם תגובה
נושא זה נמחק. רק משתמשים עם הרשאות מתאימות יוכלו לצפות בו.
  • אביעדא מחובר
    אביעדא מחובר
    אביעד
    מדריכים
    כתב נערך לאחרונה על ידי אביעד
    #1

    אז אחרי הפוסט שעשינו על חלקי המחשב בפרוטרוט עכשיו בעז"ה ניגש לשלב הבא- שהוא מערכות ההפעלה.
    אני שאלתי את עצמי כמה שאלות במהלך החיים (בטוח שחלקכם ג"כ..)
    מי זה 'האיש' שנמצא בתוך המחשב ומריץ לי פקודות?
    איך זה שאפליקציה יכולה לשמור קובץ על הדיסק – בלי לדעת איך עובד הדיסק בכלל?
    למה תוכנה שקרסה לא גוררת איתה את כל המחשב?
    ומי זה "הקרנל" שכולם מדברים עליו, והאם הוא חלק מהמחשב או סתם קובץ מסתורי במערכת?
    במדריך הזה פירקנו לגורמים את המוח מאחורי מערכת ההפעלה- מהקרנל ועד לחיצה בעכבר והתוצאה שרואים על המסך.
    בהצלחה ובהנאה לכולם!! 😄
    שימו לב!! אני לא לוקח אחריות על כל מה שכתבתי, את כל הדברים האלה למדתי במהלך השנה האחרונה -בעיקר מחבר טוב שהיה לו סבלנות להסביר לי את כל הנקודות הקטנות ע"י תיאורים יפים ומרתקים, אבל שוב- המדריך הזה הינו לעיון בלבד ככה שאל תנסו לעשות שינויים על פי מה שנאמר כאן.. קריאה מהנה 🙂

    מהי בכלל מערכת הפעלה?

    מערכת הפעלה (Operating System – OS) היא לא פחות מאשר 'המתווך' בין המשתמש, התוכנות, והחומרה. היא השכבה שמחברת בין הרצון שלך לערוך בתוכנה, להעתיק קבצים ואפילו לפתוח קובץ וורד. לבין האותות החשמליים שרצים בזיכרון ה־RAM ובכונן הקשיח.

    מה מערכת ההפעלה מראה לנו בעצם:

    אילו תוכנות ירוצו ומתי.

    איך הזיכרון יחולק בין תהליכים.

    איך מקלדת, עכבר, מסך, ואחסון יעבדו ביחד.

    ואפילו מה עומד מאחורי לחיצה פשוטה על כפתור Enter או Delete.

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

    פירוט תפקידי מערכת הפעלה

    ניהול תהליכים - להריץ תוכנות, להקצות להן זמן שהCPU ייתן להם.
    ניהול זיכרון - להקצות זיכרון (זמני- RAM) ולמנוע התנגשויות.
    ניהול קבצים - לארגן, לקרוא ולכתוב נתונים בדיסק.
    תקשורת עם חומרה - להשתמש בדרייברים כדי להפעיל מקלדת, עכבר, מדפסת וכו'.
    אבטחה והרשאות - לבדוק מי יכול לגשת למה, ואיך למנוע גישה מזיקה.
    ממשק משתמש - להציג חלונות, תפריטים וגרפיקה – או לחלופין, שורת פקודה.
    בעז"ה במדריך שלפנינו נשתדל לגעת בכל הדברים החשובים שיש במערכת הפעלה

    look

    חשוב להבין: מערכת ההפעלה אינה "עוד תוכנה". היא הבסיס שעליו כל שאר התוכנות רצות. היא מופעלת עם הדלקת המחשב (boot), שולטת בכל המשאבים, ומאפשרת לאפליקציות כמו דפדפן, עורך טקסט או משחק, לרוץ בלי להתעסק בפרטים הקטנים כמו "איך מקבלים קלט מעכבר".

    סוגי מערכות הפעלה נפוצות

    Windows – המערכת הנפוצה בעולם המשרדים והבית

    macOS – מערכת של אפל, מבוססת על UNIX

    Linux – שם כולל לאלפי הפצות מבוססות קרנל לינוקס, עם שליטה מוחלטת למשתמשים

    Android/iOS – גרסאות מותאמות לניידים, שמבוססות גם הן על קרנלים לינוקס/יוניקסיים
    יאללה עד כאן הבנו בכלל מהי מערכת ההפעלה ומהי יכולה לעשות, עכשיו נצלול לתוך החומר וננסה להבין איך זה קורה בעצם.

    הקרנל (Kernel): הלב של מערכת ההפעלה

    אז מה זה בכלל קרנל?

    הקרנל (Kernel) הוא הגרעין המרכזי של מערכת ההפעלה. אפשר לחשוב עליו כמו על מנהל־על (אבל שקט) שיושב עמוק בלב המערכת, ואחראי על הנושאים הכי רגישים והכי קריטיים: ניהול זיכרון, תהליכים, קלט/פלט, תקשורת עם רכיבי חומרה ועוד.

    ברגע שהמחשב נדלק – הקרנל הוא הדבר הראשון שמופעל, והוא נשאר בתפקוד עד כיבוי המערכת. כל בקשה שמגיעה מתוכנה – בין אם מדובר בפתיחת קובץ או בתזוזת עכבר – עוברת דרכו.

    אז למעשה, האם הקרנל הוא רכיב קוד או משהו אחר?

    הקרנל (Kernel) הוא קוד לכל דבר אבל בשונה מסתם קוד- הקרנל הוא לב ליבו של מערכת ההפעלה למרות שהקרנל לא מופיע כמסך או כחלון אבל הוא רץ כל הזמן- כי כל פעולה תלויה בו , ושולט בכל שאר הפעולות כמופיע לעיל- ולקמן.
    בלינוקס: vmlinuz הוא הקובץ של הקרנל (compressed binary).
    בוינדוס: ntoskrnl.exe הוא הקרנל הראשי של המערכת.

    explanation

    אפשר לחשוב על הקרנל כמו מנוע של רכב: אתה לא רואה אותו כשאתה נוהג (כמו שאתה לא רואה את הקרנל כשאתה פותח את וורד). אבל שום דבר לא עובד בלעדיו – ההגה, הדוושות, הגיר – כולם רק חוטים ופקודות. כשאתה לוחץ על דוושת הגז, זה כמו לקרוא ל־write() – הקרנל (המנוע) מתרגם את הפעולה לכוח ממשי

    איך הקרנל מתקשר עם שאר החלקים?

    באופן עקרוני, הקרנל מנותק מהשאר. הוא רץ ב־"מצב קרנל" (Kernel Mode), בנפרד מהיישומים שפותח המשתמש, שרצים ב־"מצב משתמש" (User Mode). ההפרדה הזו חיונית לשם ביטחון ויציבות – אפליקציה שמתרסקת לא תוכל להפיל את הקרנל.
    כשתוכנה רוצה לעשות משהו שלא מותר לה ישירות (כמו לגשת לקובץ, להקצות זיכרון, לשלוח נתון למדפסת), היא שולחת System Call – בקשה רשמית מהקרנל לבצע את הפעולה בשבילה.- שעליה נפרט בפרק -קריאות מערכת. (אפשר לגשת להציץ שם.. 😉 )

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

    למה צריך את ההפרדה הזאת בכלל?

    1. ביטחון: אפליקציה שרצה במצב משתמש לא יכולה לגעת בזיכרון של הקרנל או בגישה ישירה לחומרה. גם אם התוכנה נכתבה גרוע או אפילו זדונית – היא לא יכולה להרוס את המערכת כולה. זו חומת מגן מובנית.
    2. יציבות: אם דפדפן קורס – הקרנל לא קורס איתו. זו המשמעות של בידוד תהליכים – הקרנל ממשיך לפעול כרגיל, וסוגר רק את התהליך הבעייתי. בלי זה, כל תקלה קטנה הייתה מחייבת כיבוי/הפעלה מחדש של כל המחשב.
    3. בקרה ושליטה: הקרנל מקבל שליטה בלעדית על פעולות מסוכנות או עדינות: גישה לקבצים, תקשורת רשת, טעינת דרייברים וכו'. כל השאר – חייבים לבקש רשות ממנו, באמצעות system calls.

    למעשה איך זה עובד- איך עוברים בין המצבים?

    אם תוכנה במצב משתמש רוצה, למשל, לשמור קובץ:
    היא שולחת קריאת מערכת (system call) לקרנל (לשמור את הקובץ),
    המעבד מבצע מעבר למצב קרנל (privileged mode),
    הקרנל מבצע את הפעולה (כמו כתיבה לדיסק),
    לאחר מכן, חוזרים למצב משתמש, והתוכנה ממשיכה לרוץ.
    זה תהליך מובנה, שמבוצע במיליארדיות שנייה – אבל עם הגנה מוחלטת.

    explanation

    דימוי פשוט: תאר לך חדר בקרה גרעיני (הקרנל), ומבקר חוץ (תוכנה במצב משתמש). המבקר יכול לבקש לבצע פעולה – אבל רק דרך פקיד (system call), ולא מותר לו להיכנס לחדר בעצמו. אחרת, מספיק טעות אחת – ויש פיצוץ.

    כמה נקודות לסיכום:

    • הקרנל לא חשוף לתוכנה באופן ישיר – אין דרך לגשת ישירות לזיכרון שלו.
    • המעבד עצמו מבצע את המעבר בין המצבים. יש לו ביט מיוחד שנקרא CPU Mode Bit שמגדיר את ההרשאות.
    • קריאות מערכת הן כמו שערים מאובטחים – רק דרכן אפשר להיכנס "לקרנל לרגע" ולצאת.

    סוגי קרנלים:

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

    קרנל מונוליתי (Monolithic Kernel)

    כל הפונקציונליות נמצאת בתוך הקרנל עצמו – תזמון תהליכים, ניהול קבצים, דרייברים, ניהול זיכרון ועוד.
    אין כמעט הפרדה פנימית – הכול חלק ממקשה אחת.
    מערכת ההפעלה Linux משתמשת בקרנל זה

    יתרונות:

    מהיר במיוחד – אין צורך להעביר מידע בין רכיבים, הכול קורה בתוך הקרנל עצמו.
    גישה ישירה לחומרה – דבר חיוני במערכות שדורשות ביצועים גבוהים (כמו שרתים או משחקים).

    חסרונות:

    קריסה -כל תקלה קטנה יכולה להפיל את הקרנל כולו.
    קשה לתחזק – שינוי קטן בדרייבר או מודול עלול להשפיע על שאר הקרנל.
    אי נוחות - לרוב דורש אתחול לאחר כל שינוי או עדכון בקרנל.

    מיקרו־קרנל (Microkernel)

    הקרנל מכיל רק את הפונקציות המינימליות: תזמון, זיכרון, ו־IPC (תקשורת בין תהליכים).
    כל שאר הרכיבים – ניהול קבצים, דרייברים, מערכות קלט/פלט – רצים כתהליכים חיצוניים בקרב מצב משתמש.

    יתרונות:

    יציבות גבוהה מאוד – אם דרייבר נתקע, הקרנל ממשיך לעבוד.
    נוחות – אפשר להחליף או לעדכן רכיב בלי לאתחל את הקרנל.
    מאפשר בניית מערכות הפעלה מותאמות אישית, עם אבטחה גבוהה.

    חסרונות:

    ביצועים איטיים יותר – כי כל דבר דורש תקשורת בין תהליכים (כל פעולה קטנה → מעבר בין תהליכים).
    מורכבות גבוהה בתכנון – ניהול כל כך הרבה תהליכים נפרדים הוא אתגר.

    קרנל היברידי (Hybrid Kernel)

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

    יתרונות:

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

    חסרונות:

    מורכב -מורכב ליישום ולתחזוקה.
    עלול לסבול הן מחסרונות המונוליתי (חשיפה לתקלות) והן מהמיקרו (תקשורת בין מודולים).

    משימותיו של הקרנל בפועל

    1. ניהול זיכרון

    • להקצות זיכרון לכל תהליך.
    • לעקוב אחרי שימוש ולמנוע התנגשויות.
    • לנהל זיכרון וירטואלי: לדמות שיש יותר RAM ממה שיש בפועל.

    2. תזמון תהליכים (Scheduling)

    • להחליט מי מהתהליכים ירוץ על ה־CPU ומתי.
    • להפסיק תהליך אחד ולהעביר משאבים לאחר (Context Switch).
    • לתמוך בריבוי משימות אמיתי.

    3. מערכת קבצים וקלט/פלט

    • לתרגם פעולות כמו fopen() ו־read() לקריאות פיזיות לדיסק.
    • לגשר בין תוכנות ל־SSD, כונני USB או רשתות.

    4. דרייברים

    • הקרנל כולל מודולים שמדברים עם חומרות שונות: מקלדת, מצלמה, כרטיס רשת.
    • הדרייברים משמשים כ"מתרגמים" בין שפת החומרה לשפת הקרנל.

    5. אבטחה ובידוד

    • לוודא שתהליך לא פוגע באחר.
    • לנעול גישה לאזורים רגישים בזיכרון.
    • לאכוף הרשאות והרשאות משתמש.

    look

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

    יאללה נמאס כבר מהקרנל, נעבור לחלק הבא במערכת ההפעלה- הדרייברים.

    מנהלי התקנים (דרייברים) – הידיים של הקרנל

    מה זה "מנהל התקן"?

    מנהל התקן (Driver) הוא תוכנה קטנה שמתפקדת כמו 'מתורגמן' בין הקרנל לבין רכיב חומרה מסוים.

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

    explanation

    דוגמה פשוטה: אתה פותח את תוכנת ההקלטה שלך, ולוחץ "הקלט":

    1. התוכנה מבקשת מהקרנל להתחיל להאזין למיקרופון.
    2. הקרנל פונה לdriver של המיקרופון.
    3. הדרייבר מתרגם את הפקודה לפורמט שהמיקרופון מבין (למשל: הפעלת ערוץ כניסה, הגדרת דגימה).
    4. המיקרופון שולח את המידע דרך USB או כניסת קול - הדרייבר אוסף ומסדר את הנתונים - הקרנל מזרים אותם לתוכנה שלך.

    איך הקרנל מדבר עם הדרייברים?

    בקרנלים מונוליטיים כמו Linux:

    • הדרייברים הם חלק בלתי נפרד מהקרנל או ניתנים לטעינה כ־מודולים (modules) – קבצים עם סיומת .ko (כמו kernel objects).
    • הקרנל טוען את הדרייברים לפי הצורך – למשל כשטוענים דיסק חדש, או כשמכניסים כבל רשת.

    בקרנלים היברידיים (כמו Windows או macOS):

    • הדרייברים לרוב רצים כשירותי מערכת מיוחדים, עם הרשאות גישה ישירה לחומרה.
    • כל דרייבר מקבל מבנה נתונים קבוע (interface) שהקרנל יודע לקרוא.

    סוגי דרייברים – מה הם יודעים לעשות?

    סוג דרייבר תפקידו
    דיסקים (Disk) קריאה וכתיבה לקבצים, הבנת פורמטים (NTFS, ext4), ניהול מחיצות
    קול (Audio) הפעלת כניסות ויציאות שמע, עיבוד אודיו בזמן אמת
    USB ו־PCI ניהול התקני קלט/פלט: עכברים, מקלדות, מצלמות
    רשת (Network) קישור למתאמים (Ethernet, Wi-Fi), ניהול מנות TCP/IP
    גרפיקה (GPU) ציור מסכים, האצת גרפיקה, עבודה מול OpenGL/DirectX
    תוכנה-מדומה כוננים וירטואליים, מכשירים מדומים, או שכבות הצפנה

    מה קורה כשיש דרייבר חסר?

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

    דוגמה טכנית: איך דרייבר רשת עובד?

    1. אתה פותח את הדפדפן.
    2. הדפדפן שולח בקשה ל־www.google.com → הקרנל יודע שזה דורש שליחת מידע דרך הרשת.
    3. הקרנל מעביר את הבקשה לדרייבר של כרטיס הרשת.
    4. הדרייבר מתרגם את הבקשה לפורמט שמתאים לשכבת החומרה (כמו Ethernet או WiFi).
    5. כרטיס הרשת שולח את המידע דרך הכבל/הגלים.
    6. כשהתגובה חוזרת – אותה שרשרת מתהפכת: הדרייבר קולט → הקרנל מעבד → הדפדפן מציג.

    האם דרייברים מסוכנים?

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

    • לקרוא זיכרון של תהליכים אחרים
    • לשתק רכיבי מערכת
    • לפתוח דלתות אחוריות לחומרה

    לכן במערכות כמו Windows או macOS, מומלץ ורצוי שדרייברים יהיו חתומים דיגיטלית, ומאושרים ע"י יצרן מהימן.

    לסיכום:

    דרייבר הוא כמו מתורגמן קבוע בין הקרנל לחומרה – בלי הדרייברים, הקרנל עיוור וחרש.
    הם מאפשרים לקרנל "לדבר" עם מדפסת, דיסק, מקלדת, רשת וגרפיקה – והם חלק קריטי בכל מערכת הפעלה. (זה לא אומר שהם יהיו חלק חיצוני מהקרנל- כמו קרנל של לינוקס)

    קריאות מערכת – איך תוכנה מדברת עם הקרנל

    הרעיון המרכזי:

    התוכנה שלך לא מדברת עם החומרה. היא גם לא מדברת ישירות עם הקרנל.
    היא רק מבקשת מהקרנל לעשות עבורה פעולות – באמצעות System Calls, או בעברית: קריאות מערכת.


    למה צריך את זה?

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


    איך זה עובד בפועל?

    1. תוכנה משתמשת בפונקציה סטנדרטית (למשל open() או read()).
    2. הפונקציה הזו מבצעת קריאת מערכת (system call).
    3. המעבד עובר מ־מצב משתמש (User Mode) ל־מצב קרנל (Kernel Mode).
    4. הקרנל מקבל את הבקשה, מבצע אותה, ומחזיר את התוצאה.
    5. המעבד חוזר למצב משתמש, והתוכנה ממשיכה.

    לדוגמה: כתיבת קובץ

    נניח שכתבת קוד ב־C:

    int fd = open("log.txt", O_WRONLY);
    write(fd, "שלום עולם\n", 11);
    

    מה קורה מתחת לפני השטח?

    שלב תיאור
    1. הפונקציה open() קוראת ל־קריאת מערכת בשם SYS_open
    2. המעבד משנה מצב → עובר ל־Kernel Mode
    3. הקרנל מקצה descriptor לקובץ, פותח אותו, ומחזיר מספר מזהה
    4. הפונקציה write() קוראת ל־SYS_write עם מזהה הקובץ
    5. הקרנל כותב את המידע לדיסק דרך דרייבר הקבצים
    6. הקריאה מסתיימת → חזרה ל־User Mode

    קריאות מערכת נפוצות (בלינוקס לדוגמה)

    שם קריאה תיאור
    read() קריאת נתונים מקובץ, התקן או קלט
    write() כתיבה לקובץ או התקן
    open() פתיחת קובץ
    close() סגירת קובץ
    fork() יצירת תהליך חדש
    execve() טעינת תוכנית אחרת במקום הנוכחית
    wait() המתנה לתהליך בן
    mmap() מיפוי קובץ לזיכרון
    ioctl() שליחת פקודות מיוחדות לדרייבר
    kill() שליחת אות (signal) לתהליך

    כיצד קריאות מערכת שונות מפונקציות רגילות?

    היבט קריאה רגילה (printf) קריאת מערכת (write)
    רצה ב־ מצב משתמש מצב קרנל
    גישה ל־ זיכרון מקומי בלבד גישה לקבצים, חומרה
    סיכון בטוחה יחסית דורשת טיפול מיוחד
    אבטחה לא בודקת הרשאות הקרנל מוודא הרשאות

    איך המעבד "קופץ" לקרנל?

    בתוך הקוד אין באמת קריאה ל־read() של הקרנל. יש פקודת מכונה מיוחדת:
    למשל, ב־x86_64 זה:

    syscall
    

    זו פקודה ברמת מעבד שמעבירה שליטה לקרנל – דרך שער מיוחד (system call gate).
    המעבד משנה הקשר (context switch), שומר מצבים, ועובר לכתובת שהקרנל הגדיר מראש.


    למה זה חשוב לאבטחה?

    • אין תוכנה שיכולה לגעת בזיכרון של הקרנל ישירות – רק דרך קריאות מערכת.
    • הקרנל תמיד בודק: מי אתה (הדרייבר)? האם מותר לך לכתוב\לקרוא לקובץ הזה?
    • זה מה שמאפשר בידוד בין תהליכים, הגנה על סיסמאות, ומניעת קריסות.

    מה זה בכלל "קריאת מערכת"?

    (המחשה של צ'ט GPT:)
    תאר לך שאתה תוכנה (למשל Word).
    ואתה רוצה לשמור קובץ.
    אבל – אתה לא יכול לגשת לדיסק בעצמך. זה מסוכן – תוכל לשבור דברים, למחוק דברים חשובים, לגשת לקבצים של אחרים…

    אז מה אתה עושה?

    אתה בעצם 'מתקשר' לקרנל – שומר הראש של המחשב – ואומר לו:

    "שלום, אני רוצה שתשמור את הקובץ הזה בשם דוח.docx. הנה התוכן."

    זה נקרא קריאת מערכת (System Call).

    ולמה אני לא יכול לעשות את זה לבד?

    כי הקרנל לא סומך עליך 😉 . אתה יכול להיות באגי. אתה יכול להיות וירוס.
    ולכן – הקרנל שומר את כל הכוח לעצמו:

    • רק הוא יכול לגעת בדיסק.
    • רק הוא יכול לקרוא מהמקלדת.
    • רק הוא יכול לשלוח מידע לרשת.

    אתה – כתוכנה – יכול רק לבקש ממנו.

    תהליכים וניהול משאבים

    אממ כאן זה קצת מורכב לי, אז נחלק את זה לשלושה תתי קטגוריות. (תהליכים, מתזמן הריצה, מעברי הקשר)

    תהליך (Process):

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

    • אזור זיכרון משלו (קוד, משתנים, מחסנית)
    • מזהה ייחודי (PID)
    • גישה לקבצים פתוחים
    • זכויות מערכת (אם הוא מנהל, אם הוא רגיל וכד')

    אשכול (Thread):

    אשכול הוא למעשה פעולה אחת מתוך תהליך, לדוגמא - יש לנו תוכנה שדורשת כמה דברים- גם וידאו, גם הרצת נתונים וכו' אז כל פעולה נחשבת כאשכול (למרות שבהיגיון זה נשמע לי הפוך- אבל ככה זה) וזה טוב כי ככה אפשר לנצל יותר טוב הרבה ליבות

    מתזמן הריצה (Scheduler)

    הקרנל שולט על כל המעבדים במחשב. אבל יש הרבה יותר תהליכים ממה שיש ליבות פנויות. אז מישהו צריך להחליט איזה תהליך ירוץ עכשיו.
    זה התפקיד של ה־Scheduler הוא יושב בתוך הקרנל, ומקצה "חתיכות זמן" (time slices) לכל תהליך.

    איך הוא מחליט?

    יש כמה אפשרויות:

    • Round Robin – כל תהליך מקבל חתיכה של זמן לפי התור
    • Priorities – לתהליכים חשובים יש עדיפות (למשל, של מערכת)
    • I/O Bound מול CPU Bound – תהליך שמחכה לקלט/פלט, יפנה מהר את המקום

    מעברי הקשר (Context Switch)

    נניח שתהליך X רץ, ועכשיו צריך לפנות מקום לתהליך Y. אבל אי אפשר פשוט "להחליף". צריך:

    1. לשמור את המצב של X (איפה הוא היה, ערכי רגיסטרים, מצב המחסנית)
    2. לשחזר את המצב של Y (כמו להחזיר אותו לנקודה שהפסיק בה)

    המעבר הזה – לשמור אחד ולהטעין אחר – נקרא Context Switch.

    למה זה חשוב?

    • זה מה שמאפשר למחשב להיראות "רב־משימתי", אפילו עם ליבה אחת.
    • אבל זה גוזל זמן וגורם לאובדן יעילות, לכן עושים את זה רק כשצריך.

    לדוגמה:

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

    • כל אחד מאלו הוא תהליך.
    • בתוך כל תהליך רצים Threads (למשל, בכרום – Thread עבור כל טאב).
    • הקרנל כל הזמן מחליף בין תהליכים (Context Switch).
    • Scheduler מחליט מי מקבל רשות לרוץ.
    • כל תהליך חושב שהוא לבד במערכת...

    מערכת קבצים

    מה זה בעצם מערכת קבצים?

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

    • למפות איזה בלוקים שייכים לאיזה קובץ.
    • לנהל את המרחב הפנוי.
    • לאכוף הרשאות ובעלות.
    • לשמור על עקביות במקרה של קריסה.

    מערכת הקבצים שומרת גם מטא־נתונים – כלומר, מידע על הקובץ, לא רק את תוכנו.

    רכיבי מערכת קבצים:

    Inode (בלינוקס, ext4): מזהה ייחודי של קובץ. כולל את כל המטא־נתונים: תאריכים, הרשאות, בעלות, מיקומי בלוקים
    Data Blocks: איפה התוכן האמיתי של הקובץ מאוחסן
    Directory Table: רשימה של שמות קבצים ותיקיות (קישור בין שם לבין inode)
    Superblock: מידע על כל מערכת הקבצים: גודל, כמה inodes, כמה בלוקים, ועוד
    Journal: יומן פעולות כדי להבטיח עקביות – משמש בעיקר לשחזור אחרי קריסה

    אז בואו נסכם: אם ניצור קובץ x.txt, יקרה הדברים הבאים:

    1. יוקצה inode חדש עם מספר מזהה ייחודי (למשל 1002)
    2. תיוצר רשומה ב־Directory Table שמקשרת:
      x.txt → inode 1002
    3. התוכן שלך יכתב לבלוקים 4321, 4322, 4323
    4. ה־inode ישמור: "הקובץ מתחיל בבלוק 4321 וממשיך הלאה..."

    קריאה\כתיבה:

    תמיד אנחנו קונים דיסק אונקי או כרטיס זיכרון ורואים מהירות קריאה ומהירות כתיבה. עכשיו בעז"ה נבין מה כל אחד מהם אומר.

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

    • לא משנה את התוכן המקורי.
    • עלול להיכשל אם אין הרשאות גישה, או אם הקובץ לא קיים.

    אבל דווקא בגלל זה הקריאה מהירה יחסית לכתיבה (כי אין צורך בלכתוב ממש לדיסק).

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

    • משנה את המידע הקיים או מוסיפה חדש.
    • עשויה להיות בלתי הפיכה– במיוחד אם אין גיבוי.

    ובגלל זה לרוב יותר כתיבה איטית מקריאה, כי מערכות אחסון צריכות לכתוב פיזית את המידע.

    איך קובץ נכתב בפועל (Write Flow)

    נניח שאתה שומר קובץ של 3MB:

    1. הקרנל מקבל בקשה מהאפליקציה.
    2. מערכת הקבצים מחפשת מקום ריק (בלוקים).
    3. תוכן הקובץ נכתב לזיכרון המטמון (Write Cache).
    4. בלוקים אלה מסומנים כ"תפוסים" בטבלת מערכת הקבצים.
    5. המטא־נתונים (inode) נרשמים ביומן.
    6. לאחר מכן מתבצע כתיבה לדיסק, לרוב בצורה "דחויה" (Delayed Write).

    explanation

    לפי מה שראינו עכשיו יוצא משהו מעניין: כשאתה מוחק קובץ הקובץ לא באמת נמחק מייד! מערכת הקבצים רק: מסירה את הקישור (השם של הקובץ) מה־Directory Table. ומסמנת את ה־inode והבלוקים שלו כפנויים לשימוש עתידי וממילא, כל עוד המידע לא שוכתב – ניתן לשחזר אותו עם תוכנות מתאימות-תוכנות שיחזור למיניהם.

    סוגי מערכות קבצים

    Windows – NTFS:
    • שומר הרשאות מתקדמות (ACLs)
    • תומך בהצפנה, דחיסה, קבצים ענקיים
    • כולל יומן (journal) פנימי לשחזור מהיר
    • משתמש ב־MFT (Master File Table) – המקביל ל־inode
    Linux – ext4:
    • ביצועים גבוהים
    • תמיכה ב־journaling
    • יש inode לכל קובץ, ו־superblock למידע כללי
    • מערכת פשוטה יותר ועמידה
    USB – exFAT / FAT32:
    • לא תומכות בהרשאות
    • פשוטות – מיועדות לשיתוף בין מערכות
    • exFAT תומכת בקבצים גדולים, FAT32 מוגבלת ל־4GB לקובץ

    ממשק המשתמש

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

    CLI - Command Line Interface

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

    GUI – Graphical User Interface

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

    איך מערכת הפעלה מריצה GUI – שלב אחרי שלב

    ממשק משתמש גרפי (GUI) אינו "רק תוספת בעיצוב", אלא שכבה על גבי שכבה:

    1. הקרנל (Kernel) – השכבה הכי תחתונה.
      מאפשר גישה לחומרה, ניהול זיכרון, תהליכים, וקלט (עכבר, מקלדת).
    2. מערכת תצוגה גרפית – כמו X Server או Wayland.
      מתווכת בין האפליקציות לבין כרטיס המסך.
    3. מנהל חלונות (Window Manager) – אחראי על עיצוב, גודל, תזוזה, מסגרות, תפריטים.
    4. סביבת שולחן עבודה (Desktop Environment) – מספקת סרגלים, כפתורים, תפריטים, אייקונים.
    5. אפליקציות גרפיות – סייר קבצים, דפדפן, עורך טקסט וכו'.

    עכשיו ננסה להמחיש עד כמה שאפשר- מה קורה בכל פעולת מחשב:

    שלב 1: הפעלת מערכת הפעלה – הקרנל נכנס לפעולה

    כאשר אתה מפעיל את המחשב:

    1. ה-BIOS/UEFI טוען את הקרנל מהדיסק
    2. הקרנל מבצע:
    • זיהוי חומרה (כרטיס מסך, עכבר, מקלדת)
    • טעינת דרייברים לכל רכיב
    • הקצאת Framebuffer – אזור בזיכרון שבו נכתב מה יוצג על המסך.

    עד כאן – אין GUI.
    אם תישאר בשלב הזה, תראה רק שורת פקודה (CLI) כמו בלינוקס.

    שלב 2: טעינת ה־Display Server (כמו X או Wayland)

    הקרנל מאפשר שימוש בכרטיס המסך, אבל לא מצייר.
    מי שאחראי על זה זה שרת תצוגה גרפית (Display Server), כמו:

    • Xorg / X11 – הוותיק והנפוץ בלינוקס.
    • Wayland – מודרני יותר, עם פחות שכבות תיווך.
    תפקידו של ה־Display Server (שרת תצוגה גרפית):
    • ליצור חלונות גרפיים לתוכנות.
    • להאזין לקלט מהעכבר והמקשים.
    • להודיע לתוכנה מתי להזיז, לצייר או לעדכן חלון.
    • להחזיק את "הרכב המסך" – אילו חלונות נמצאים, באיזה מקום, איזה פעיל.

    שלב 3: מנהל החלונות (Window Manager)

    תוך כדי ריצת ה־Display Server, נטען גם מנהל חלונות.

    תפקידו של Window Manager (מנהל החלונות):
    • להוסיף מסגרות, כפתור סגירה, מינימיזציה וכו'.
    • לאפשר גרירה ושינוי גודל לחלונות.
    • לזהות מהו החלון הפעיל.
    • לבצע שכבות Z (איזה חלון נמצא מעל מה).

    שלב 4: סביבת שולחן עבודה (Desktop Environment)

    אם ה־Window Manager אחראי על התצורה של החלונות עצמם,
    Desktop Environment אחראי על כל ה"מסביב":

    • שולחן עבודה עם רקע.
    • תפריטי התחלה.
    • סרגלי משימות.
    • שלטים גרפיים כמו שומר מסך, סייר קבצים.

    לסיכום

    דוגמה לפעולה פשוטה – פתיחת תיקייה:

    1. אתה לוחץ פעמיים על אייקון
    • הלחיצה מזוהה ע"י הקרנל (Interrupt).
    • הקרנל מעביר את הנתון ל־X Server.
    2. X Server מעדכן את האפליקציה ש"נלחץ האייקון".
    • האפליקציה (כמו Explorer או Nautilus) יודעת שזו תיקיה → פותחת חלון חדש.
    3. האפליקציה מציירת לתוך חלון – בתוך ה־Framebuffer.
    • הקרנל נותן גישה לזיכרון גרפי.
    • התמונה נשלחת לכרטיס המסך.

    בונוס 😉 איך באמת מציירים למסך?

    זיכרון מסך – Framebuffer- זהו אזור בזיכרון שבו נשמרת תמונה בגודל המסך.
    לדוגמה: 1920x1080 פיקסלים × 32 ביט צבע → בערך 8MB זיכרון.
    כל פיקסל נכתב כקוד צבע (RGB).
    האפליקציה פשוט "ממלאת את הזיכרון", והכרטיס הגרפי דואג להציג זאת למסך.

    סיכום דסיכום: מה באמת קורה כשאתה רואה אייקון על המסך

    1. הקרנל מפעיל את המחשב ונותן דרייברים לקלט/פלט.
    2. עולה ה־Display Server (X / Wayland).
    3. נטען Window Manager – מסדר חלונות, מסגרות.
    4. סביבת שולחן עבודה מוסיפה תפריטים ורקע.
    5. אתה מזיז עכבר → הקרנל מעדכן את X.
    6. אתה לוחץ על תיקייה → אפליקציית קבצים נפתחת.
    7. האפליקציה מבקשת מהקרנל לקרוא את הדיסק.
    8. הקרנל מאשר, שולף מידע.
    9. האפליקציה מציירת את התוכן לזיכרון מסך.
    10. הקרנל מאשר לכרטיס הגרפי להציג את זה.

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

    רק בקשה אחת - נא לא להגיב כאן!!! בשביל זה יש פוסט מסודר כאן
    ושוב- למי שלא ראה את הפוסט על חלקי המחשב שיערב לו 😉

    לכל המדריכים שלי
    https://mitmachim.top/topic/82032

    תגובה 1 תגובה אחרונה
    32
    • אביעדא אביעד התייחס לנושא זה
    • אביעדא אביעד התייחס לנושא זה
    • אביעדא אביעד התייחס לנושא זה

    • התחברות

    • אין לך חשבון עדיין? הרשמה

    • התחברו או הירשמו כדי לחפש.
    • פוסט ראשון
      פוסט אחרון
    0
    • חוקי הפורום
    • פופולרי
    • לא נפתר
    • משתמשים
    • חיפוש גוגל בפורום
    • צור קשר