שלום לכולם.
בתור תחביב התחלטתי לממש מיני מערכת הפעלה משלי. נכון לעכשיו קיים bootloader stage 1 שטוען את bootloader stage 2 והוא אמור להיכנס ל PMODE ולהעביר שליטה לקרנל.
אבל אני נתקלתי במס' בעיות:
בשביל למפה (מהמילה מפה to map) יותר מ 1MB (עד 4GB) של זכרון עלי להגדיר GDT או Global Descriptor Table, אני יודע שהוא מורכב מ selectorים שכל אחד בגודל של 8בית (כלומר כל סלקטור בגודל של 64ביט) והראשון הוא NULL SELECTOR, כמו כן אני יודע שיש צורך להגדיר CODE ו DATA סלקטורים. הבעיה שאני לא יודע מה בדיוק המשמעות של כל ביט בסלקטור ודיי קשה למצוא על זה מידע, אני בספק אם קיים ידע על זה בעיברית אז מידע באנגלית יספיק לי, אם מישהוא מכיר כמובן.
הבעיה אחרת היא ה IDT (Interrupt Descriptor Table) אני יודע שב PMODE קריאה לפסיקה כאשר IDT לא קיים מביא ל triple fault של המעבד ולכן הבנתי שיש צורך להגדיר IDT, אבל שוב לא הצלחתי למצוא עליו מידע.
אותו דבר לגבי LDT שעליו בכלל מידע (האם הוא הכרחי בכלל)?
שאלה נוספת: מה הדרך המקובלת להיכנס ל PMODE, נניח בוט לואדר 1 מעביר שליטה ל 2 עכשיו דרך אחת היא לממש הכל באסמבלי (כולל המבנה של IDT/GDT/LDT) לפתוח את A20 ולשים את הביט של PMODE ב CR0 ואז להבעיר שליטה לקרנל, דרך נוספת היא ישר להעביר שליטה לקרנל והוא יעשה את כל העבודה הזאתי. מה שתי אלה יותר מקובל?
ושאלה אחרונה בשביל להיות בטוח: אחרי ה POST הכתובות 0x00000500 עד 0x00007BFF וכתובות 0x00007E00 עד 0x0009FFFF פנויות וניתן לטעון את הקרנל לשם?
תודה רבה רבה מראש!

קצת תשובות :

ניהול זיכרון :

* סלקטורים זה לא מאוד מעניין .יש 13 ביט של אינדקס ,ביט אחד שקובע האם זה אינדקס ל- GDT או ל - LDT ושני ביטים של RPL- REQUESTED PRIVILEGE LEVEL.
* דסקריפטורים הם הרשומות שיושבות ב - GDT \ IDT \ LDT .יש עליהם המון מידע באינטרנט באנגלית . האתר של אינטל זה הכי טוב : http://www.intel.com/products/proce...nuals/index.htm החלק משם שמדבר על דסקריפטורים וכו' זה ה - System Programming Guide .
סעיף 3.4.5 Segment Descriptors ב-VOLUME A מסביר בדיוק על המבנה של ה-SEGMENT DESCRIPTORS

בגדול תמצא שם תשובות גם לשאר השאלות שלך אבל אני אגיד עליהן כמה מילים :
* IDT הוא כמו GDT רק שבמקום להכיל TSSים, GATEים וסגמנטים של זיכרון הוא מכיל רק INTERRUPT GATES ו TRAP GATES
*ה- LDT לחלוטין לא הכרחי אבל מספק תפקודיות מסוימת - מאפשר הגנה בין פרוססים . אם לא תשתמש ב-PAGING אין דרך אחרת לעשות את זה .

אחלה תודה רבה, מור שלא שמתי לב לנושא הזה ב MANUAL של אינטל, שוב תודה.
אני אבדוק את זה היום אחרי שאחזור מהמכללה.
לגבי PAGING אני לא בטוח עדיין (זה הרי אותו דבר כמו VM לא? או שאני מפספס משהוא?) נכון לעכשיו אני רוצה להגיע למצב שהקרנל רץ ויכול להשתמש בכמה פקודות של ספריות בשפת C (שכמובן אני אממש גם אותן) בשביל שאני אדע שזה עובד, אחרי זה תלוי בצרכים אני אכניס/לא אכניס מנגון של PAGING.
שוב תודה!
מידע נוסף יתקל בברכה.

