# מערכת ההפעלה: Kernel, תהליכים, קבצים והרשאות<no value>

## מה בשיעור

השיעור הזה בנוי מכמה פרקים קצרים, באותו סדר כמו במצגת:

1. **פרק ראשון** — מהי מערכת הפעלה ומה זה Kernel
2. **פרק שני** — Program לעומת Process וניהול זיכרון
3. **פרק שלישי** — File System, משתמשים והרשאות

## פרק ראשון: מהי מערכת הפעלה ומה זה Kernel

### מה נלמד?

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

- מהי **מערכת הפעלה** (Operating System, ובקיצור **OS**).
- מה היא מנהלת ולמה.
- מהו **Kernel** — הליבה של מערכת ההפעלה.
- איך הקוד שלנו "מבקש" ממנה דברים, דרך **System Call**.

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

כל `print`, כל פתיחת קובץ, כל חיבור לאינטרנט ובנושא Backend ומסדי נתונים כל שרת — **הכול עובר דרך מערכת ההפעלה**. כשתקבלו שגיאה כמו `PermissionError` או `Address already in use`, היא מגיעה ממערכת ההפעלה. כדי להבין את השגיאה צריך להבין מי שלח אותה ולמה.

בנוסף, רוב השרתים בעולם רצים על **Linux**. גם אם אתם עובדים ב-Windows, בעבודה תפגשו Linux, ולכן חשוב להבין את הרעיונות המשותפים לכל מערכות ההפעלה.

### הסבר מהבסיס

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

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

דוגמאות: **Windows**, **macOS**, **Linux** (Ubuntu, Debian...), **Android**, **iOS**.

{{< box "analogy" "אנלוגיה: מנהל בניין" >}}
דמיינו בניין משרדים עם הרבה חברות (תוכנות). יש חשמל, מעליות, חדרי ישיבות ומחסן (משאבים: CPU, RAM, דיסק, רשת). אם כל חברה הייתה ניגשת ישירות ללוח החשמל ולוקחת כמה שבא לה — היה כאוס. **מנהל הבניין** (מערכת ההפעלה) מחלק את המשאבים, מוודא שאף חברה לא נכנסת למשרד של חברה אחרת, ומחזיק את המפתחות לכל דלת.
{{< /box >}}

#### חמשת התפקידים המרכזיים

| תפקיד | מה זה אומר | דוגמה מהקוד שלנו |
|---|---|---|
| **ניהול תהליכים** (Process Management) | יוצרת תהליכים, מחלקת ביניהם זמן CPU, מסיימת אותם. | כל `python file.py` יוצר Process חדש. |
| **ניהול זיכרון** (Memory Management) | נותנת לכל תהליך אזור RAM משלו ומונעת מתהליך אחד לגעת בזיכרון של אחר. | המשתנים שלנו חיים באזור שמערכת ההפעלה הקצתה. |
| **ניהול קבצים** (File System) | מארגנת את הדיסק בתיקיות וקבצים, וקוראת וכותבת עבורנו. | פתיחת קובץ, שמירה, מחיקה. |
| **משתמשים והרשאות** (Users & Permissions) | מי מחובר, ומה מותר לו לעשות. | `PermissionError` כשמנסים לכתוב לתיקיית מערכת. |
| **ניהול חומרה** (Device Management) | מדברת עם המקלדת, המסך, כרטיס הרשת והדיסק דרך **Drivers**. | `print` מגיע למסך, ובקשת HTTP יוצאת דרך כרטיס הרשת. |

#### מהו Kernel?

**Kernel** (גרעין / ליבה) הוא **החלק המרכזי והמוגן ביותר** של מערכת ההפעלה. הוא נטען ראשון ל-RAM ונשאר שם כל הזמן. הוא זה שבאמת מבצע את חמשת התפקידים שלמעלה.

כל השאר, כמו שולחן העבודה, סייר הקבצים, ה-Terminal והדפדפן, הן **תוכנות רגילות** שרצות "מעל" ה-Kernel.

#### Kernel Mode מול User Mode

המעבד יודע לעבוד בשני מצבים:

