@yankevk כתב בבקשת מידע | בטריה ל4*4 הונגרית, מישהו שמע???:

נראה לי שהוא התכוון לבטריה פולנית

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

@EBA כתב בלהורדה | להורדה - תוסף חדש לכרום להורדת כל הקבצים המצורפים בבת אחת:

@אלישי כתב בלהורדה | להורדה - תוסף חדש לכרום להורדת כל הקבצים המצורפים בבת אחת:

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

זה ניסוח אישי שלי, אני לא יודע האם להיעלב או להיות מוחמא...

האימוג'ים זה עם עזרה של כלי בינה מלאכותית שעוזר להוסיף אותם, אם זה בעיה אני אסיר. אבל המלל עצמו הוא מילה במילה שלי.

אני אהבתי
עכשיו אני יעלה פוסט לבינה ויבקש ממנה להפציץ אותה באימוג'ים

בעיה של אתרוג (מניסיון)

@צבי-דורש-ציון כתב בשיתוף | תגובות למדריך המלא על רכיבי המחשב:

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

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

@יוסף-חיים-5 כתב בהמלצה | מעבר מווינדוס לאפל:

@אביעד כתב בהמלצה | מעבר מווינדוס לאפל:

אני מבין שגרפיקה בלבד ולא עריכת וידאו, נכון?

נכון מאוד.

@אביעד כתב בהמלצה | מעבר מווינדוס לאפל:

תלוי באיזה מחשב כמובן לאח שלי יש M4 רגיל ולא שורד עבודה פשוטה של פוטושופ (למרות שרשמית זה כן אמור לתמוך)

איזה מחשב כן מומלץ. מה לא אמור לקרוס? המליצו לי על MacBook Pro 16 M4 24 GB-RAM. ידוע לך משהו?

@אביעד כתב בהמלצה | מעבר מווינדוס לאפל:

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

יש מעבד גרפי.

איזה?

@יוסף-חיים-5 כתב בהמלצה | מעבר מווינדוס לאפל:

@אביעד אני יחסית בסדר בלימוד דברים חדשים.

פצצה

@יוסף-חיים-5 כתב בהמלצה | מעבר מווינדוס לאפל:

אני צריך לגרפיקה

אני מבין שגרפיקה בלבד ולא עריכת וידאו, נכון?

@יוסף-חיים-5 כתב בהמלצה | מעבר מווינדוס לאפל:

התוכנה קרסה ברמה שלא נפתחת והאני צריך להתחיל מההתחלה או מהקובץ קופי האחרון.

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

@יוסף-חיים-5 כתב בהמלצה | מעבר מווינדוס לאפל:

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

תלוי באיזה מחשב כמובן לאח שלי יש M4 רגיל ולא שורד עבודה פשוטה של פוטושופ (למרות שרשמית זה כן אמור לתמוך)

@צבי-דורש-ציון כתב בשיתוף | תגובות למדריך המלא על רכיבי המחשב:

@אביעד דבר ראשון תודה רבה על המדריכים הנפלאים!
דבר נוסף, אולי כדאי שתוסיף בספויילר ליד כל דבר, איפה אפשר לראות את זה במחשב, דהיינו גם את הנתונים של המחשב ששלי/אחרים, וגם בלוח הבקרה, איך רואים כמה זה "תפוס"
מקוה שהובנתי.

תסביר יותר למה אתה מתכוון

מעראכת הפעלה אני יתקין לך בחינם
אם אתה בבני ברק

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

@פאפא-אמסנא-48 כתב בבקשת מידע | בטריה ל4*4 הונגרית, מישהו שמע???:

שמעתי שיצא
בטריה לפלאפונים 4*4 וכיוצ"ב
משהו הונגרי,
שמחזיק יומיים שלמים,
מישהו יש פרטים ע"כ?????

בטח לא שמעת טוב (מוזר יש לטלפון הזה אחלה של שמע )
בטריה גרמנית

@משה-מזרחי כתב בבירור | PHOTOSHOP בעברית:

@אביעד
מוריד
מחלץ
ודוחס עם סיסמה
בלי זה גוגל חוסמים את החלק האחרון
מניסיון מר , עם רוויט (12 ג'יגה למי שלא מעודכן )

וכמובן מעלה ידני
הרובוט זה רק עד 2 גיגה

אוהה
צריך להפיץ את הפוסט הזה שאנשים קצת יעריכו את העבודה הזאת

@hujbi11 כתב בלהורדה | קובץ iso של ווינדוס 11 23H2 + אופיס, wsa ומקבץ תוכנות מומלצות:

@NH-LOCAL מה עושים?

תעלה דרך דיסק טכנאים ותפתח שם את הקובץ הזה

@יוסף-אלחנן כתב בבירור | PHOTOSHOP בעברית:

@אביעד נכון, כל הכבוד לו על המסירות!
(אני גם מעלה מידי פעם תוכנות של ירון, אמנם לא כזה משקל אבל עדיין)

אבל אם זה כל כך דחוף לו אני יכול לנסות להוריד...

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

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

@יוסף-אלחנן ומה חשבת שמשה מזרחי מעלה?- הוא לוקח את זה משם
(לא יודע כמה דחיסה דוחסת בפועל)
עריכה: אני רואהשגם שם זה דחוס

@רבי-יהודי כתב בבירור | PHOTOSHOP בעברית:

@יוסף-אלחנן https://mitmachim.top/topic/60665/להורדה-adobe-photoshop-cc-2025-v26.6.1.7

יש לך גישה לטלגרם?
אם כן
https://t.me/YaronTeam/2970

@דוד-משה-1 כתב בשיתוף | תגובות והערות על המדריך של מערכות הפעלה:

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

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

לכל מי שעוקב כאן- יצא מדריך חדש על מערכות הפעלה
https://mitmachim.top/topic/85832/מדריך-מהי-מערכת-ההפעלה-מדריך-על-מערכת-ההפעלה-חתיכה-אחרי-חתיכה

@דער-צדיק-נסתר כתב בשיתוף | תגובות והערות על המדריך של מערכות הפעלה:

@אביעד
כל הכבוד על ההשקעה
המידע שרשום הוא מאומת נכון ?
לא איזה AI או משהו
לא אוהב לקרוא וללמוד על משהו ולבסוף לגלות שחצי לא מדויק
בכל מקרה תודה רבה על ההשקעה

רובם של הדברים נכתבו על ידי ממש (יותר מ85%) היה הדגמות ותיאורים שנעזרתי בבינה מלאכותית אבל בכלל לא בבסיס
סתם סיקרן אותי: העלתי את המדריך לAI ושאלתי אותו אם יש בזה שגיאות-הפלט בספויילר

Spoiler

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

Spoiler

מה דעתכם?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• הקרנל לא חשוף לתוכנה באופן ישיר – אין דרך לגשת ישירות לזיכרון שלו.
• המעבד עצמו מבצע את המעבר בין המצבים. יש לו ביט מיוחד שנקרא 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. אבטחה ובידוד

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

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

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

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

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

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

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), שומר מצבים, ועובר לכתובת שהקרנל הגדיר מראש.

---

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

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

Spoiler

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

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

תהליך (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).

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

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. הקרנל מאשר לכרטיס הגרפי להציג את זה.

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

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