בכללי, עדיף להשתמש בGRUB כדי לטעון את הקרנל שלך, כי הוא זורק אותך אוטומטית לPMODE במקום להתחיל להתסבך מלעבור מreal mode לprotected mode עם הA20 Gate, להדליק את הPE bit וכו' (כמובן שתצטרך להקים GDT עם הסגמנטים שלך - אחד NULL כמו שאתה יודע, אחד נוסף DATA SEGMENT לקרנל וCODE SEGMENT...בהמשך, לusermode תצטרך גם עוד data&code segments)

עזוב זה כל הרעיון לבנות אחד משלי, אפשר להשתמש גם בקרנל של לינוקס אבל זה לא הקטע פה.
בלכ מקרה הסתדרתי עם ה GDT, והבנתי שבשביל קרנל מוד צריך מינימום 3 דסקריפטורים (כמו שאמרת) NULL, CODE ו DATA ואחרי שהוכלם ה RING ביטים עומדים על 00 (RING0) ואחריש אני אוסיף גם USER מוד אני אצטרך עוד שתיים עם RING ביטים ב 11 (RING3).
בכל מקרה אם יהיה צורך אוכל לעלות לפה את המבנה של GDT כמו שאני מבין אותו, יותר מאוחר, עכשיו פשוט אני הולך לאכול כי לא אכלתי מאז שחזרתי הביתה (ישר התחלתי לכתוב את ה GDT )
עכשיו נשאר לממש רק IDT ואפשר להתחיל את הקרנל
ד"א אם יש למישהוא מידע על IDT (עוד לא בדקתי את המדריך של אינטל אז לא לצעוק עלי בבקשה >.<) אז אשמח אם תוכלו לשתף
תודה רבה רבה מראש!

יש המון מדריכים על איך להרים גם IDT וכעיקרון זה מאוד דומה לGDT, פשוט השימוש הוא בlidt כשאתה מודיע למעבד איפה הIDT, והמבנים קצת שונים. יש מדריכים בכל האינטרנט, וגם אין לי בעיה להראות לך איך אני יוצר את הIDT אצלי בקרנל.

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

אתה פשוט חייב לקרוא את המדריכים של אינטל או ספר אם תמצא .ספר ממש טוב לנושאים הבסיסיים הוא Microsoft's 80386/80486 Programming Guide של MSPRESS אבל הוא משנת 1991 ולא נראה לי שיש אותו באינטרנט .

אתה שואל שאלות מאוד לא ברורות על נושאים די בסיסיים בקשר לSYSTEM PROGRAMMING ב-386 ואין שום סיכוי בעולם שתלמד הכל נכון רק מלשאול שאלות ולעשות ניסויים .אלה דברים טובים וחשובים אבל אתה פשוט חייב גם לקרוא את הדברים בצורה מסודרת .


לגבי השאלה הסציפית : ב-386 ומעלה ב-PM אתה תמיד משתמש בזיכרון וירטואלי .אתה תמיד טוען SELECTOR שמתייחס ל - DESCRIPTOR ב -GDT או ב -LDT לתוך ה-SEGMENT REGISTERS .הזיכרון הוא תמיד וירטואלי והוא תמיד ממופה ל"כתובת לינארית" בעזרת מנגנון ה- SEGMENTATION .
בשלב הזה מנגנון ה- PAGING יכול להיות פעיל או כבוי .אם הוא כבוי אז הכתובת הלינארית היא גם הכתובת הפיזית .אם הוא פעיל את הכתובת הלינארית מפורקת וממופה לכתובת פיזית דרך מנגנון ה- PAGING שגם עליו אתה יכול לקרוא במדריכים של אינטל אני בטוח .

אם כי הוא יכול לעשות identity mapping כלומר, גם כשיש לו paging במערכת, הכתובות הוירטואליות יכולות להיות ממופות לפיזיות (כמובן שהוא יצטרך לדאוג לזה בעצמו, לא סיפור גדול)

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

השתמע ממה שכתבת שכשהוא מפעיל paging במערכת, הכתובות הוירטואליות הן לא הפיזיות, אז אני כתגובה כתבתי שכן אפשר לגרום למצב כזה שהן כן יהיו ממופות לפיזיות ביחס של אחד לאחד (identity mapping), כלומר הכתובות הוירטואלית 0x1234 תהיה ממופת לכתובת הפיזית 0x1234.

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

ברור לי, לא כתבתי אחרת.
החוסר הבנה בינינו נוצר בתגובה קודמת שלי ("גם כשיש לו paging במערכת", ששכחתי לציין את העניין שהמיפוי עובר ביחס של אחד לאחד, 0x1000 -> 0x1000 וכו')