- **Kernel Mode** — גישה מלאה לכל החומרה ולכל הזיכרון. רק ה-Kernel רץ כך.
- **User Mode** — גישה מוגבלת. כל התוכנות שלנו, כולל Python, רצות כך.

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

#### System Call — לבקש מה-Kernel

אז איך תוכנה ב-User Mode כותבת לקובץ או שולחת מידע לרשת? היא **מבקשת** מה-Kernel. הבקשה הזו נקראת **System Call** (קריאת מערכת).

```text
Your Python code:       print("Hi")
        │
Python interpreter:     "I need to write 'Hi' to the screen"
        │   System Call (write)
        ▼
Kernel (Kernel Mode):   checks permissions → talks to the screen driver
        │
        ▼
Hardware:               the text appears
```

{{< box "term" "מילון" >}}
- **Operating System (OS)** — תוכנה שמנהלת את משאבי המחשב.
- **Kernel** — הליבה המוגנת של ה-OS. רצה תמיד ומבצעת את הניהול בפועל.
- **Driver** — תוכנה קטנה שמלמדת את ה-Kernel לדבר עם רכיב חומרה מסוים.
- **System Call** — בקשה של תוכנה מה-Kernel לבצע פעולה מוגנת.
- **User Mode / Kernel Mode** — מצב מוגבל לתוכנות רגילות / מצב מלא ל-Kernel.
{{< /box >}}

### מערכות הפעלה נפוצות

| מערכת הפעלה | איפה פוגשים אותה | ה-Shell של ה-Terminal |
|---|---|---|
| **Windows** | רוב המחשבים האישיים | PowerShell |
| **macOS** | מחשבי Apple | zsh |
| **Linux** | רוב השרתים בענן, ומחשבים של מפתחים | Bash |
| **Android / iOS** | טלפונים וטאבלטים | — |

כולן עושות את אותם חמשת התפקידים — תהליכים, זיכרון, קבצים, משתמשים והרשאות, חומרה — ולכולן יש Kernel. ההבדלים הם בעיקר בממשק, בפקודות של ה-Terminal ובמבנה התיקיות (למשל `C:\` ב-Windows מול `/` ב-Mac ו-Linux).

**למה זה חשוב למפתחים?** קוד שאתם כותבים על Windows ירוץ בסוף, הרבה פעמים, על שרת Linux בענן. לכן כדאי להכיר את ההבדלים — ולכתוב קוד שלא תלוי במערכת הפעלה אחת.

### טעות נפוצה

**הטעות: לנסות לגעת בקבצי מערכת "כדי לבדוק".**

תוכנה של משתמש רגיל מנסה, למשל, למחוק קובץ ששייך למערכת ההפעלה (בתיקייה `C:\Windows\System32`). מה שקורה:

1. התוכנה רצה ב-**User Mode**, ולכן היא לא ניגשת לדיסק בעצמה — היא שולחת **System Call** ל-Kernel.
2. ה-Kernel בודק הרשאות, ורואה שלמשתמש הרגיל אין הרשאת כתיבה לקובץ הזה.
3. הבקשה נדחית, והתוכנה מקבלת **שגיאת הרשאה** ("Access is denied" / `PermissionError`).

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

### סיכום

- **מערכת הפעלה** מנהלת את משאבי המחשב: תהליכים, זיכרון, קבצים, משתמשים והרשאות, וחומרה.
- **Kernel** הוא הלב המוגן שלה ורץ ב-**Kernel Mode**. התוכנות שלנו רצות ב-**User Mode**.
- תוכנה מבקשת שירות מה-Kernel דרך **System Call**: כתיבה למסך, פתיחת קובץ, תקשורת.
- שגיאות הרשאה מגיעות ממערכת ההפעלה — היא זו שבודקת ומסרבת.
- **Windows**, **macOS** ו-**Linux** במחשבים ובשרתים, **Android** ו-**iOS** בטלפונים — כולן עם אותם תפקידים בסיסיים.

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### דוקומנטציה רשמית

- [User mode and kernel mode](https://learn.microsoft.com/en-us/windows-hardware/drivers/gettingstarted/user-mode-and-kernel-mode) — ה-Kernel ומה מותר לתוכנות רגילות

<!-- docs:end -->

## פרק שני: Program לעומת Process וניהול זיכרון

### מה נלמד?

- מה ההבדל בין **Program** (תוכנה) ל-**Process** (תהליך).
- איך מערכת ההפעלה מריצה עשרות תהליכים "בבת אחת" — **Scheduling**.
- איך היא מנהלת את ה-RAM — **Memory Management**.
- איך רואים ועוצרים תהליכים מה-Terminal.

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

- בנושא Backend ומסדי נתונים נריץ **שרת**. שרת הוא Process שלא נגמר. אם תריצו אותו פעמיים, השני ייכשל, כי הראשון עדיין רץ ותופס את הכתובת שלו. בלי להבין Process זה נראה כמו קסם.
- כשתוכנית "נתקעת", צריך לדעת איך למצוא את התהליך ולעצור אותו.
- **Memory Leak** (דליפת זיכרון), כלומר תוכנית שהזיכרון שלה רק גדל, היא באג שמחפשים בעזרת כלי ניטור תהליכים.

### הסבר מהבסיס

#### Program — המתכון. Process — הבישול.

- **Program** = קובץ על ה-Storage שמכיל הוראות. הוא סטטי: לא עושה כלום, רק שוכב על הדיסק. דוגמאות: `python.exe`, `chrome.exe`, `hello.py`.
- **Process** = **מופע רץ** של תוכנה. הוא דינמי: יש לו זיכרון ב-RAM, PID, ומצב (רץ / ממתין / מסתיים).

**נקודה חשובה:** מתוכנה אחת אפשר להריץ **כמה תהליכים במקביל**. פתחתם 3 חלונות של VS Code? יש תוכנה אחת ו-3 תהליכים (ובפועל יותר, כי דפדפנים ועורכים מודרניים מפצלים את עצמם לכמה תהליכים).

{{< box "analogy" "אנלוגיה" >}}
**Program** = מתכון לעוגה שכתוב בספר. **Process** = עוגה שנאפית עכשיו בתנור. מאותו מתכון אפשר לאפות שלוש עוגות במקביל בשלושה תנורים. לכל אחת יש מצב משלה: אחת כבר תפחה, אחת עוד בתחילת הדרך.
{{< /box >}}

#### מה יש לכל Process?

| רכיב | הסבר |
|---|---|
| **PID** | מספר מזהה ייחודי. |
| **Memory Space** | אזור RAM פרטי: הקוד, המשתנים והנתונים. |
| **State** | מצב: Running (רץ על CPU), Ready (ממתין לתורו), Waiting (ממתין למשהו חיצוני, כמו קובץ או רשת). |
| **Owner** | איזה משתמש הריץ אותו, וזה קובע את ההרשאות שלו. |
| **Parent** | איזה תהליך יצר אותו. למשל: ה-Terminal הוא ה-Parent של `python`. |

#### Scheduling — איך כולם רצים "בבת אחת"?

יש לכם אולי 8 ליבות, אבל רצים במחשב 200 תהליכים. איך?

ה-**Scheduler** (מתזמן), חלק מה-Kernel, נותן לכל תהליך **פרוסת זמן** קצרה מאוד על ה-CPU (אלפיות שנייה), ואז עובר לתהליך הבא. זה קורה כל כך מהר שנראה כאילו כולם רצים בו-זמנית.

```text
Time →   | P1 | P2 | P3 | P1 | P2 | P3 | P1 | ...
          each slice ≈ a few milliseconds
```

תהליך ש**ממתין** (למשל ל-`time.sleep` או לתשובה מהרשת) לא מקבל זמן CPU בכלל עד שההמתנה נגמרת. לכן שרת שמחכה לבקשות כמעט לא צורך CPU.

#### Memory Management — ניהול זיכרון

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

1. **הקצאה** (Allocation) — כשנוצר תהליך, ובכל פעם שהוא צריך עוד זיכרון (למשל רשימה שגדלה), ה-OS נותן לו עוד RAM.
2. **בידוד** (Isolation) — כל תהליך רואה רק את הזיכרון שלו. תהליך אחד **לא יכול** לקרוא או לשנות את המשתנים של תהליך אחר. זה מונע מבאג באפליקציה אחת להשחית אפליקציה אחרת.
3. **שחרור** (Release) — כשתהליך מסתיים, כל ה-RAM שלו מוחזר למערכת.

ואם נגמר ה-RAM? מערכת ההפעלה מעבירה חלקים שלא בשימוש לדיסק (**Swap** ב-Linux/Mac, **Page File** ב-Windows). זה מונע קריסה, אבל המחשב נהיה איטי מאוד, כי הדיסק איטי.

{{< box "tip" "ומה עם Python?" >}}
ל-Python יש גם מנגנון פנימי משלה: **Garbage Collector** (אוסף אשפה). כשאובייקט כבר לא בשימוש (אף משתנה לא מצביע עליו), Python משחררת את הזיכרון שלו בעצמה. לכן ב-Python לא צריך "לשחרר זיכרון" ידנית כמו בשפות כמו C.
{{< /box >}}

### עץ תהליכים — מי הפעיל את מי

כל תהליך נוצר על ידי תהליך אחר — ה-**Parent** (הורה) שלו. כשמריצים תוכנית מה-Terminal, ה-Terminal הוא ההורה:

```text
explorer.exe          PID 4120
└── pwsh.exe          PID 9920   (Terminal)
    └── python.exe    PID 18044  (our program)
```

לכל תהליך יש **PID** משלו, ולכל אחד יש גם **PPID** — ה-PID של ההורה. כשסוגרים את ה-Terminal, בדרך כלל נסגרים גם התהליכים שהוא הפעיל.

### פקודות לצפייה ולעצירת תהליכים

את התהליכים אפשר לראות ב-Task Manager, ואפשר גם מה-Terminal. המרצה יציג את הפקודות על המסך:

**Windows (PowerShell):**

```powershell
Get-Process                    # list all processes
Get-Process python             # only processes named python
Stop-Process -Id 12345         # stop the process with PID 12345
```

**Mac / Linux (Bash / Zsh):**

```bash
ps aux                  # list all processes
ps aux | grep python    # filter lines that contain "python"
kill 12345              # stop the process with PID 12345
```

### טעות נפוצה

**הטעות: לחשוב ש-`Ctrl + C` גרם ל"שגיאה".** כשעוצרים תוכנית Python שרצה עם `Ctrl + C`, מופיע משהו כזה:

```text
^C
Traceback (most recent call last):
  ...
KeyboardInterrupt
```

- `Ctrl + C` שולח לתהליך **בקשה לעצור** — זה לא באג.
- `KeyboardInterrupt` אומר: "עצרתם אותי באמצע".
- כל ערך שהיה רק ב-RAM של התהליך — **אבד**, כי הזיכרון שלו שוחרר.

### סיכום

- **Program** הוא קובץ סטטי על הדיסק. **Process** הוא מופע רץ שלו, עם PID, זיכרון ומצב.
- מתוכנה אחת אפשר להריץ כמה תהליכים, ולכל אחד זיכרון **מבודד** משלו.
- ה-**Scheduler** מחלק זמן CPU בפרוסות קטנות, וכך הכול נראה מקבילי.
- **ניהול זיכרון:** הקצאה, בידוד ושחרור. כשה-RAM נגמר, משתמשים ב-Swap / Page File, וזה איטי.
- לכל תהליך יש **Parent**. עוצרים תוכנית עם `Ctrl + C`, ותהליך תקוע עם `Stop-Process` / `kill` לפי PID.

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### דוקומנטציה רשמית

- [About Processes and Threads](https://learn.microsoft.com/en-us/windows/win32/procthread/about-processes-and-threads) — Program מול Process
- [Virtual Address Space](https://learn.microsoft.com/en-us/windows/win32/memory/virtual-address-space) — לכל תהליך זיכרון משלו

<!-- docs:end -->

## פרק שלישי: File System, משתמשים והרשאות

### מה נלמד?

- **File System** — איך מערכת ההפעלה מארגנת את הדיסק.
- **נתיבים** (Paths) — מלא מול יחסי, ומה זה `.` ו-`..`.
- **משתמשים** (Users) — מי מחובר, ומיהו המשתמש "החזק".
- **הרשאות** (Permissions) — מי רשאי לעשות מה עם כל קובץ.

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

- בנושא Python נקרא ונכתוב **קבצים** מתוך Python. השגיאה הנפוצה ביותר שם היא `FileNotFoundError`, וכמעט תמיד הסיבה היא נתיב לא נכון.
- בנושא Backend ומסדי נתונים נשמור **Database** כקובץ. צריך לדעת איפה הוא נוצר.
- כשמתקינים כלים מקבלים לפעמים "Access denied" או "Permission denied". כדאי להבין למה זה קורה, ולא לפתור כל בעיה ב"הרצה כמנהל".

### הסבר מהבסיס

#### File System — מערכת הקבצים

הדיסק עצמו הוא רצף ענק של בתים. **File System** היא השכבה של מערכת ההפעלה שהופכת את הרצף הזה ל**קבצים ותיקיות** עם שמות, ושומרת לכל קובץ מידע נוסף (**Metadata**): גודל, תאריך שינוי, בעלים והרשאות.

המבנה הוא **עץ** (Tree): יש **שורש** (Root), ממנו יוצאות תיקיות, ובכל תיקייה עוד תיקיות וקבצים.

```text
Windows                         Mac / Linux
C:\                             /
├── Users\                      ├── home/            (Mac: /Users/)
│   └── dana\                   │   └── dana/
│       ├── Desktop\            │       ├── Desktop/
│       └── dev\                │       └── dev/
│           └── kodkod6\        │           └── kodkod6/
├── Program Files\              ├── usr/
└── Windows\                    └── etc/
```

הבדלים חשובים:

| | Windows | Mac / Linux |
|---|---|---|
| שורש | אות כונן: `C:\` (ויכולים להיות עוד: `D:\`) | שורש אחד: `/` |
| מפריד | `\` (Backslash) | `/` (Slash) |
| תיקיית הבית | `C:\Users\dana` | `/home/dana` (Mac: `/Users/dana`) |
| אותיות גדולות/קטנות | `File.txt` = `file.txt` | `File.txt` ≠ `file.txt` (בלינוקס) |

**תיקיית הבית** (Home Directory) היא התיקייה הפרטית של המשתמש. בה, ובתתי-התיקיות שלה, יש לכם הרשאות מלאות. לכן את `kodkod6` שמים בתוכה.

#### נתיב מלא מול נתיב יחסי

- **נתיב מלא** (Absolute Path) — מתחיל מהשורש. עובד מכל מקום.
  `C:\Users\dana\dev\kodkod6\week-1\hello.py`
- **נתיב יחסי** (Relative Path) — מתחיל **מהתיקייה הנוכחית**. קצר, אבל תלוי איפה עומדים.
  `week-1\hello.py` (אם עומדים ב-`kodkod6`)

שני קיצורים מיוחדים:

- `.` (נקודה) = **התיקייה הנוכחית**.
- `..` (שתי נקודות) = **תיקיית האב**, תיקייה אחת למעלה.

```text
Standing in: C:\Users\dana\dev\kodkod6\week-1

.              → C:\Users\dana\dev\kodkod6\week-1
..             → C:\Users\dana\dev\kodkod6
..\week-2      → C:\Users\dana\dev\kodkod6\week-2
..\..          → C:\Users\dana\dev
```

{{< box "analogy" "אנלוגיה" >}}
**נתיב מלא** הוא כתובת מלאה: "ישראל, חיפה, רחוב הרצל 10, דירה 3". שולח מכל מקום בעולם — יגיע. **נתיב יחסי** הוא הוראת הגעה: "שתי דלתות ימינה מכאן". עובד רק אם יודעים מאיפה מתחילים.
{{< /box >}}

#### משתמשים (Users)

מערכת הפעלה תומכת בכמה **משתמשים**. לכל אחד יש שם, סיסמה, תיקיית בית והרשאות. יש גם משתמשים "מיוחדים":

- **Administrator** (Windows) / **root** (Linux/Mac) — משתמש-על עם הרשאות מלאות לכל המערכת.
- **משתמשי מערכת** — משתמשים שאינם בני אדם. שירותים כמו שרת או Database רצים תחתם, כך שגם אם יפרצו אליהם, הנזק מוגבל.

בעבודה רגילה עובדים כמשתמש **רגיל**, ומעלים הרשאות רק לפעולה ספציפית: **Run as Administrator** ב-Windows, `sudo` בלינוקס/מק.

#### הרשאות (Permissions)

לכל קובץ ותיקייה יש הרשאות שקובעות **מי** רשאי לעשות **מה**. שלוש הפעולות הבסיסיות:

| הרשאה | בקובץ | בתיקייה |
|---|---|---|
| **Read** (r) | לקרוא את התוכן | לראות אילו קבצים יש בה |
| **Write** (w) | לשנות / למחוק | ליצור ולמחוק קבצים בתוכה |
| **Execute** (x) | להריץ כתוכנה | להיכנס אליה (`cd`) |

בלינוקס/מק ההרשאות מוצגות כמחרוזת כמו `-rwxr-xr--`, ומחולקות לשלוש קבוצות: **בעלים** (Owner), **קבוצה** (Group) ו**כל השאר** (Others):

```text
-  rwx  r-x  r--
│   │    │    └── others: read only
│   │    └─────── group:  read + execute
│   └──────────── owner:  read + write + execute
└──────────────── type: "-" = file, "d" = directory
```

ב-Windows ההרשאות נקראות **ACL** ומופיעות בלחיצה ימנית ‏←‏ Properties ‏←‏ **Security**. העיקרון זהה.

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

### טעות נפוצה

**הטעות 1: "הקובץ לא נמצא" — אבל הוא קיים.**

```text
Standing in:  C:\dev\kodkod6
Looking for:  data.txt
Searched:     C:\dev\kodkod6\data.txt
Real file:    C:\dev\kodkod6\week-1\data.txt
```

- נתיב **יחסי** נבדק **מהתיקייה הנוכחית** — מהמקום שבו ה-Terminal עומד — ולא מהתיקייה שבה הקובץ נמצא.
- הרצתם מתיקייה אחרת? התוכנה מחפשת במקום אחר, ולא מוצאת.
- **הפתרון:** לעבור קודם לתיקייה הנכונה (`cd`), או להשתמש בנתיב **מלא**.

**הטעות 2: לעבוד כ-Administrator / root "כדי שלא יהיו בעיות".** זה עוקף את ההגנה שההרשאות נותנות: כל טעות, או תוכנה זדונית, מקבלת גישה לכל המחשב. עובדים כמשתמש רגיל, ומשתמשים בהרשאות-על רק כשבאמת צריך.

**הטעות 3: לחשוב ששגיאת הרשאה היא באג בתוכנה.** כשמערכת ההפעלה מחזירה "Access is denied" / `PermissionError`, היא **בדקה ומצאה** שלמשתמש הנוכחי אין הרשאה לפעולה. הפתרון הוא לבדוק מי הבעלים של הקובץ ומה ההרשאות שלו — לא לשנות את התוכנה.

### סיכום

- **File System** מארגן את הדיסק כ**עץ** של תיקיות וקבצים, החל מהשורש (`C:\` או `/`).
- **נתיב מלא** מתחיל מהשורש. **נתיב יחסי** מתחיל מהתיקייה הנוכחית. `.` = כאן, `..` = למעלה.
- נתיבים יחסיים נמדדים **מהמקום שממנו הרצתם**, ולא ממיקום הקובץ.
- לכל משתמש יש תיקיית בית והרשאות. **Administrator / root** הם משתמשי-על, ומשתמשים בהם רק כשצריך.
- הרשאות בסיסיות: **Read / Write / Execute**. שגיאת הרשאה = מערכת ההפעלה סירבה.

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### דוקומנטציה רשמית

- [Naming Files, Paths, and Namespaces](https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file) — נתיב מלא מול נתיב יחסי
- [chmod — Linux manual page](https://man7.org/linux/man-pages/man1/chmod.1.html) — הרשאות rwx ב-Linux וב-Mac

<!-- docs:end -->

<!-- exercises:start — generated by scripts/intro6/sync_site_exercises.py; edit scripts/intro6/exercises/ -->
## תרגול

שאלות הבנה על החומר של השיעור — בלי קוד.

### תרגיל 1: חמשת התפקידים

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

{{< solution >}}
| תפקיד | דוגמה |
|---|---|
| **ניהול תהליכים** | מחליטה מי מקבל את ה-CPU ומתי — דפדפן, נגן מוזיקה ו-VS Code "רצים יחד" |
| **ניהול זיכרון** | נותנת לכל תוכנה RAM, ומונעת מתוכנה אחת לקרוא את הזיכרון של אחרת |
| **ניהול קבצים** | שומרת קבצים בעץ של תיקיות על הדיסק |
| **משתמשים והרשאות** | משתמש רגיל לא יכול למחוק קבצי מערכת |
| **ניהול חומרה** | מדברת עם המסך, המקלדת והמדפסת דרך Drivers |
{{< /solution >}}

### תרגיל 2: מה קורה כש-print מדפיס?

תוכנית Python מבצעת `print("Hi")`. תארו את המסלול מהתוכנית ועד שהטקסט מופיע על המסך. השתמשו במושגים User Mode, System Call, Kernel ו-Driver.

{{< solution >}}
1. התוכנית שלנו רצה ב-**User Mode** — אין לה גישה ישירה למסך.
2. Python מבקשת מה-Kernel לכתוב את הטקסט — זו **System Call** (בקשה מסודרת).
3. ה-**Kernel**, שרץ ב-**Kernel Mode** עם גישה מלאה לחומרה, בודק הרשאות.
4. ה-Kernel מעביר את הבקשה ל-**Driver** של המסך.
5. הטקסט מופיע על המסך.
{{< /solution >}}

### תרגיל 3: Program מול Process

1. מה ההבדל בין Program ל-Process?
2. פתחתם שלושה חלונות של Chrome. כמה Programs יש, וכמה Processes לפחות?
3. במחשב יש 8 ליבות, אבל רצים 300 תהליכים. איך זה אפשרי?

{{< solution >}}
1. **Program** הוא קובץ על הדיסק — המתכון. **Process** הוא הרצה פעילה שלו ב-RAM, עם PID וזיכרון משלה — הבישול.
2. **Program אחד** (Chrome) ו**לפחות שלושה Processes** — בפועל הרבה יותר, כי Chrome מריץ תהליך נפרד לכל לשונית ולכל רכיב.
3. ה-**Scheduler** של מערכת ההפעלה מחלק את זמן ה-CPU לפרוסות קטנות של מילישניות, ומעביר את הליבות בין התהליכים מהר מספיק כדי שייראה שכולם רצים במקביל.
{{< /solution >}}

### תרגיל 4: נתיבים

ה-Terminal עומד ב-`C:\Users\dana\dev\kodkod6\week-1`. לאיזה נתיב מלא מתורגם כל אחד מהנתיבים היחסיים?

```text
.
..
..\week-2
..\..
```

{{< solution >}}
| נתיב יחסי | נתיב מלא |
|---|---|
| `.` | `C:\Users\dana\dev\kodkod6\week-1` |
| `..` | `C:\Users\dana\dev\kodkod6` |
| `..\week-2` | `C:\Users\dana\dev\kodkod6\week-2` |
| `..\..` | `C:\Users\dana\dev` |

`.` = התיקייה הנוכחית, `..` = תיקייה אחת למעלה.
{{< /solution >}}

### תרגיל 5: לקרוא הרשאות

זו שורה מ-`ls -l` במחשב Linux:

```text
-rw-r-----   dana   grades.txt
```

1. האם זה קובץ או תיקייה?
2. מה מותר לבעלים (dana), מה מותר לקבוצה ומה מותר לכל השאר?
3. משתמש אחר, שלא בקבוצה, מנסה לקרוא את הקובץ. מה יקרה, ומי מחליט?

{{< solution >}}
1. **קובץ** — התו הראשון הוא `-` (תיקייה הייתה מתחילה ב-`d`).
2. ההרשאות מתחלקות לשלוש קבוצות של שלושה תווים:
   - **בעלים** `rw-` — קריאה וכתיבה.
   - **קבוצה** `r--` — קריאה בלבד.
   - **כל השאר** `---` — שום הרשאה.
3. הוא יקבל **שגיאת הרשאה** (Permission denied). מי שמחליט הוא **מערכת ההפעלה** — ה-Kernel בודק את ההרשאות בכל ניסיון גישה לקובץ.
{{< /solution >}}

<!-- exercises:end -->