Windows
Bootloader, Boot.ini, %systemroot%
תהליך האתחול של Windows: Bootloader, Boot.ini, BCD, winload.exe והתיקייה %SystemRoot%.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Bootloader, Boot.ini, %systemroot%: איך Windows עולה, מה היא קוראת בדרך ואיפה היא יושבת
בין הלחיצה על כפתור ההפעלה לבין מסך הכניסה רצות כמה תוכניות קטנות, וכל אחת מהן קיימת רק כדי להעלות את הבאה בתור. הפרק עוקב אחריהן אחת אחרי השנייה: איפה כל אחת שמורה, מה היא קוראת, ולמי היא מוסרת את השליטה.
- Bootloader וקושחה: במה שונה מחשב BIOS ממחשב UEFI, מה Secure Boot בודק, ובאיזו מחיצה נמצא כל קובץ אתחול.
- Windows Boot Manager, הטוען winload ו-winresume: מי בוחר מה לטעון, מי מביא את הליבה לזיכרון, ומי מחזיר את המחשב מתרדמה.
- NTLDR והקובץ boot.ini: הדרך שבה עלתה Windows XP, כולל המבנה של הקובץ, נתיבי ARC והמתגים שבסוף כל שורה.
- BCD והכלי bcdedit: המאגר שתפס את מקומו של boot.ini, הרשומות שבו והפקודות שמשנות אותו.
- תקלות אתחול: סביבת השחזור, הכלים שבונים מחדש את קובצי האתחול, ומה אומרת כל הודעת שגיאה נפוצה.
- %SystemRoot%: משתנה הסביבה שמחזיק את תיקיית ההתקנה של Windows, התיקיות החשובות שבתוכה והעבודה איתו בחלון cmd.
הפקודות שמוצג לצדן פלט הורצו על מחשב Windows 10 שעולה במצב UEFI, והפלט הוא מה שהתקבל בפועל. דברים ששייכים ל-XP, כמו תוכן של boot.ini או פקודות של Recovery Console, מוצגים כטקסט בלבד ומוסברים במילים, כי אין כאן מערכת כזו להריץ אותם עליה.
שרשרת האתחול: מהקושחה ועד הליבה
Bootloader: החוליה שמביאה את מערכת ההפעלה לזיכרון
ברגע ההדלקה אין בזיכרון ה-RAM שום דבר שימושי. Windows מחכה על הדיסק, אבל המעבד לא יודע לבד באיזה דיסק היא נמצאת ובאילו קבצים צריך להתחיל.
לכן האתחול בנוי כמו מרוץ שליחים. תוכנית קטנה רצה ראשונה, מאתרת את התוכנית הבאה, טוענת אותה ומפעילה אותה, וזו חוזרת על אותו דבר עם מי שאחריה.
מה הופך שליח מסוים ל-Bootloader (טוען אתחול)? המשימה שלו: לקחת מערכת הפעלה ששוכבת על הדיסק, להעמיד אותה בזיכרון ולהעביר אליה את המעבד. מהרגע ש-Windows מחזיקה במעבד אין לו יותר מה לעשות, ולכן כל קיומו שייך לזמן שלפני מערכת ההפעלה.
ב-Windows של היום העבודה הזו מפוצלת בין שני רכיבים, ולכל אחד מהם שם רשמי וקובץ משלו:
| רכיב | הקובץ במחשב BIOS | הקובץ במחשב UEFI | מה הוא עושה |
|---|---|---|---|
| Windows Boot Manager (מנהל האתחול) | bootmgr | bootmgfw.efi | קורא את הגדרות האתחול, מציג תפריט כשיש ממה לבחור, ומפעיל את הטוען |
| Windows Boot Loader (טוען מערכת ההפעלה) | winload.exe | winload.efi | מביא את הליבה עצמה לזיכרון |
במערכות הוותיקות של המשפחה, מ-Windows NT ועד Windows Server 2003 (כולל 2000 ו-XP), לא היה פיצול כזה. קובץ אחד בשם NTLDR מילא את שני התפקידים.
הטבלה הבאה עוקבת אחרי השרשרת כולה, מהחשמל ועד שולחן העבודה. שימו לב איפה עובר הגבול: עד השורה הרביעית עוד אין ליבה בזיכרון.
| שלב | מי רץ | מה קורה בו |
|---|---|---|
| 1 | הקושחה (BIOS או UEFI) | בדיקת החומרה, ואחריה חיפוש של התקן לאתחל ממנו |
| 2 | קוד האתחול שעל הדיסק | מעביר את השליטה הלאה, עד שמנהל האתחול נטען |
| 3 | Windows Boot Manager (bootmgr או bootmgfw.efi) | קורא את BCD, מאגר הגדרות האתחול שנפרט עליו בהמשך, ומחליט מה להפעיל |
| 4 | Windows Boot Loader (winload.exe או winload.efi) | טוען את הליבה ואת מנהלי ההתקן של האתחול |
| 5 | הליבה, ntoskrnl.exe | מאתחלת את עצמה ומפעילה את התהליכים הראשונים |
| 6 | smss.exe, ואחריו wininit.exe ו-winlogon.exe | מכינים את הסביבה ומציגים את מסך הכניסה |
| 7 | explorer.exe | שולחן העבודה, אחרי שהמשתמש נכנס |
טעויות נפוצות
- אחרי שה-Bootloader טוען את Windows, הוא נשאר ברקע ומחלק את זמן המעבד בין התוכניות. חלוקת זמן מעבד היא העבודה של המתזמן שבתוך הליבה. כשהליבה מתחילה לרוץ, ה-Bootloader כבר סיים.
- ה-Bootloader מעלה את שולחן העבודה ומריץ את מה שנמצא בתיקיית Startup. שולחן העבודה ותוכניות ה-Startup מופיעים רק אחרי שמשתמש נכנס למערכת, הרבה שלבים אחרי שהאתחול הסתיים.
- בכל הדלקה ה-Bootloader שומר תמונת מצב של המערכת, כדי שאפשר יהיה לחזור אליה. אין לו תפקיד כזה. הוא מביא את מערכת ההפעלה לזיכרון ומוסר לה את השליטה, וזהו.
בדקו את עצמכם
מה הצעד האחרון ש-Bootloader חייב לבצע, שאחריו הוא כבר לא נחוץ?
להעביר את השליטה למערכת ההפעלה שהוא הביא לזיכרון.
במחשב Windows 11, איזה רכיב בוחר איזו רשומה לאתחל, ואיזה רכיב מביא את הליבה לזיכרון?
מנהל האתחול (bootmgr או bootmgfw.efi) בוחר לפי ה-BCD, והטוען winload מביא את הליבה.
מי עשה את שתי העבודות האלה ב-Windows 2000?
NTLDR לבדו.
הקושחה: BIOS מסורתי מול UEFI, ומה Secure Boot מוסיף
הקוד הראשון שרץ אחרי ההדלקה בכלל לא נמצא בדיסק, אלא בשבב שעל לוח האם. זו הקושחה (Firmware).
היא מתחילה בבדיקה עצמית של החומרה, POST, ורק אחר כך מחפשת התקן שאפשר לאתחל ממנו. מכאן הדרך מתפצלת לפי סוג הקושחה:
| מאפיין | BIOS מסורתי (Legacy) | UEFI |
|---|---|---|
| הפורמט של טבלת המחיצות בדיסק המערכת | MBR | GPT |
| מה נשלף מהדיסק ומורץ | התוכנית הזעירה שבסקטור הפותח את הדיסק | קובץ EFI ממחיצה ייעודית לאתחול (ESP), שהכתובת שלו רשומה ב-NVRAM, זיכרון קבוע על לוח האם. שני המושגים מוסברים בהמשך. |
| השם של מנהל האתחול של Windows | bootmgr | bootmgfw.efi |
| השם של טוען מערכת ההפעלה | winload.exe | winload.efi |
| אימות חתימה לפני הרצת קוד אתחול (Secure Boot) | אין | יש |
כדי להבין את השורה הראשונה, כדאי להציץ במה שיושב ממש בתחילת הדיסק בכל אחד משני העולמות:
- דיסק MBR: הסקטור הראשון, Master Boot Record, הוא כל מה שה-BIOS צריך. ב-512 הבתים שלו דחוסים תוכנית אתחול קטנה, טבלה שמתארת את המחיצות, ובקצה הסקטור זוג בתים עם הערך
0x55AA. בלי הזוג הזה ה-BIOS לא יתייחס לסקטור כאל משהו שאפשר לאתחל ממנו. - דיסק GPT (GUID Partition Table): הדיסק כולו, וכל מחיצה בו, מזוהים במזהה ייחודי (GUID) של 128 סיביות. קושחת UEFI לא מחפשת בתחילת דיסק כזה קוד להריץ, אלא קובץ בתוך מחיצה.
ומה אם צריך להריץ על מחשב UEFI משהו ישן? ברוב הקושחות יש הגדרה בשם Legacy Boot, או CSM (Compatibility Support Module). כשמפעילים אותה, הקושחה מעמידה פני BIOS: קוראת את ה-MBR ומריצה את הקוד שבו.
השימוש האמיתי בהגדרה הזו הוא תוכנה שלא מכירה UEFI, כמו Windows XP או כלי שחזור מהדור הקודם. שתי סיבות אחרות שנשמעות סבירות לא מחזיקות: מהירות, כי בדרך כלל דווקא UEFI עולה מהר יותר, ודיסקי GPT, כי אותם UEFI יודע לאתחל בעצמו.
נניח עכשיו שתוכנה זדונית החליפה את bootmgfw.efi בגרסה משלה. בלי הגנה מיוחדת, הקוד שלה ירוץ לפני Windows ולפני האנטי-וירוס, כלומר לפני כל מי שיכול לזהות אותו.
Secure Boot, תכונה של קושחת UEFI, נועד לעצור בדיוק את זה. בכל פעם שהקושחה עומדת להעביר שליטה לקוד אתחול, היא בודקת קודם את החתימה הדיגיטלית שלו מול רשימת מפתחות מהימנים שהיא מחזיקה. הגרסה המזויפת לא חתומה, או שהחתימה שלה כבר לא מתאימה לתוכן ששונה, ולכן היא לא תורץ.
טעויות נפוצות
- כדי ש-Secure Boot יעבוד, צריך להדליק בקושחה את Legacy Boot. ההפך. Secure Boot שייך ל-UEFI, ובמצב Legacy הוא לא פועל בכלל.
- UEFI לא מסתדר עם דיסק GPT, ולכן עוברים למצב Legacy. GPT הוא הפורמט הטבעי של UEFI. מי שעולה מ-MBR הוא דווקא BIOS מסורתי.
- עוברים למצב Legacy כדי שהמחשב יעלה מהר יותר. Legacy אינו מהיר יותר, ובדרך כלל UEFI מקצר את העלייה. מפעילים אותו בשביל תוכנה ישנה שלא תומכת ב-UEFI.
- Secure Boot שומר על המחשב כי הוא מצפין את הדיסק, נועל את תפריט האתחול בסיסמה ושומר עותק של ה-BCD. אף אחד מאלה. הוא בודק את החתימה הדיגיטלית של קוד האתחול לפני שהקוד מורץ, ולא יותר.
בדקו את עצמכם
טכנאי צריך להעלות מחשב UEFI מכונן USB עם כלי אבחון ישן, שנכתב לפני ש-UEFI הופיע. איזו הגדרה ישנה בקושחה?
יפעיל את מצב התאימות Legacy Boot (CSM), כדי שהקושחה תתנהג כמו BIOS.
המחשב עולה במצב Legacy. האם Secure Boot יעצור קוד אתחול ששונה?
לא. במצב Legacy אין בדיקת חתימות, כי Secure Boot פועל רק במצב UEFI.
מה מסמן הערך 0x55AA בסוף ה-MBR?
שהסקטור הוא סקטור אתחול תקין.
הדרך במחשב BIOS עם דיסק MBR
חשבו על ה-BIOS כעל קורא שמכיר רק עמוד אחד בספר, הראשון. הוא טוען את ה-MBR ומריץ אותו, אבל קובץ, תיקייה ומערכת קבצים הם מושגים זרים לו, ולכן bootmgr מבחינתו פשוט לא קיים.
בגלל זה מנהל האתחול לא נטען בצעד אחד. יש באמצע חוליה נוספת, וכל חוליה יודעת קצת יותר מזו שלפניה:
- ה-BIOS טוען לזיכרון את 512 הבתים של ה-MBR ומפעיל את הקוד שבהם.
- קוד ה-MBR עובר על טבלת המחיצות ומחפש את המחיצה שמסומנת כפעילה (Active). הוא טוען את מגזר האתחול (Boot Sector) שלה, כלומר את הסקטור הראשון של אותה מחיצה, ומוסר לו את השליטה.
- מגזר האתחול כבר מכיר את מערכת הקבצים של המחיצה שלו. הוא מאתר בה את
bootmgr, טוען אותו ומפעיל אותו. bootmgrפותח את מאגר ה-BCD שבתיקייה\Bootשל אותה מחיצה, מציג תפריט אם יש צורך, ומפעיל אתwinload.exe.winload.exeמביא לזיכרון את הליבה ואת מנהלי ההתקן של האתחול.
BIOS > MBR boot code > active partition's boot sector > bootmgr
bootmgr > \Boot\BCD > \Windows\system32\winload.exe > ntoskrnl.exeומה בעצם עושה הדגל Active? הוא מראה לקוד ה-MBR מאיזו מחיצה להמשיך, וזה כל השימוש בו. מי שמעביר אותו למחיצה אחרת משנה את נקודת היציאה של האתחול, אבל התפריט של bootmgr נשאר בדיוק כפי שהיה, בלי רשומה חדשה.
תרחיש 1: מחשב משרדי ישן: מי קורא את מה
במשרד יש מחשב BIOS ועליו Windows 7, על דיסק MBR. בדיסק שתי מחיצות: מחיצה קטנה בשם System Reserved שמסומנת Active, ואחריה מחיצת C: עם תיקיית Windows.
- ה-BIOS מריץ את הקוד שבסקטור הראשון של הדיסק.
- הקוד הזה רואה בטבלת המחיצות ש-System Reserved היא הפעילה, ומפעיל את מגזר האתחול שלה.
- מגזר האתחול שולף את
bootmgrמהשורש של System Reserved. bootmgrקורא את\Boot\BCDמאותה מחיצה. הרשומה שם אומרת שהטוען הוא\Windows\system32\winload.exeשבמחיצת C:.winload.exeטוען מ-C: אתntoskrnl.exe, ומכאן הליבה ממשיכה.
עד ש-winload.exe מתחיל לרוץ, אף רכיב לא קרא קובץ מתיקיית Windows. ה-BIOS אפילו לא יודע שהיא קיימת, וקוד ה-MBR לא מגיע עד bootmgr: הוא רק מעביר את השליטה למגזר האתחול.
טעויות נפוצות
- ה-BIOS ניגש לתיקיית Windows ומריץ משם את bootmgr. ה-BIOS מריץ רק את קוד ה-MBR, בלי להבין שום מערכת קבצים. וחוץ מזה,
bootmgrבכלל לא שמור בתיקיית Windows. - קוד ה-MBR טוען את bootmgr בעצמו. קוד ה-MBR רק מאתר את המחיצה הפעילה ומפעיל את מגזר האתחול שלה. מגזר האתחול, שמכיר את מערכת הקבצים, הוא שמוצא את
bootmgr. - winload.exe עולה קודם, ורק אחריו bootmgr.
bootmgrהוא שמחליט איזה טוען להפעיל, ולכן הוא חייב לרוץ לפניwinload.exe. - מסמנים מחיצה נוספת כ-Active, והיא תופיע כאפשרות בתפריט האתחול. הדגל קובע רק מאיפה האתחול מתחיל. הרשומות שבתפריט מגיעות מה-BCD.
בדקו את עצמכם
סדרו לפי סדר הריצה במחשב BIOS: bootmgr, מגזר האתחול של המחיצה הפעילה, winload.exe, קוד ה-MBR.
קוד ה-MBR, אחריו מגזר האתחול של המחיצה הפעילה, אחריו bootmgr, ובסוף winload.exe.
למה ה-BIOS לא יכול לטעון את bootmgr ישירות?
כי הוא לא מכיר מערכות קבצים. הוא יודע רק להריץ את הסקטור הראשון, ומגזר האתחול של המחיצה הוא שמוצא את הקובץ.
הדרך במחשב UEFI: רשומות NVRAM ומחיצת ה-ESP
במחשב BIOS ראיתם שלוש חוליות עד שמנהל האתחול רץ. במחשב UEFI יש חוליה אחת, כי הקושחה עצמה מבינה את מערכת הקבצים FAT32 ולא צריכה קוד מה-MBR שיעשה בשבילה את העבודה.
מה שהיא כן צריכה לדעת הוא לאיזו מחיצה לפנות ואיזה קובץ בה להריץ. התשובה מתחלקת בין שני מקומות:
- ESP (EFI System Partition): מחיצה קטנה בפורמט FAT32, נפרדת מכונן C:, שמיועדת לקובצי אתחול ולא לשום דבר אחר. שם נמצאים
bootmgfw.efi, ה-BCD וכמה קבצים נלווים, ולפעמים גם תוספות שיצרן המחשב שם. - NVRAM: זיכרון על לוח האם ששומר את תוכנו גם כשהחשמל מנותק. הקושחה מחזיקה בו רשימה של רשומות אתחול, וכל רשומה היא הכתובת של קובץ EFI כלשהו בתוך ה-ESP.
כשמתקינים Windows, ההתקנה רושמת ב-NVRAM רשומה בשם Windows Boot Manager. שלושה נתיבים בתוך ה-ESP חוזרים שוב ושוב בשאלות:
| נתיב בתוך ה-ESP | מה יש בו |
|---|---|
\EFI\Microsoft\Boot\bootmgfw.efi | מנהל האתחול של Windows בגרסת UEFI, הקובץ שהרשומה ב-NVRAM מצביעה עליו |
\EFI\Microsoft\Boot\BCD | מאגר תצורת האתחול |
\EFI\Boot\bootx64.efi | נתיב גיבוי, שהקושחה פונה אליו כשאין ב-NVRAM רשומה שמתאימה להתקן |
נתיב הגיבוי חשוב בעיקר להתקנים ניידים. כונן USB שמחברים למחשב בפעם הראשונה לא רשום ב-NVRAM שלו, ולכן הקושחה מנסה את \EFI\Boot\bootx64.efi שעל הכונן.
כש-Secure Boot מופעל, כל קובץ כזה עובר בדיקת חתימה לפני שהוא מקבל את השליטה. ומרגע שמנהל האתחול רץ, ההמשך זהה למה שראיתם במחשב BIOS:
UEFI firmware
| reads its boot entry list in NVRAM
ESP: \EFI\Microsoft\Boot\bootmgfw.efi
| opens \EFI\Microsoft\Boot\BCD and picks an entry
C: \Windows\System32\winload.efi
| loads the kernel
ntoskrnl.exeכדאי לשים לב מי מפעיל את מי, כי כל חוליה מפעילה רק את הבאה אחריה:
- הקושחה מריצה את
bootmgfw.efi, וזה הקובץ היחיד שהיא מריצה בעצמה. bootmgfw.efiמריץ אתwinload.efi.winload.efiמביא לזיכרון את הליבה,ntoskrnl.exe.
חתימת 0x55AA, הקובץ boot.ini ונתיבי ARC לא משחקים שום תפקיד בשלב הקושחה של מחשב UEFI. שאלה על UEFI שמזכירה אותם מערבבת פרטים מעולמות של BIOS ו-XP.
אפשר לראות את הדברים האלה על מחשב אמיתי. במחשב Windows 10 שעליו הורצו הדוגמאות, משתנה הסביבה firmware_type מראה באיזה מצב המחשב עלה:
C:\> echo %firmware_type%UEFIהפקודה Get-Partition של PowerShell, שרק קוראת ואינה משנה דבר, מציגה את המחיצות של הדיסק הראשון:
PS C:\> Get-Partition -DiskNumber 0 | Format-Table PartitionNumber, Type, DriveLetter, @{n='SizeMB';e={[int]($_.Size/1MB)}} -AutoSizePartitionNumber Type DriveLetter SizeMB
--------------- ---- ----------- ------
1 System 100
2 Reserved 16
3 Basic C 488268המחיצה מסוג System, בגודל 100MB ובלי אות כונן, היא ה-ESP. המחיצה השלישית היא כונן C:, ובה תיקיית Windows.
תרחיש 2: ה-ESP נמחקה בזמן סידור הדיסק
טכנאית סידרה מחיצות במחשב UEFI עם Windows 10. היא ראתה מחיצת FAT32 קטנה בלי אות כונן, הניחה שזו שארית מיותרת ומחקה אותה. מאז המחשב לא עולה.
| קובץ | איפה הוא שמור | מה מצבו אחרי המחיקה |
|---|---|---|
bootmgfw.efi | ESP | נמחק |
| מאגר ה-BCD | ESP | נמחק |
winload.efi ו-ntoskrnl.exe | התיקייה System32 שבמחיצת Windows | שלמים |
hiberfil.sys | השורש של C: | שלם |
winre.wim, סביבת השחזור WinRE | בדרך כלל מחיצת שחזור נפרדת | שלם |
הרשומה ב-NVRAM עדיין קיימת, אבל היא מצביעה על קובץ שכבר איננו, והקושחה נשארת בלי מה להפעיל. מערכת ההפעלה עצמה שלמה לגמרי, ומה שאבד הוא רק הדרך להגיע אליה.
התיקון: יוצרים ESP חדשה, ומעתיקים אליה את קובצי האתחול מתוך תיקיית Windows בעזרת הכלי bcdboot, שמוסבר בחלק על תיקון תקלות.
טעויות נפוצות
- במחשב UEFI עם Windows 10, הקושחה מפעילה את NTLDR מה-ESP. NTLDR שייך לדור של XP, ואין אותו ב-Windows 10. מה שהקושחה מפעילה הוא
bootmgfw.efi. - הקושחה מדלגת על מנהל האתחול ומפעילה ישר את winload.efi, או אפילו את ntoskrnl.exe. הקושחה מפעילה רק את
bootmgfw.efi. הוא בוחר רשומה ומפעיל אתwinload.efi, והטוען מביא את הליבה. - גם UEFI קורא קודם את ה-MBR ובודק שבסופו כתוב 0x55AA. כך עובד BIOS מסורתי. UEFI קורא קובץ מתוך ה-ESP לפי רשומה ב-NVRAM.
- את הנתיב למנהל האתחול הקושחה לוקחת מ-boot.ini או מנתיב ARC. שניהם שייכים ל-NTLDR של XP. קושחת UEFI נעזרת ברשומות ששמורות ב-NVRAM שלה.
- bootmgfw.efi נמצא ב-System32, או בשורש C: לצד boot.ini. המקום שלו הוא ה-ESP, מחיצה נפרדת ממחיצת Windows.
- smss.exe נטען מה-ESP כבר בשלב הקושחה.
smss.exeהוא התהליך הראשון במצב משתמש, והוא עולה רק אחרי שהליבה כבר רצה.
בדקו את עצמכם
מחברים כונן USB עם כלי שחזור למחשב UEFI שמעולם לא ראה אותו. איזה קובץ בכונן הקושחה תנסה להפעיל?
את \EFI\Boot\bootx64.efi, נתיב הגיבוי, כי אין לכונן הזה רשומה ב-NVRAM.
במחשב UEFI, באיזה נתיב ובאיזו מחיצה נמצא מאגר ה-BCD?
בנתיב \EFI\Microsoft\Boot\BCD, בתוך ה-ESP.
ה-ESP נמחקה. האם חייבים להתקין את Windows מחדש?
לא. הטוען והליבה שלמים במחיצת Windows, ולכן יוצרים ESP חדשה ומעתיקים אליה את קובצי האתחול עם bcdboot.
מפת המחיצות: איזה קובץ יושב באיזו מחיצה
הרבה שאלות על אתחול מסתכמות בשאלה איפה קובץ מסוים נמצא. הטבלה הבאה מסודרת לפי מה שמחפשים, ולצד כל פריט כתובה המחיצה שבה הוא נמצא:
| מה מחפשים | באיזו מחיצה | הערה |
|---|---|---|
bootmgfw.efi וה-BCD של מחשב UEFI | ESP (במחשב UEFI עם דיסק GPT) | מכאן הקושחה מפעילה את מנהל האתחול |
bootmgr והתיקייה \Boot עם ה-BCD של מחשב BIOS | System Reserved (במחשב BIOS עם דיסק MBR) | זו המחיצה שממלאת אצל BIOS את התפקיד של ה-ESP. בהתקנה שבה היא לא קיימת, הקבצים האלה עוברים לשורש C:. |
winload, winresume, ntoskrnl.exe, מנהלי ההתקן וקובצי ה-Registry | מחיצת Windows (C:), בתוך תיקיית Windows | המחיצה היחידה שקיימת בכל מחשב |
hiberfil.sys ו-pagefile.sys | מחיצת Windows (C:), בשורש שלה | קובץ התרדמה וקובץ ההחלפה של Windows |
winre.wim, הקובץ של סביבת השחזור WinRE | מחיצת שחזור (Recovery), שיש ברוב ההתקנות | משמשת לתיקון, ואין לה תפקיד בניהול האתחול |
ועוד מלכודת אחת, של שמות. בעגה של Microsoft, המחיצה שממנה האתחול יוצא לדרך (ה-ESP או System Reserved) היא ה-System partition, ואילו זו שמחזיקה את Windows עצמה היא ה-Boot partition.
הצירוף נשמע הפוך, ולכן בשאלות כדאי להיאחז במה שיש בתוך המחיצה ולא בתווית שלה.
טעויות נפוצות
- WinRE נמצאת ב-ESP, ולכן ה-ESP היא בעצם מחיצת השחזור. WinRE יושבת בדרך כלל במחיצת שחזור משלה. ה-ESP מחזיקה את קובצי האתחול.
- ESP ו-System Reserved הן אותה מחיצה, רק בשמות שונים. התפקיד שלהן דומה, אבל כל אחת שייכת לסוג קושחה אחר: ESP ל-UEFI, ו-System Reserved ל-BIOS.
- ה-ESP היא המחיצה שבה מותקנת Windows, ומשם הקושחה מריצה את winload.efi. תיקיית Windows ו-
winload.efiנמצאות במחיצת Windows. מה-ESP הקושחה מריצה אתbootmgfw.efi, והוא מפעיל את הטוען.
בדקו את עצמכם
במחשב UEFI, איפה תמצאו את bootmgfw.efi, ואיפה את winload.efi?
bootmgfw.efi ב-ESP, ו-winload.efi בתיקייה System32 שבמחיצת Windows.
במחשב BIOS שבו לא נוצרה מחיצת System Reserved, איפה יימצא bootmgr?
בשורש כונן C:, יחד עם התיקייה \Boot.
Windows Boot Manager, winload ו-winresume
מנהל האתחול ותפריט הבחירה
מאז Windows Vista, החלק של Windows בתהליך האתחול מתחיל תמיד ב-Windows Boot Manager. במחשב BIOS הוא נקרא bootmgr, ובמחשב UEFI הוא bootmgfw.efi.
הדרך הטובה להבין אותו היא לראות אותו בעבודה. במחשב לדוגמה יש שלוש רשומות: Windows 10, אותה Windows 10 במצב בטוח, ו-Windows XP ישנה בדיסק נוסף.
- מנהל האתחול פותח את ה-BCD (Boot Configuration Data), מאגר הגדרות האתחול, ומוצא בו את שלוש הרשומות.
- יש יותר מאחת, ולכן מוצג תפריט. מנהל האתחול מחכה, ואם עד סוף זמן ההמתנה איש לא בחר, הוא לוקח את ברירת המחדל.
- נבחרה Windows 10. ברשומה שלה כתוב באיזה דיסק ובאיזו מחיצה היא יושבת, ולפי זה מנהל האתחול מפעיל את הטוען
winload. אילו חיכה במחשב קובץ תרדמה תקין, הוא היה מפעיל במקומו אתwinresume.
שימו לב מאיפה הגיע המידע על המחיצה: מהרשומה, ורק ממנה. אין חיפוש של winload.exe על פני הדיסקים, ואין גם קריאה מה-Registry, שנטען רק כש-Windows עצמה עולה.
ואילו במחשב היה רק Windows 10 אחת? אז לא היה מופיע תפריט בכלל. כשיש ב-BCD רשומה יחידה, מנהל האתחול ניגש ישר לאתחול שלה.
התפריט עצמו הוא בחירה של מה לאתחל הפעם, ותו לא. בחירת המשתמש שייכנס, שינוי מחיצות ועדכון קושחה הם עניין של שלבים אחרים ושל כלים אחרים.
| נושא | NTLDR (עד XP) | Windows Boot Manager (מ-Vista) |
|---|---|---|
| מאיפה הוא לוקח את ההגדרות | מקובץ הטקסט boot.ini | ממאגר ה-BCD |
| כמה מערכות הפעלה | כמה, דרך התפריט | כמה, דרך התפריט |
| סוג קושחה | BIOS בלבד, בלי תמיכה ב-UEFI | גרסה ל-BIOS (bootmgr) וגרסה ל-UEFI (bootmgfw.efi) |
| מי טוען את הליבה | NTLDR עצמו | הטוען winload, שמנהל האתחול מפעיל |
winload.טעויות נפוצות
- לפני כל אתחול, מנהל האתחול מריץ chkdsk כדי לוודא שהדיסק תקין. בדיקת מערכת הקבצים היא העבודה של chkdsk. מנהל האתחול רק קורא את ה-BCD ומפעיל את הטוען.
- מנהל האתחול מציג את המסך הגרפי של Windows ומתקין עדכוני דרייברים. שני הדברים קורים אחרי שהליבה עלתה, ואין לו יד בהם.
- Windows Boot Manager יודע להתמודד רק עם מערכת הפעלה אחת. בשביל כמה מערכות קיים התפריט, וכל רשומה ב-BCD היא אפשרות בו.
- התמיכה ב-UEFI זהה אצל NTLDR ואצל Windows Boot Manager. NTLDR נכתב לעולם של BIOS ולא יודע לעבוד עם UEFI. ל-Windows Boot Manager יש גרסה לכל אחד משני סוגי הקושחה.
- מנהל האתחול מוצא את מחיצת Windows לפי המפתח HKLM\SYSTEM שב-Registry. בשלב הזה ה-Registry עוד לא נטען. המיקום כתוב ברשומת ה-BCD.
בדקו את עצמכם
על מחשב נייד מותקנת רק Windows 11, וב-BCD יש רשומה אחת. האם המשתמש יראה תפריט בחירה?
לא. כשיש רשומה יחידה, מנהל האתחול מדלג על התפריט ומאתחל אותה מיד.
מאיפה מנהל האתחול יודע באיזו מחיצה מותקנת Windows?
מהרשומה שלה ב-BCD.
winload: הליבה, HAL ומנהלי ההתקן של האתחול
השם הרשמי הוא Windows Boot Loader, והקובץ הוא winload.exe במחשב BIOS או winload.efi במחשב UEFI. בניגוד למנהל האתחול, הוא לא יושב במחיצה שהאתחול מתחיל ממנה אלא בתוך התקנת Windows עצמה, בתיקייה %SystemRoot%\System32 (בהתקנה רגילה: System32 שתחת C:\Windows).
על המחשב שעליו הורצו הדוגמאות, שתי הגרסאות של הטוען, וגם שתי הגרסאות של רכיב החזרה מתרדמה שנכיר מיד, יושבות זו לצד זו באותה תיקייה:
C:\> dir /b C:\Windows\System32\winload.* C:\Windows\System32\winresume.*winload.efi
winload.exe
winresume.efi
winresume.exeהמחשב הזה עולה במצב UEFI, ולכן בפועל רצים אצלו הקבצים שמסתיימים ב-.efi.
מה הטוען צריך להביא כדי שהליבה תוכל לעמוד על הרגליים? מנהל האתחול מוסר לו את ההגדרות של הרשומה שנבחרה, ולפיהן הוא אוסף ארבעה פריטים:
| מה נטען | מה זה | למה אי אפשר בלעדיו |
|---|---|---|
ntoskrnl.exe | הליבה | בלי ליבה אין מערכת הפעלה |
hal.dll | HAL (Hardware Abstraction Layer) | מתווך בין הליבה לבין החומרה, כדי שאותה ליבה תתאים למחשבים שונים |
SYSTEM, מהתיקייה %SystemRoot%\System32\config | קובץ Registry | רשום בו אילו מנהלי התקן צריכים לעלות כבר בשלב האתחול |
| Boot drivers, למשל של בקר הדיסק ושל מערכת הקבצים | מנהלי ההתקן של האתחול | בעזרתם הליבה תמשיך לקרוא קבצים מהדיסק בכוחות עצמה |
ברגע שהרשימה הושלמה, winload מעביר את המעבד לליבה, ותפקידו נגמר. הליבה מכינה את עצמה, ואז יוצרת את התהליך הראשון שרץ במצב משתמש ולא כחלק ממנה: smss.exe (Session Manager).
אחריו, כל אחד בתורו, מגיעים wininit.exe, winlogon.exe ומסך הכניסה.
| רכיב | מה הוא תורם | האם הליבה כבר פועלת כשהוא רץ? |
|---|---|---|
bootmgr או bootmgfw.efi | בוחר רשומה מתוך ה-BCD ומעביר את העבודה לטוען | לא |
winload.exe או winload.efi | מעמיס לזיכרון את הליבה, את HAL, את קובץ SYSTEM ואת מנהלי ההתקן של האתחול | לא |
ntoskrnl.exe | הוא הליבה עצמה | מתחילה לפעול ברגע ש-winload מוסר לה את המעבד |
smss.exe, ואחריו wininit.exe | פותחים את עולם התהליכים של המשתמש | כן |
טעויות נפוצות
- את הליבה טוען bootmgr.
bootmgrרק מפעיל אתwinload. הטוען הוא שמביא אתntoskrnl.exeלזיכרון. - smss.exe מופעל עוד לפני הליבה, ישירות ממנהל האתחול.
smss.exeהוא תהליך במצב משתמש, והליבה היא שמפעילה אותו אחרי שאתחלה את עצמה. - winload הוא הכלי שפותח את Recovery Console. Recovery Console הוא כלי תיקון של XP.
winloadטוען ליבה ומנהלי התקן, ותו לא. - winload עורך ערכים ב-HKLM תוך כדי ריצה, או מאפס משתני סביבה של ה-BIOS. הוא רק קורא את קובץ SYSTEM כדי לדעת אילו מנהלי התקן לטעון. עריכת Registry ומשתנים של ה-BIOS אינן חלק מהתפקיד שלו.
- גם ב-Windows 10, מי שטוען את הליבה הוא ntldr. NTLDR שייך למשפחה של NT עד Server 2003. מ-Vista ואילך הטוען הוא
winload.
בדקו את עצמכם
למה winload חייב להביא לזיכרון את מנהל ההתקן של הדיסק עוד לפני שהליבה מתחילה לפעול?
כי בלעדיו לליבה אין דרך לקרוא מהדיסק את שאר הקבצים שהיא צריכה.
איזה קובץ Registry winload קורא, ולשם מה?
את SYSTEM שבתיקייה %SystemRoot%\System32\config, כי ממנו הוא לומד אילו מנהלי התקן צריכים לעלות כבר באתחול.
מהו התהליך הראשון במצב משתמש, ומי מפעיל אותו?
smss.exe, והליבה היא שמפעילה אותו.
winresume: חזרה מתרדמה, ו-Fast Startup
לפני שהוא בוחר טוען, מנהל האתחול שואל, לפי מה שכתוב ב-BCD, שאלה אחת: האם בשורש C: מחכה קובץ תרדמה תקין בשם hiberfil.sys? התשובה קובעת את המשך הדרך:
- אין קובץ כזה: מופעל
winload.exe, והליבה נבנית מההתחלה. - יש קובץ כזה: מופעל
winresume.exe(במחשב UEFIwinresume.efi). הוא קורא את הקובץ, מחזיר לזיכרון את מה שהיה בו ומשחזר את מצב המערכת, כך שהעבודה ממשיכה מאותה נקודה.
מאיפה מגיע הקובץ? כשבוחרים Hibernate (תרדמה), Windows מעבירה את כל תוכן הזיכרון אל hiberfil.sys, ורק כשזה גמור היא מכבה את החשמל.
ב-BCD עצמו מסומן הקשר בין שתי האפשרויות: ברשומת Windows יש אלמנט בשם resumeobject, שמחזיק הפניה לרשומה של החזרה מתרדמה.
יש עוד מקור לקובץ, שמפתיע רבים. Fast Startup, שדולקת מראש ב-Windows 8 ובגרסאות 10 ו-11 שאחריה, הופכת גם כיבוי רגיל לתרדמה חלקית: ב-Shut down נשמר ב-hiberfil.sys מצב הליבה, ולכן את ההדלקה הבאה מנהל winresume.
רק Restart לא משתתף בזה. הוא מאתחל ליבה חדשה דרך winload בכל מצב.
| מה המשתמש בחר | Fast Startup | מי יופעל בהדלקה הבאה |
|---|---|---|
| Hibernate | לא משנה | winresume |
| Shut down | כבוי | winload |
| Shut down | פועל | winresume |
| Restart | לא משנה | winload |
תרחיש 3: שלושה ימים של מחשב אחד
במחשב של מיכל Fast Startup כבוי.
- ביום שלישי בערב היא בוחרת Shut down. ביום רביעי בבוקר מנהל האתחול לא מוצא קובץ תרדמה תקין, מפעיל את
winload.exe, והליבה נטענת מההתחלה. - ביום רביעי בערב, באמצע עבודה על גיליון אלקטרוני, היא בוחרת Hibernate.
- ביום חמישי בבוקר מנהל האתחול מוצא קובץ תרדמה תקין ומפעיל את
winresume.exe. הגיליון פתוח באותה שורה שבה היא עצרה.
ומה עם wininit.exe? הוא לא השתתף בשחזור. זה תהליך שמופיע רק כשהליבה כבר פועלת, והשחזור מהקובץ מתבצע לפני כן.
טעויות נפוצות
- בחזרה מתרדמה פועל אותו winload.exe כמו בכל אתחול. כשיש קובץ תרדמה תקין, מנהל האתחול מפעיל את
winresume.exeבמקום הטוען. - bootmgr פותח את hiberfil.sys ומשחזר את הזיכרון בעצמו. מנהל האתחול רק בודק אם יש קובץ תרדמה ומחליט את מי להפעיל. את השחזור עושה
winresume. - wininit.exe הוא שמחזיר את המערכת מקובץ התרדמה.
wininit.exeעולה רק אחרי שהליבה רצה, ולכן אין לו תפקיד בשלב הזה. - כש-Fast Startup פועל, גם Restart עובר דרך winresume. Restart תמיד מאתחל את הליבה מאפס דרך
winload. Fast Startup משנה רק את מה שקורה אחרי Shut down.
בדקו את עצמכם
לאן נכתב תוכן הזיכרון כשבוחרים Hibernate, ואיזה רכיב קורא אותו בהדלקה?
לקובץ hiberfil.sys בשורש C:, ו-winresume קורא אותו.
ב-Windows 11 עם הגדרות ברירת המחדל, המשתמש בחר Shut down. איזה רכיב יופעל בהדלקה הבאה?
winresume, כי Fast Startup פועל כברירת מחדל ושומר את מצב הליבה ב-hiberfil.sys.
איזה אלמנט ברשומת Windows ב-BCD מקשר אותה לרשומת החזרה מתרדמה?
resumeobject.
השיטה הישנה: NTLDR ו-boot.ini
NTLDR: מנהל האתחול של NT, 2000, XP ו-Server 2003
לפני Vista, האתחול של מערכות ה-NT היה בידי קובץ אחד: NTLDR (NT Loader). כך עלו ארבע מערכות: Windows NT, Windows 2000, Windows XP, וגרסת השרת Windows Server 2003.
NTLDR עבד עם שני שותפים, ושלושתם יושבים בשורש של מחיצת המערכת הפעילה, שבדרך כלל היא כונן C:.
| קובץ | מה תפקידו |
|---|---|
NTLDR | מנהל האתחול, וגם הטוען |
NTDETECT.COM | מזהה את החומרה בשלב האתחול |
boot.ini | קובץ טקסט: אילו מערכות מופיעות בתפריט, ואיך התפריט מתנהג |
תחילת הדרך זהה לזו של מחשב BIOS עם Windows 7: ה-BIOS מריץ את קוד ה-MBR, וקוד ה-MBR מפעיל את מגזר האתחול של המחיצה הפעילה. ההבדל הוא שכאן מגזר האתחול טוען את NTLDR ולא את bootmgr. משם:
- NTLDR קורא את
C:\boot.iniומציג את התפריט. - אחרי הבחירה הוא מריץ את
NTDETECT.COM, שמזהה את החומרה. - אחר כך NTLDR טוען בעצמו את
ntoskrnl.exe, אתhal.dll, את קובץ ה-Registry בשם SYSTEM ואת מנהלי ההתקן של האתחול.
מי שעבר ל-Vista קיבל מנגנון אחר לגמרי: Windows Boot Manager במקום NTLDR, ומאגר BCD במקום boot.ini. לכן אף גרסה מ-Vista ועד Windows 11 לא פותחת את boot.ini כחלק מהאתחול שלה.
במחשב Windows 10 שעליו הורצו הדוגמאות אין boot.ini בכלל. המתג /a מציג גם קבצים מוסתרים וקובצי מערכת, כך שהקובץ לא פשוט מוסתר:
C:\> dir /b /a C:\boot.iniFile Not Foundהחריג היחיד הוא מחשב שעליו, לצד Windows חדשה, מותקנת גם מערכת NT ישנה כמו XP. את התפריט מציג bootmgr, אבל כשבוחרים בו את XP הוא מעביר את המושכות ל-NTLDR הוותיק, וזה מתנהג כמו תמיד ופותח את boot.ini שלו.
טעויות נפוצות
- Windows 8.1 ו-Windows 10 עדיין מסתמכות על boot.ini. מ-Vista ואילך ההגדרות שמורות ב-BCD. boot.ini נקרא רק כשבוחרים מערכת ותיקה באתחול כפול, ואז NTLDR הוא שקורא אותו.
- ה-BIOS קורא את boot.ini, ולפי מה שכתוב בו מפעיל את NTLDR. הסדר הפוך. מגזר האתחול מפעיל את NTLDR, ו-NTLDR קורא את boot.ini.
בדקו את עצמכם
מבין Windows NT, Windows 8 ו-Windows Server 2003, אילו קוראות את boot.ini באתחול רגיל?
Windows NT ו-Windows Server 2003. Windows 8 משתמשת ב-BCD.
במחשב עם אתחול כפול (Dual boot) של Windows 10 ו-XP, מי קורא את boot.ini, ומתי?
NTLDR, אחרי ש-bootmgr מסר לו את השליטה כשנבחרה XP בתפריט.
boot.ini: מיקום, תכונות ודרכי עריכה
איפה מחפשים את boot.ini? לא בתיקיית Windows, וגם לא באף תיקייה שמתחתיה כמו System32 או config. הוא יושב בשורש של מחיצת המערכת הפעילה, ובמחשב טיפוסי פירוש הדבר C:\boot.ini.
שלוש תכונות (Attributes) מגינות עליו:
| תכונה | האות בפקודה attrib | מה היא עושה |
|---|---|---|
| Hidden | H | סייר הקבצים לא מציג את הקובץ כברירת מחדל |
| System | S | הקובץ מסומן כקובץ מערכת |
| Read-only | R | אי אפשר לשמור עליו שינויים עד שמסירים את התכונה |
פתחו אותו בכל עורך טקסט ותראו את כל מה שהוא יודע: אילו התקנות של Windows יש במחשב, איפה כל אחת נמצאת, איך קוראים לה בתפריט ועם אילו מתגים היא נטענת. אין בו הצפנה ואין בו תוכן בינארי.
לכן תשובה שמייחסת ל-boot.ini סדר טעינה של מנהלי התקן, חשבונות משתמשים, שם מחשב, שירותים או משתני סביבה היא תשובה שגויה. כל אלה חיים במקומות אחרים במערכת.
התכונה Hidden מסבירה מצב שמבלבל מתחילים. בדוגמה הבאה יצרנו על Windows 10, בתיקיית עבודה רגילה, קובץ תרגול בשם boot.ini ונתנו לו את שלוש התכונות. הפקודה dir הרגילה לא מוצאת אותו:
attrib +s +h +r boot.ini
dir /b boot.iniFile Not Foundהמתג /a:h מבקש מ-dir להציג דווקא קבצים מוסתרים, ועכשיו הקובץ מופיע:
dir /b /a:h boot.iniboot.iniב-XP יש שלוש דרכים לשנות את הקובץ:
| דרך | איפה | מה עושים שם |
|---|---|---|
| עריכה ידנית | מציגים קבצים מוסתרים, מורידים את Read-only ופותחים בפנקס רשימות (Notepad) | כל שינוי שרוצים |
| System Properties | הלשונית Advanced, החלק Startup and Recovery | בוחרים מערכת ברירת מחדל וקובעים זמן המתנה, והכפתור Edit פותח את הקובץ בפנקס רשימות |
| msconfig | הלשונית BOOT.INI | מסמנים מתגים בתיבות סימון |
עריכה ידנית משורת הפקודה של XP נראית כך. השורה השנייה שומרת עותק לפני השינוי, כי טעות בקובץ עלולה להשאיר את המחשב בלי מערכת שעולה. זה רצף של XP, ולכן הוא מוצג בלי פלט:
attrib -r -h -s C:\boot.ini
copy C:\boot.ini C:\boot.bak
notepad C:\boot.ini
attrib +r +h +s C:\boot.iniטעויות נפוצות
- boot.ini שמור בתיקיית Windows, ב-System32 או בתיקייה config. הוא יושב בשורש של מחיצת המערכת הפעילה, לרוב
C:\boot.ini. - boot.ini הוא קובץ בינארי, ועורכים אותו ב-regedit או בתוכנה מיוחדת שמפענחת אותו. זה טקסט רגיל ולא מוצפן, ופנקס רשימות מספיק כדי לערוך אותו.
- boot.ini היא תוכנית שטוענת את הליבה. זה קובץ הגדרות בלבד. את הליבה טוען NTLDR, אחרי שקרא את ההגדרות מהקובץ.
- משנים את boot.ini דרך לשונית Startup ב-Task Manager, דרך Device Manager, או בפקודה bcdedit /edit. bcdedit לא קיים ב-XP ועוסק ב-BCD, ל-Device Manager אין הגדרות אתחול, ולשונית Startup נוספה ל-Task Manager רק ב-Windows 8.
- boot.ini מחזיק את רשימת המשתמשים, את קובצי ה-Registry או את סדר הטעינה של מנהלי ההתקן. הוא מחזיק רק את הגדרות התפריט ואת המיקום ופרמטרי הטעינה של כל התקנה.
בדקו את עצמכם
ב-XP פתחתם את כונן C: בסייר הקבצים, ו-boot.ini לא מופיע. האם הקובץ אבד?
לא בהכרח. הוא מסומן Hidden ו-System, ולכן צריך להפעיל הצגה של קבצים מוסתרים כדי לראות אותו.
ניסיתם לשמור שינוי ב-boot.ini בפנקס רשימות, והשמירה נכשלה. איזו תכונה כנראה עדיין מסומנת?
Read-only. מסירים אותה (למשל עם attrib -r) לפני העריכה.
המבנה: הסעיף [boot loader] והסעיף [operating systems]
תוכן הקובץ מתחלק לשני חלקים (Sections), וכל אחד מהם נפתח בכותרת בסוגריים מרובעים. שורה שייכת תמיד לכותרת האחרונה שהופיעה מעליה.
כך ייראה הקובץ אחרי התקנה רגילה של XP, במחשב שבו היא הותקנה במחיצה השלישית של הדיסק הקשיח השני:
[boot loader]
default=multi(0)disk(0)rdisk(1)partition(3)\WINDOWS
timeout=30
[operating systems]
multi(0)disk(0)rdisk(1)partition(3)\WINDOWS="Microsoft Windows XP Professional" /fastdetectמתחת לכותרת [boot loader] רשומות ההגדרות של התפריט כולו. יש שם שתי שורות בצורה שם=ערך, ואין משמעות לסדר ביניהן:
| שורה | מה היא קובעת | ערכים שכדאי להכיר |
|---|---|---|
timeout= | כמה שניות התפריט נשאר על המסך לפני שהאתחול ממשיך לבד | התקנה רגילה של XP כותבת 30. הערך 0 מבטל את התפריט, ומערכת ברירת המחדל עולה מיד. |
default= | איזו מערכת תעלה אם המשתמש לא בחר כלום עד שה-timeout נגמר | נתיב ARC, זהה לאחת השורות שבסעיף [operating systems] |
default הוא רק מה שקורה כשאף אחד לא נוגע במקלדת. אם מישהו מספיק לבחור בתפריט התקנה אחרת, היא זו שתעלה.
מתחת ל-[operating systems] כל התקנה שמופיעה בתפריט מקבלת שורה משלה. נפרק את השורה מהדוגמה:
| חלק בשורה | בדוגמה | תפקידו |
|---|---|---|
| נתיב ARC, משמאל לסימן השוויון | multi(0)disk(0)rdisk(1)partition(3)\WINDOWS | מכוון לדיסק, למחיצה ולתיקייה של ההתקנה |
| שם התצוגה, מימין לסימן השוויון ובין מירכאות | Microsoft Windows XP Professional | הטקסט שהמשתמש יראה בתפריט |
| מתגים (Switches) בסוף השורה | /fastdetect | משנים את אופן הטעינה של ההתקנה הזו |
השורות מתחת ל-[operating systems] מסודרות כמו שהן יופיעו על המסך, אבל המיקום ברשימה לא נותן לאף אחת עדיפות. ההתקנה שתעלה מעצמה היא זו שה-default מכוון אליה, גם אם היא האחרונה.
תרחיש 4: מי יעלה כשלא נוגעים במקלדת
במחשב של מעבדה מותקנות שתי מערכות, וזה ה-boot.ini שלו:
[boot loader]
timeout=15
default=multi(0)disk(0)rdisk(2)partition(1)\WINNT
[operating systems]
multi(0)disk(0)rdisk(1)partition(2)\WINDOWS="XP Office" /fastdetect /noguiboot
multi(0)disk(0)rdisk(2)partition(1)\WINNT="Windows 2000 Server" /fastdetect /sos- הערך של timeout גדול מאפס, ולכן תפריט עם שתי האפשרויות יופיע ל-15 שניות.
- default מצביע על rdisk(2), כלומר על הדיסק השלישי. אם אף אחד לא בחר עד שהזמן נגמר, NTLDR יטען את Windows 2000 Server.
- העובדה ש-XP Office רשומה ראשונה לא משנה דבר.
- מי שבוחר XP Office לפני שעברו 15 השניות, יקבל את XP Office.
- אילו היה כתוב timeout=0, התפריט לא היה מופיע, ו-Windows 2000 Server הייתה עולה מיד.
טעויות נפוצות
- שני הסעיפים של boot.ini הם [timeout] ו-[default]. אלה שתי שורות בתוך הסעיף [boot loader]. הסעיף השני הוא [operating systems]. גם שמות כמו [boot manager], [system paths], [startup options] או [windows] לא קיימים בקובץ.
- default= קובע כמה זמן התפריט מוצג. את הזמן קובע timeout=. השורה default= בוחרת מה ייטען כשהזמן נגמר.
- המערכת שב-default תעלה גם אם המשתמש בחר בתפריט מערכת אחרת. בחירה של המשתמש גוברת. default חל רק כשלא נבחר כלום.
- בשורה default= כותבים /safeboot כדי לאתחל במצב בטוח. /safeboot הוא מתג שמוסיפים בסוף שורת מערכת ההפעלה, בסעיף [operating systems].
- תמיד נטענת המערכת שכתובה ראשונה ב-[operating systems]. המיקום ברשימה קובע רק את סדר ההצגה. נטענת המערכת שמופיעה ב-default.
- timeout=30 אומר שהמחשב יכבה אחרי 30 דקות, שאפשר לרשום עד 30 מערכות, או שחיסכון החשמל נכנס לפעולה. זה רק מספר השניות שהתפריט מוצג לפני שהאתחול ממשיך.
- בסעיף [operating systems] מגדירים ממשק גרפי, רשימת מנהלי מערכת או רשימת דרייברים. הסעיף מחזיק לכל התקנה את נתיב ה-ARC שלה ואת השם שיוצג בתפריט, ואחריהם מתגים.
בדקו את עצמכם
מנהל מעבדה רוצה שבתפריט יופיעו חמש התקנות ממשפחת NT. כמה שורות יהיו מתחת ל-[operating systems], והאם timeout ו-default נכללות בספירה?
חמש, אחת לכל התקנה, ולא שורה אחת עם רשימה מופרדת בפסיקים. timeout ו-default לא נספרות, כי הן שייכות ל-[boot loader].
הקובץ מכיל timeout=0, ותחת [operating systems] יש ארבע שורות. מה יראה המשתמש כשהמחשב עולה?
שום תפריט. NTLDR יטען מיד את המערכת שמופיעה ב-default.
באיזה סעיף נמצאת השורה שקובעת מה ייטען כברירת מחדל?
בסעיף [boot loader].
בתפריט שתי מערכות, וה-default מצביע על השנייה. המשתמש בחר את הראשונה אחרי חמש שניות, כש-timeout=20. מה ייטען?
המערכת הראשונה, כי המשתמש בחר לפני שהזמן נגמר.
נתיב ARC: דיסק, מחיצה ותיקייה
למה boot.ini לא כותב פשוט C:\WINDOWS? כי בזמן ש-NTLDR רץ, לאף מחיצה עוד אין אות: את האותיות Windows מחלקת רק כשהיא כבר פועלת. במקום אות, כל התקנה מתוארת ככתובת בחומרה, בתחביר שנקרא ARC (Advanced RISC Computing).
נפרק נתיב לדוגמה לחלקים:
multi(0)disk(0)rdisk(1)partition(3)\WINXP| חלק | על מה הוא מצביע | מאיזה מספר מתחילים לספור |
|---|---|---|
multi(0) | מספר הבקר (Controller) שה-BIOS נעזר בו כדי להגיע לדיסקים | 0 |
disk(0) | בתחביר multi הוא לא משתנה, ותמיד יהיה 0 | 0 |
rdisk(1) | איזה דיסק פיזי, לפי המספור של ה-BIOS. הערך 1 פירושו הדיסק השני. | 0 |
partition(3) | איזו מחיצה בתוך אותו דיסק. הערך 3 פירושו המחיצה השלישית. | 1 |
\WINXP | שם תיקיית ההתקנה בתוך המחיצה | אין כאן מספר |
rdisk(0)partition(1)\WINDOWS.כל תפקידו של נתיב ARC הוא לכוון את NTLDR להתקנה אחת. לכן שלוש פרשנויות נפוצות שגויות: שהוא מצביע על ה-MBR, שהוא קובע לאיזה כונן ה-BIOS יפנה קודם, או שהוא מונה את המחיצות שבדיסק.
תרחיש 5: תרגול בפענוח
| נתיב ARC | איזה דיסק | איזו מחיצה |
|---|---|---|
multi(0)disk(0)rdisk(0)partition(4)\WINDOWS | הראשון | הרביעית |
multi(0)disk(0)rdisk(2)partition(1)\WINNT | השלישי | הראשונה, בתיקייה WINNT |
multi(0)disk(0)rdisk(1)partition(2)\WINDOWS | השני | השנייה |
שימו לב לשורה השנייה: הספרה 2 ב-rdisk היא הדיסק השלישי, ואילו הספרה 1 ב-partition היא המחיצה הראשונה. אותו מספר מתורגם אחרת בכל חלק, כי הספירה מתחילה מ-0 בדיסקים ומ-1 במחיצות.
עם Vista הגיע ה-BCD, שנפרט עליו בהמשך, ותפס את מקומם של boot.ini ושל נתיבי ה-ARC שבו. כך נראות שתי השיטות זו מול זו:
| נושא | boot.ini עם נתיב ARC | BCD |
|---|---|---|
| מי קורא את המיקום | NTLDR, במערכות NT עד Server 2003 | Windows Boot Manager, מ-Vista והלאה |
| צורת האחסון | קובץ טקסט שכל מערכת בו היא שורה | מאגר בינארי שכל מערכת בו היא רשומה |
| תיאור המיקום | מספרים סידוריים של בקר, דיסק ומחיצה | האלמנטים device ו-osdevice, שמזהים דיסק לפי החתימה שלו או לפי GUID |
| הפניה לרשומה מסוימת | כותבים את נתיב ה-ARC שלה | משתמשים ב-GUID הקבוע שלה |
טעויות נפוצות
- partition(1) היא המחיצה השנייה בדיסק. הספירה של partition מתחילה מ-1, ולכן partition(1) היא הראשונה.
- rdisk(0) הוא הדיסק השני. הספירה של rdisk מתחילה מ-0, ולכן rdisk(0) הוא הדיסק הראשון.
- נתיב ARC אומר איפה נמצא ה-MBR, באיזה סדר ה-BIOS עובר על הכוננים, או כמה מחיצות יש בדיסק. הוא מצביע על דבר אחד: הדיסק, המחיצה והתיקייה של התקנה מסוימת.
- נתיבי ARC הם השיטה החדשה, שהחליפה את ה-BCD ב-Vista. הסדר הפוך. boot.ini ונתיבי ה-ARC שבו קדמו ל-BCD.
- boot.ini מחזיק את המיקום בפורמט בינארי ששמור ב-Registry, ואילו ה-BCD הוא טקסט פתוח. גם כאן הכול הפוך: boot.ini הוא טקסט, וה-BCD הוא בינארי.
- boot.ini וה-BCD שומרים את המיקום באותה שיטה בדיוק, והשוני ביניהם הוא רק שם הקובץ. אלה שני מנגנונים שונים: מספרים לפי סדר החומרה מול אלמנטים עם חתימת דיסק או GUID.
בדקו את עצמכם
כתבו נתיב ARC לתיקייה WINNT במחיצה הרביעית של הדיסק הקשיח השני.
multi(0)disk(0)rdisk(1)partition(4)\WINNT
בנתיב כתוב rdisk(3)partition(3). האם הדיסק והמחיצה כאן באותו מספר סידורי?
לא. rdisk(3) הוא הדיסק הרביעי, ו-partition(3) היא המחיצה השלישית.
המתגים שבסוף שורת מערכת ההפעלה
לכל שורה ב-[operating systems] אפשר לצרף בסופה מתגים. מזהים אותם לפי הלוכסן שבתחילתם, וכל אחד משפיע רק על ההתקנה שבאותה שורה.
הטבלה מסודרת לפי המטרה, כי כך השאלות בדרך כלל מנוסחות: מה רוצים להשיג, ואיזה מתג עושה את זה.
| מה רוצים להשיג | המתג | איך זה עובד |
|---|---|---|
| לקצר את האתחול | /fastdetect | NTDETECT מוותר על סריקה של היציאות הטוריות (COM) והמקביליות (LPT). מה שמחובר אליהן יתגלה מאוחר יותר דרך Plug and Play של Windows. התקנת XP מוסיפה את המתג לבד. |
| לעלות במצב בטוח (Safe Mode) | /safeboot:minimal | רק מנהלי ההתקן והשירותים שבלעדיהם אי אפשר |
| מצב בטוח שבו יש רשת | /safeboot:network | כמו minimal, ובנוסף תמיכה ברשת |
| ש-NTLDR יבחר HAL בעצמו | /detecthal | הוא בוחן את החומרה, למשל את מספר המעבדים ואם יש ACPI, ולפי זה בוחר את קובץ ה-HAL |
| לכפות HAL מסוים | /hal= | שם הקובץ כתוב במתג עצמו, ו-NTLDR לא בוחן את החומרה |
| להגביל את ה-RAM | /maxmem= | Windows לא תנצל זיכרון פיזי מעבר לכמות שנכתבה |
| לראות אילו מנהלי התקן נטענים | /sos | השמות מודפסים על המסך תוך כדי הטעינה |
| לקבל רשימה כתובה של מנהלי ההתקן שנטענו | /bootlog | הרשימה נשמרת בקובץ ntbtlog.txt שבתיקייה %SystemRoot% |
| לעקוף בעיה בכרטיס התצוגה | /basevideo | Windows עולה עם מנהל תצוגה VGA בסיסי |
| לוותר על מסך הפתיחה | /noguiboot | בזמן האתחול לא מוצג המסך הגרפי |
תזכורת: HAL (Hardware Abstraction Layer) היא השכבה שמפרידה בין הליבה לבין פרטי החומרה, וכך אותה ליבה יכולה לרוץ על מחשבים שונים בלי שינוי.
כך נראית שורה עם כמה מתגים יחד. המערכת הזו תעלה במצב בטוח, ובזמן הטעינה יוצגו שמות מנהלי ההתקן:
multi(0)disk(0)rdisk(1)partition(2)\WINDOWS="XP Office" /fastdetect /safeboot:minimal /sosומה תוקפו של מתג? כל עוד הוא כתוב בשורה, הוא בתוקף. אין לו תאריך תפוגה ואין לו מונה אתחולים, ולכן הוא חל על כל עלייה של המערכת עד שמישהו מוחק אותו מהקובץ.
תרחיש 6: Safe Mode שלא נגמר
טכנאי רוצה לבדוק מחשב XP בלי מנהלי ההתקן הרגילים. הוא פותח את msconfig, עובר ללשונית BOOT.INI, מסמן את התיבה /SAFEBOOT ושומר.
msconfig כותב את המתג /safeboot לשורה של אותה מערכת בתוך boot.ini. המחשב מופעל מחדש ועולה ב-Safe Mode, כמו שהטכנאי רצה.
יומיים אחר כך המשתמשת מתלוננת שהמחשב עדיין עולה במצב בטוח בכל פעם. זה צפוי: המתג עדיין כתוב בקובץ, ו-NTLDR מציית לו בכל אתחול. הפתרון: לחזור ל-msconfig, להוריד את הסימון מ-/SAFEBOOT ולשמור.
אם הטכנאי היה מסתפק בפעם אחת, היה עדיף ללחוץ F8 בזמן האתחול ולבחור Safe Mode בתפריט האפשרויות המתקדמות. בחירה כזו חלה על אתחול אחד בלבד, והקובץ לא משתנה.
טעויות נפוצות
- /fastdetect מבטל את בדיקת החתימה של מנהלי ההתקן. אין לו קשר לחתימות. הוא רק חוסך את החיפוש אחרי התקנים ביציאות הטוריות והמקביליות.
- /fastdetect מוותר על זיהוי Plug and Play של מתאם הרשת ושל כרטיס התצוגה, או חוסם חומרה חדשה עד שמישהו מאשר אותה. שני התיאורים שגויים. הוא נוגע רק ליציאות COM ו-LPT, וגם אותן Plug and Play מזהה מאוחר יותר.
- /detecthal קובע HAL קבוע, מגביל את הזיכרון או מעלה מצב בטוח. /detecthal דווקא בודק את החומרה ובוחר HAL מתאים. למטרות האחרות יש מתגים משלהן: /hal= בוחר HAL מראש, /maxmem= מגביל זיכרון, ו-/safeboot מעלה מצב בטוח.
- /SAFEBOOT שסומן ב-msconfig חל רק על האתחול הבא. המתג נכתב לתוך boot.ini ונשאר שם עד שמבטלים אותו, ולכן הוא חל על כל אתחול.
- סימון /SAFEBOOT גורם לתפריט F8 להופיע באתחול הבא. F8 היא דרך נפרדת וחד-פעמית. /SAFEBOOT מעלה את המערכת ישר ב-Safe Mode.
בדקו את עצמכם
מערכת XP נתקעת באמצע האתחול, ואתם רוצים לראות על המסך איזה מנהל התקן נטען אחרון. איזה מתג תוסיפו?
/sos, שמציג את שמות מנהלי ההתקן בזמן הטעינה.
הוספתם בעצמכם /safeboot:network לשורה ב-boot.ini. כמה אתחולים יעלו במצב בטוח?
כל האתחולים, עד שתמחקו את המתג מהקובץ.
באיזה מתג משתמשים כדי ש-NTLDR יבחר לבד את קובץ ה-HAL לפי החומרה?
/detecthal.
כש-boot.ini שגוי או חסר: תסמינים ותיקון
כש-XP לא עולה בגלל תקלה באתחול, ההודעה שעל המסך כבר מסגירה חלק גדול מהתשובה. שלושה מצבים שכדאי לזהות:
| מה רואים | מה זה אומר |
|---|---|
NTLDR is missing | חסר הקובץ NTLDR עצמו. לתוכן של boot.ini אין קשר להודעה הזו. |
Windows could not start because the following file is missing or corrupt, ואחריה שם של קובץ מתיקיית Windows, ברוב המקרים hal.dll | NTLDR מחפש את Windows במקום הלא נכון, למשל כי נתיב ה-ARC ב-boot.ini מכוון למחיצה אחרת |
| ההתקנה שבחרתם פשוט לא נטענת | השורות ב-boot.ini לא מתארות נכון את ההתקנה, ו-NTLDR לא מצליח למצוא אותה |
בשני המצבים האחרונים מתקנים את boot.ini עצמו. בשביל זה בדיוק קיימת עריכה ידנית שלו: ליישר נתיב ARC שמכוון למקום הלא נכון, לעדכן את default או את timeout, או לצרף מתג.
מי שמנסה כאן chkdsk יתאכזב. הכלי הזה מטפל במבנה של מערכת הקבצים, וקובץ שתקין מבחינת הדיסק אבל כתוב בו ערך שגוי יוצא ממנו בדיוק כמו שנכנס.
כש-XP לא עולה ואי אפשר לערוך מתוכה, יש סביבת תיקון שמפעילים מתקליטור ההתקנה: Recovery Console, שורת פקודה מצומצמת. ארבע מהפקודות שלה נוגעות לאתחול, וכל אחת מטפלת בשכבה אחרת:
| שכבה | פקודה | מה היא עושה |
|---|---|---|
| תחילת הדיסק | fixmbr | מחליפה את התוכנית שבסקטור הראשון של הדיסק בקוד MBR תקין |
| תחילת המחיצה | fixboot | רושמת מחדש את מגזר האתחול של מחיצת המערכת |
| הקובץ boot.ini | bootcfg /scan | מחפשת התקנות Windows בכל הדיסקים ומדפיסה אותן, בלי לגעת בשום קובץ |
| הקובץ boot.ini | bootcfg /rebuild | אותו חיפוש, ובסופו boot.ini חדש. על כל התקנה שנמצאה היא שואלת אם להכניס אותה לקובץ. |
מהעמודה הראשונה רואים למה fixmbr ו-fixboot לא יחזירו boot.ini שנמחק: הן כותבות סקטורים, ולא בונות קבצים.
כש-XP כן עולה, ל-bootcfg שבשורת הפקודה הרגילה שלה יש גם את המתג /addsw. הוא לא מחפש התקנות אלא רק מצרף מתג לשורה שכבר קיימת ב-boot.ini, ומכיר רק ארבעה: /sos, /basevideo, /noguiboot ו-/maxmem. מתג אחר, כמו /bootlog, מוסיפים בעריכה של הקובץ או דרך msconfig.
תרחיש 7: מישהו מחק את boot.ini
במעבדת מחשבים, תלמיד ניקה קבצים מוסתרים משורש C: במחשב XP ומחק בטעות את boot.ini. בהדלקה הבאה המחשב לא עולה כמו שצריך.
- מאתחלים מתקליטור ההתקנה של XP ונכנסים ל-Recovery Console.
- מריצים
bootcfg /rebuild. - הפקודה מוצאת את ההתקנה בתיקייה
C:\WINDOWSושואלת אם לצרף אותה. עונים בחיוב. - היא מבקשת שם שיוצג בתפריט ומתגים לטעינה, למשל
/fastdetect. - נכתב boot.ini חדש, והמחשב עולה.
מי שינסה לפתור את זה עם bcdedit /export לא יגיע רחוק. הכלי הזה שייך ל-Vista והלאה ומייצא את ה-BCD, ו-XP לא מכירה אף אחד מהשניים.
תרחיש 8: גם Recovery Console לא זמין
boot.ini פגום, ותקליטור ההתקנה שרוט ולא נטען, כך שאין דרך להגיע ל-Recovery Console.
הפתרון נשען על תכונה פשוטה של הקובץ: הוא טקסט, וכל מערכת הפעלה אחרת יכולה לפתוח אותו. מחברים את הדיסק כדיסק נוסף למחשב תקין, או מאתחלים את אותו מחשב מ-Live CD, מאתרים את boot.ini בשורש של מחיצת המערכת הפעילה ומתקנים אותו בעורך טקסט.
שלוש הצעות שנשמעות טוב ולא יעזרו כאן:
- Safe Mode: בוחרים בו מתוך התפריט ש-boot.ini עצמו בונה, ושום דבר בו לא מתקן את הקובץ.
- Last Known Good Configuration: מחזיר גרסה קודמת של הגדרות ב-Registry, ו-boot.ini אינו חלק מה-Registry.
- System Restore: גם הוא משחזר הגדרות מערכת ו-Registry ולא את boot.ini, ובנוסף הוא פועל רק בתוך Windows שכבר עלתה.
טעויות נפוצות
- boot.ini שנמחק משחזרים עם bcdedit /export. ב-XP אין bcdedit, ובכל מקרה הוא מטפל ב-BCD ולא ב-boot.ini.
- אפשר לשחזר את boot.ini אם עורכים את ה-BCD ב-Notepad. ב-XP אין BCD בכלל, וה-BCD גם אינו קובץ טקסט.
- מריצים fixboot מחלון cmd רגיל, והוא משחזר את תוכן boot.ini. fixboot היא פקודה של Recovery Console, והיא כותבת מגזר אתחול. את boot.ini היא לא בונה.
- bootcfg /rebuild משנה את הגודל של ה-ESP, או ממיר את ההגדרות לפורמט BCD. הפקודה בונה מחדש את boot.ini מההתקנות שמצאה בדיסקים, וזה הכול.
- bootcfg /rebuild רק מוסיף מתגים לשורות שכבר קיימות. זה התפקיד של
/addsw. ה-rebuild מחפש התקנות ובונה את הקובץ מחדש. - chkdsk מתקן ערכים שגויים בתוך boot.ini. chkdsk מתקן את מבנה מערכת הקבצים, ולא את מה שכתוב בתוך קובץ.
- כשהערכים ב-boot.ini שגויים, המחשב נכנס להגדרות ה-BIOS או מציג מסך כחול כבר בהתחלה. מה שקורה הוא ש-NTLDR לא מוצא את ההתקנה המבוקשת, והיא לא נטענת.
בדקו את עצמכם
ב-XP שעולה כרגיל רוצים לצרף /basevideo לשורה קיימת ב-boot.ini, בלי שום סריקה של הדיסקים. איזה מתג של bootcfg עושה את זה?
/addsw. הוא מוסיף לשורה קיימת אחד מארבעת המתגים שהוא מכיר (/sos, /basevideo, /noguiboot, /maxmem) ולא מחפש התקנות.
ואם רוצים לצרף באותה דרך את /bootlog?
את המתג הזה /addsw לא מכיר. מוסיפים אותו בעריכה של boot.ini, או מסמנים אותו ב-msconfig בלשונית שמוקדשת לקובץ.
מחשב XP מציג NTLDR is missing. האם הבעיה היא בתוכן של boot.ini?
לא. ההודעה הזו אומרת שהקובץ NTLDR עצמו חסר.
איזו פקודה של Recovery Console רק מציגה את ההתקנות שבדיסקים, בלי לבנות את הקובץ?
bootcfg /scan.
BCD: מאגר הגדרות האתחול
מה ה-BCD, איפה הוא שמור ולמה boot.ini פינה לו את המקום
נתחיל בניסוי מחשבתי. טכנאי שהתרגל ל-XP מחפש את הגדרות האתחול של מחשב Windows 10, מוצא קובץ בשם BCD ופותח אותו בפנקס רשימות. על המסך מופיעים תווים חסרי פשר, ואם ילחץ על שמירה, ייתכן שבהפעלה הבאה המחשב כבר לא יעלה.
ההסבר: BCD (Boot Configuration Data) הוא בכלל לא קובץ טקסט. זה מסד נתונים בינארי במבנה hive, המבנה שבו Windows שומרת גם את קובצי ה-Registry, ועורך טקסט ששומר אותו מחדש מקלקל את המבנה הזה.
ומה תפקיד הקובץ? מאז Vista הוא ממלא את מקומו של boot.ini: זה המאגר ש-Windows Boot Manager פותח בכל הפעלה כדי לדעת מה להציג ומה לטעון. לכן עובדים עליו רק בכלים ייעודיים, bcdedit בשורת הפקודה, או בהיקף מצומצם הלשונית Boot של msconfig וחלון System Properties.
איפה הטכנאי מצא את הקובץ? זה תלוי בקושחה:
- במחשב UEFI הקובץ נמצא במחיצת ה-ESP, תחת
\EFI\Microsoft\Boot\BCD. - במחשב BIOS הקובץ נמצא בתיקייה
\Bootשל מחיצת המערכת, כלומר\Boot\BCD. לרוב זו המחיצה הקטנה System Reserved, ובמחשב שאין בו מחיצה כזו, כונן C:.
יש גם שני מקומות שבהם אין טעם לחפש את המאגר. הוא לא שמור בזיכרון של הקושחה, כי זה קובץ רגיל בדיסק. והוא לא יושב במפתח ה-Registry HKLM\SYSTEM\CurrentControlSet, כי רשומות האתחול לא נכתבות לשם.
השאלה הבאה של הטכנאי תהיה: למה לוותר על קובץ טקסט שכל אחד יודע לערוך? הטבלה עונה:
| החולשה של boot.ini | מה BCD עושה במקום |
|---|---|
| שורת טקסט חופשית, שטעות הקלדה אחת משבשת | כל רשומה היא אובייקט עם אלמנטים מוגדרים |
| NTLDR ו-boot.ini לא ידעו לעבוד עם UEFI | אותו מאגר משרת מחשבי BIOS ומחשבי UEFI, ובמחשב UEFI אין אתחול של Windows בלעדיו |
| מיקום ההתקנה נקבע לפי מספר סידורי של דיסק ומחיצה | לכל רשומה GUID קבוע, ודיסקים מזוהים לפי חתימה או GUID |
| אין מקום לרכיבים חדשים | יש רשומות לחזרה מתרדמה, לכלי בדיקת הזיכרון, לטעינה מדיסק מדומה בזיכרון (RAMDISK) ועוד |
| עריכה בכל עורך טקסט, בלי שום בדיקה של מה שנכתב | שינויים בפקודות ייעודיות, שדורשות הרשאות מנהל |
מה שהמעבר לא שינה: אפשר עדיין להחזיק כמה מערכות הפעלה באותו תפריט, גם ב-Windows 11. ומה שהמעבר לא היה: לא החלפת שם של boot.ini, שהרי הפורמט שונה לגמרי, ולא תגובה למגבלה כלשהי של 32 סיביות.
טעויות נפוצות
- 'הקובץ מסומן כמוסתר, ולכן Notepad לא מצליח להציג אותו.' הסתרה היא רק תכונה של הקובץ. מה שמונע קריאה הוא התוכן: מסד נתונים בינארי במבנה hive, שאין בו שורות.
- 'התוכן נראה אקראי, אז כנראה הוא מוצפן, ובזכות זה BCD בטוח יותר.' אין בו שום הצפנה, כך שגם היתרון הזה לא קיים.
- 'חיפשתי את המאגר ולא מצאתי, אז הוא בטח שמור בזיכרון של לוח האם.' זה קובץ רגיל בדיסק:
\Boot\BCDבמחיצת המערכת של מחשב BIOS, או בתוך ה-ESP במחשב UEFI. - 'ב-XP הוספתי שורה ל-boot.ini בעורך טקסט, אז אעשה אותו דבר ב-BCD.' אין בו שורות, ושמירה מעורך טקסט עלולה להשחית אותו. בשביל זה יש bcdedit.
- 'בגרסאות החדשות ההגדרות עברו לקובץ אחר, אולי Bootmgr.ini, autoexec.bat או ntldr.' אין קובץ Bootmgr.ini, autoexec.bat שייך לימי DOS, ו-ntldr הוא הטוען של XP. ההגדרות נמצאות בקובץ BCD.
- 'boot.ini נעלם כי הוא לא הסתדר עם מעבדי 64 סיביות, וממילא אתחול כפול כבר לא קיים ב-Windows 11.' שתי הטענות שגויות. המעבר נבע ממבנה מסודר, תמיכה ב-UEFI, מזהים קבועים ורכיבים חדשים, ואתחול כפול עדיין קיים.
בדקו את עצמכם
חבר פתח את ה-BCD בפנקס רשימות, ראה תווים לא קריאים והסיק שהקובץ מוצפן. מה תענו לו?
שהקובץ אינו מוצפן אלא בינארי, במבנה hive כמו קובצי ה-Registry. לכן קוראים ועורכים אותו ב-bcdedit, ולא שומרים אותו מעורך טקסט.
במחשב UEFI, באיזה נתיב נמצא קובץ המאגר?
במחיצת ה-ESP, ב-\EFI\Microsoft\Boot\BCD.
אובייקטים, GUID וכינויים קבועים
מנהלת רשת כתבה בבוקר סקריפט שמשנה את השם של הרשומה Windows Lab, בעזרת bcdedit /set ומזהה בצורה {4ff8b239-7ece-44d9-b31b-1361b499c69b}. בצהריים מישהו שינה את סדר התפריט, וגם העביר את ההתקנה למחיצה אחרת. הסקריפט עדיין עובד, ופוגע בדיוק באותה רשומה.
הסיבה היא המזהה (Identifier). ה-BCD מורכב מאובייקטים (Objects), שנקראים גם רשומות (Entries), ולכל אחד מהם GUID: מספר באורך 128 סיביות, בתוך סוגריים מסולסלים, שנולד עם הרשומה ונשאר שלה עד שהיא נמחקת. bcdedit מאתר רשומה רק לפיו, ולא לפי השורה בתפריט או המחיצה שבה המערכת נמצאת.
כל רשומה מתארת רכיב אחד במערך האתחול. יש רשומה למנהל האתחול, רשומה לכל התקנה של Windows, רשומה לחזרה מתרדמה, רשומה לכלי בדיקת הזיכרון, וכשצריך גם רשומה לטוען הישן של XP.
ומה ה-GUID לא עושה? הוא לא נושא בתוכו מספר דיסק או מחיצה, שנשמרים באלמנטים device ו-osdevice; הוא לא קובע מי ייטען קודם; ואין בו שום הגנה מפני עריכה.
להקליד מספר ארוך כזה בכל פקודה זה מתכון לטעויות. לכן לרשומות הנפוצות יש שמות קבועים (Well-known identifiers), וכל אחד מהם מחליף את המספר:
| כינוי | על איזו רשומה הוא מצביע |
|---|---|
{bootmgr} | מנהל האתחול: התפריט, הבחירה שנטענת מעצמה וזמן ההמתנה |
{current} | המערכת שבה אתם נמצאים עכשיו, זו שממנה מריצים את הפקודה |
{default} | הרשומה שמסומנת כברירת המחדל של התפריט |
{ntldr} | טוען בסגנון הישן, שמוסר את השליטה ל-NTLDR של Windows XP |
{memdiag} | Windows Memory Diagnostic, כלי בדיקת הזיכרון |
בפלט הרגיל של bcdedit /enum מופיעים השמות האלה. מי שצריך את המספרים עצמם מוסיף את המתג /v.
{current} ו-{default} יכולים להצביע על אותה רשומה, אבל לא חייבים. אם עליתם הפעם למערכת שאינה ברירת המחדל, {current} הוא המערכת הזו.טעויות נפוצות
- 'הרשומה שה-GUID שלה נמוך יותר, או שהמחיצה שלה גדולה יותר, תיטען ראשונה.' ה-GUID הוא מזהה בלבד. את ברירת המחדל קובע default, ואת הסדר בתפריט displayorder.
- 'אם אפענח את ה-GUID, אדע באיזה דיסק ובאיזו מחיצה ההתקנה.' המספר אינו מקודד שום מיקום. המחיצה נשמרת בנפרד, באלמנטים device ו-osdevice.
- 'לרשומה יש GUID, אז אף אחד לא יוכל לשנות אותה.' כל מנהל מערכת יכול לשנות או למחוק אותה ב-bcdedit. ה-GUID רק אומר לפקודה באיזו רשומה מדובר.
בדקו את עצמכם
ההתקנה Windows Lab הועברה מ-C: ל-D:, ועדכנו בה את device ואת osdevice. האם ה-GUID שלה השתנה?
לא. ה-GUID נשאר קבוע כל חיי הרשומה, והמחיצה נשמרת באלמנטים, לא במזהה.
איזה מתג תוסיפו ל-bcdedit /enum כדי לראות את ה-GUID האמיתי שמאחורי {current}?
/v.
אלמנטים: ההגדרות שבתוך כל רשומה
רשומה היא בעצם אוסף של אלמנטים (Elements). כל אלמנט הוא זוג של שם וערך, וכל זוג הוא הגדרה אחת של הרשומה.
הפלט של bcdedit /enum בחלון מנהל בנוי מבלוקים. לכל רשומה יש כותרת לפי הסוג שלה, למשל Windows Boot Manager לרשומת {bootmgr} ו-Windows Boot Loader לכל התקנה של Windows, ומתחתיה שתי עמודות: שם האלמנט והערך שלו.
הטבלה הבאה מרכזת את האלמנטים שתראו ברשומת Windows Boot Loader, עם ערכים לדוגמה ממחשב BIOS שבו Windows מותקנת ב-C:.
| אלמנט | ערך לדוגמה | מה הוא קובע |
|---|---|---|
| description | Windows 11 Studio | הטקסט שהמשתמש רואה בשורה של הרשומה בתפריט |
| device | partition=C: | באיזו מחיצה נמצא קובץ הטעינה של הרשומה, למשל winload.exe |
| path | \Windows\system32\winload.exe | איפה בתוך אותה מחיצה נמצא קובץ הטעינה |
| osdevice | partition=C: | באיזו מחיצה נמצאת תיקיית Windows עצמה |
| systemroot | \Windows | שם התיקייה של Windows בתוך המחיצה של osdevice |
| resumeobject | GUID של רשומה אחרת | איזו רשומה משמשת לחזרה מתרדמה (winresume) |
| inherit | {bootloadersettings} | מאיזה אובייקט הרשומה מקבלת את כל מה שלא הוגדר בה במפורש |
ברשומת {bootmgr} יש אלמנטים שעוסקים בתפריט כולו, ולא בהתקנה אחת:
| אלמנט | ערך לדוגמה | מה הוא קובע |
|---|---|---|
| default | {current} | איזו רשומה נטענת כשאף אחד לא בוחר |
| displayorder | רשימה של GUID או כינויים | אילו רשומות מופיעות בתפריט, ובאיזה סדר |
| timeout | 30 | כמה שניות התפריט ממתין לפני שהוא טוען את ברירת המחדל |
| toolsdisplayorder | {memdiag} | אילו כלים מופיעים בחלק הכלים של התפריט |
| inherit | {globalsettings} | הגדרות כלליות שמנהל האתחול יורש |
קחו שתי רשומות Windows, A ו-B. בשתיהן כתוב inherit {bootloadersettings}, ובאובייקט הכללי {bootloadersettings} מוגדרות הגדרות שכל רשומות ה-Windows צריכות. A לא מגדירה אף אחת מהן בעצמה ולכן מקבלת את כולן מהאובייקט, ואילו B מגדירה ערך משלה לאחד האלמנטים, ובו הערך שלה הוא שקובע.
זה כל התפקיד של inherit: הוא חוסך לכתוב את אותן הגדרות בכל רשומה, כמו תבנית שממלאים בה רק את מה ששונה. אם הטעינה של A נכשלת, inherit לא מעביר ל-B או לעותק גיבוי של ה-BCD, וגם את ברירת המחדל הוא לא קובע, כי זה התפקיד של default.
שני זוגות של אלמנטים עושים את עיקר העבודה. device יחד עם path מובילים את מנהל האתחול לקובץ הטעינה (winload), ו-osdevice יחד עם systemroot מובילים את winload לתיקיית Windows שממנה הוא טוען את המערכת.
תרחיש 9: קוראים רשומה ומוצאים את Windows
ברשומה מסוימת כתוב osdevice partition=F: ו-systemroot \OS2. תיקיית Windows של הרשומה היא אפוא F:\OS2: האות מגיעה מ-osdevice, והתיקייה מ-systemroot.
אם באותה רשומה כתוב גם device partition=F: ו-path \OS2\system32\winload.exe, מנהל האתחול יטען את F:\OS2\system32\winload.exe.
כדי ששורת התפריט תציג Windows Lab במקום השם הנוכחי, משנים את description. אף אחד מהאלמנטים שמצביעים על מחיצות לא קשור לכיתוב.
טעויות נפוצות
- osdevice שומר את זמן ההמתנה של התפריט. זמן ההמתנה הוא timeout, ברשומת
{bootmgr}. osdevice הוא מחיצה. - osdevice הוא הכיתוב שמופיע בתפריט. את הכיתוב קובע description.
- osdevice מפרט אילו מנהלי התקן חתומים ייטענו. אין לו קשר למנהלי התקן. זו המחיצה שבה יושבת תיקיית Windows.
- inherit הוא רשומת חירום, שנטענת כשהרשומה הרגילה נכשלת. inherit רק משלים הגדרות חסרות מאובייקט אחר. אין בו טעינה חלופית, והוא גם לא מצביע על קובץ גיבוי.
- בעזרת inherit בוחרים את ברירת המחדל. ברירת המחדל נקבעת באלמנט default של
{bootmgr}.
בדקו את עצמכם
ברשומה כתוב osdevice partition=E: ו-systemroot \Win11. מה הנתיב של תיקיית Windows שלה?
E:\Win11.
רשומה C מפנה ב-inherit לאובייקט כללי, ואין לה ערך משלה לאלמנט מסוים שמוגדר באובייקט. מאיפה יגיע הערך של האלמנט, ומה ישתנה אם תגדירו אותו ב-C?
כרגע הוא יגיע מהאובייקט הכללי. אחרי שתגדירו אותו ב-C, הערך של C יגבר על הירושה.
אילו שני אלמנטים יחד מובילים את מנהל האתחול לקובץ winload?
device (המחיצה) ו-path (הנתיב בתוכה).
איך רשומה יודעת על איזה דיסק ומחיצה מדובר
שני מקרים מהשטח. ביום ראשון טכנאי העביר דיסק GPT עם Windows מהשקע SATA0 לשקע SATA3, וביום שני משתמשת שינתה את התווית של מחיצת Windows מ-SYSTEM ל-WORK. בשני המקרים המחשב עלה כרגיל, וההסבר נמצא במה שה-BCD בוחר לשמור.
בפלט של bcdedit רואים partition=C:, אבל זו רק הצגה ידידותית: ברגע שמנהל האתחול רץ, לאף מחיצה אין עדיין אות. מה שנשמר באמת הוא מזהה שצרוב בדיסק עצמו:
| סגנון הדיסק | מה מזהה את הדיסק | מה מזהה את המחיצה |
|---|---|---|
| MBR | חתימת הדיסק (Disk Signature), מספר שכתוב ב-MBR | המיקום של המחיצה בתוך הדיסק |
| GPT | ה-GUID של הדיסק | ה-GUID של המחיצה |
השקע בלוח האם לא מופיע באף שורה בטבלה, ולכן המעבר מ-SATA0 ל-SATA3 לא שינה דבר. גם תווית הנפח (Volume label) לא שם: אותה אפשר לשנות בכל רגע, כמו שקרה ביום שני, ושום דבר לא מונע משתי מחיצות להיקרא באותו שם, כך שמזהה כזה לא היה אמין. וגם הנפח של הדיסק לא משמש לזיהוי.
המקרה של יום ראשון היה יכול להיגמר אחרת עם boot.ini. נתיב ARC מתאר דיסק לפי מספר סידורי, ומספר כזה עלול להצביע על דיסק אחר כשסדר הדיסקים משתנה.
טעויות נפוצות
- הרשומה מוצאת את המחיצה לפי השם שנתתם לה, למשל DATA. תווית אפשר לשנות, והיא יכולה לחזור על עצמה, ולכן היא לא מזהה אמין.
- הרשומה זוכרת לאיזה שקע בלוח האם הדיסק מחובר. אילו כך היה, כל העברה לשקע אחר הייתה שוברת את האתחול. נשמרים חתימה או GUID של הדיסק עצמו.
- 'יש לי דיסק של 500GB ודיסק של 1TB, וכך ה-BCD יודע להבדיל ביניהם.' נפח אינו חלק מהזיהוי. אילו היה, שני דיסקים זהים היו מתבלבלים, ולכן נשמרים חתימה או GUID.
בדקו את עצמכם
דיסק MBR עם Windows עבר מהשקע הראשון של הבקר לשקע הרביעי. האם הרשומה ב-BCD עדיין תמצא את המחיצה?
כן. ב-MBR הדיסק מזוהה לפי חתימת הדיסק והמחיצה לפי מיקומה בדיסק, ושום דבר מאלה לא תלוי בשקע.
למה אות הכונן שמופיעה בפלט של bcdedit אינה מה שבאמת נשמר במאגר?
כי בזמן האתחול עוד אין אותיות כונן. האות היא רק הצגה נוחה של המזהה הייחודי.
RAMDISK OPTIONS: כשהמערכת עולה מתוך קובץ
מאתחלים מחשב מדיסק און קי של התקנת Windows. על הדיסק און קי אין Windows מותקנת, יש רק קובץ תמונה גדול בשם sources\boot.wim, ובכל זאת אחרי כמה שניות עולה סביבה גרפית שמציעה להתקין או לתקן.
הסביבה הזו היא WinPE (Windows Preinstallation Environment), Windows מוקטנת שקיימת בשביל התקנה ושחזור, ו-WinRE נבנתה על בסיסה. היא ארוזה בקובץ WIM, כמו boot.wim כאן או winre.wim של סביבת השחזור, ולא מותקנת על מחיצה.
רשומת הטעינה שלה ב-BCD מגלה איך זה עובד. ב-device וב-osdevice שלה כתוב ערך בצורה ramdisk=[D:]\sources\boot.wim,{ramdiskoptions}: לפני הפסיק קובץ ה-WIM, ואחריו הפניה לאובייקט נוסף.
האובייקט הזה, RAMDISK OPTIONS (בכינוי {ramdiskoptions}), מתאר דיסק מדומה (RAM disk) שמנהל האתחול בונה בזיכרון, ומציין את קובץ ה-SDI שעליו הדיסק נבנה, ברוב המקרים \boot\boot.sdi. לתוך הדיסק הזה מנהל האתחול פורש את תמונת ה-WIM, ואז מאתחל ממנו כאילו היה מחיצה רגילה.
טעויות נפוצות
- RAMDISK OPTIONS מגביל את כמות ה-RAM שהמערכת הרגילה רואה. הוא מגדיר את הדיסק המדומה של WinPE, ולא את הזיכרון של ההתקנה הרגילה.
- 'בזמן ש-WinPE עולה היא צריכה מקום להחלפת דפי זיכרון, ובשביל זה קיים RAMDISK OPTIONS.' קובץ ההחלפה (Page File) שייך ל-Windows שכבר רצה, ואין לו מקום בהגדרות האתחול. RAMDISK OPTIONS מתאר את הדיסק המדומה.
- זו הגדרה של טעינת הליבה מהרשת. טעינה ברשת (PXE) היא נושא אחר. RAMDISK OPTIONS מתאר שטח בזיכרון שמתפקד כמחיצה מדומה, ולא את הדרך שבה הקבצים מגיעים.
בדקו את עצמכם
בדיסק און קי של התקנת Windows יש sources\boot.wim, ואין מחיצה מותקנת. איך מנהל האתחול מעלה ממנו מערכת?
הוא בונה בזיכרון דיסק מדומה לפי RAMDISK OPTIONS (עם קובץ ה-SDI), פורש לתוכו את התמונה מקובץ ה-WIM, ומאתחל ממנו כמו ממחיצה.
באיזה כינוי מפנים לאובייקט שמתאר את הדיסק המדומה?
{ramdiskoptions}.
BCDEdit: ניהול ה-BCD משורת הפקודה
מה bcdedit עושה, ומה לא
נתחיל מהרצה אמיתית. מחלון cmd רגיל, בלי הרשאות מנהל, מבקשים לראות את רשומות האתחול:
bcdedit /enumThe boot configuration data store could not be opened.
Access is denied.הכישלון מלמד את הכלל הראשון: bcdedit עובד רק מחלון שנפתח באפשרות Run as administrator, ואין לו גרסה גרפית. זה הכלי שבא במקום הפתיחה הידנית של boot.ini, בכל מחשב עם Vista ומעלה, בין שהקושחה שלו BIOS ובין שהיא UEFI.
בחלון מנהל אפשר לעבוד. הנה סשן שלם של שינוי זהיר:
rem full snapshot of the store before touching it
bcdedit /export D:\Safe\bcd-2026-11
bcdedit /set {current} description "Windows 11 Studio"
rem roll everything back if the change went wrong
bcdedit /import D:\Safe\bcd-2026-11
rem list a BCD file that lives on another disk
bcdedit /store G:\Boot\BCD /enum allבשורה הראשונה /export צילם את המאגר כולו לקובץ, בפורמט בינארי ולא XML. אחריו /set שינה ערך אחד, description, ברשומה אחת. ואז /import דרס את המאגר הנוכחי בצילום, כך שגם השינוי בוטל.
בשורה האחרונה /store הפנה את /enum all לקובץ BCD של דיסק אחר. לבד הוא לא מבצע שום פעולה: הוא רק בוחר על איזה קובץ תפעל הפקודה שלצידו, וכך אפשר לבדוק דיסק אחר, או להכין קובץ BCD לפני שמעבירים אותו למחשב.
הסשן מראה גם את היתרון על boot.ini: כל שינוי מכוון לרשומה ולאלמנט בעלי שם, ולא לשורה בקובץ שאפשר להקליד בה כל דבר. מנגד, bcdedit לא פועל מיוזמתו. הוא איננו חלק מהליבה, לא רץ בזמן האתחול ולא מתקן רשומה פגומה בלי שביקשתם.
| פקודה | מה היא עושה |
|---|---|
bcdedit /enum | מציגה רשומות ואת האלמנטים שלהן. /enum all מציגה את כל הרשומות, ו-/v מחליף כינויים ב-GUID מלאים |
bcdedit /set {id} element value | קובעת ערך חדש לאלמנט אחד ברשומה אחת |
bcdedit /deletevalue {id} element | מסירה אלמנט אחד מרשומה |
bcdedit /create | יוצרת רשומה חדשה |
bcdedit /copy {id} /d "name" | משכפלת רשומה קיימת לרשומה חדשה, עם GUID חדש ותיאור חדש |
bcdedit /delete {id} | מסירה רשומה שלמה מהמאגר |
bcdedit /export file | כותבת לקובץ עותק גיבוי של המאגר כולו, בפורמט בינארי ולא XML |
bcdedit /import file | טוענת את המאגר מקובץ גיבוי, ודורסת את מה שיש בו עכשיו |
bcdedit /store file ... | מפנה את הפקודה לקובץ BCD אחר, במקום המאגר שהמחשב מאתחל ממנו |
פקודה אחת בטבלה דורשת זהירות מיוחדת. אחרי /delete הרשומה איננה, ולא רק מושבתת, ואם זו הייתה הרשומה של מערכת שעוד צריך, השורה שלה תיעלם מהתפריט. מכאן ההרגל להריץ /export לפני כל מחיקה.
טעויות נפוצות
- 'כדי לראות מה יש במאגר אריץ
/set.'/setמשנה ערך. ההצגה היא/enum, המחיקה/deleteוהגיבוי/export. - '
/exportו-/importהם הכלים שמעבירים הגדרות מ-boot.ini אל BCD.' הם מגבים ומשחזרים את מאגר ה-BCD כולו, ואין בהם שום המרה. - 'כדי לתקן שגיאת כתיב בשם של רשומה אחת, אייבא קובץ BCD מתוקן.' ערך בודד, כמו description, משנים ב-
/set./importמחליף את כל המאגר. - '
/exportמצפין את boot.ini ושומר אותו בתיקיית Windows.' boot.ini מעולם לא ישב בתיקיית Windows, ו-/exportלא מצפין: הוא כותב עותק בינארי של ה-BCD. - '
/storeהיא עוד דרך לגבות או לשחזר.'/storeרק אומר לפקודה על איזה קובץ BCD לעבוד. - 'אחרי
/deleteאפשר פשוט להפעיל את הרשומה שוב', או לחלופין 'הפקודה מוחקת את כל הקובץ'. נמחקת בפועל הרשומה שציינתם, והיא בלבד. כדי להחזיר אותה צריך גיבוי. - 'יש לו חלון גרפי, ואפשר להריץ אותו גם על XP.' זה כלי שורת פקודה בלבד, והוא קיים רק מ-Vista.
- 'אם רשומה נשברה, bcdedit יבחין בזה בהפעלה הבאה ויתקן אותה לבד.' הוא לא רץ באתחול ולא מתקן כלום מעצמו. מריצים אותו ידנית, והוא עושה רק את מה שמבקשים.
- 'במחשב BIOS אין BCD, ולכן שם bcdedit לא רלוונטי.' Windows מודרנית משתמשת ב-BCD בשני סוגי הקושחה, ו-bcdedit עובד בשניהם.
בדקו את עצמכם
אתם עומדים לשנות כמה רשומות ורוצים דרך לחזור בדיוק למצב הנוכחי. מה מריצים לפני השינוי, ומה אם צריך לחזור?
לפני: bcdedit /export לקובץ גיבוי. כדי לחזור: bcdedit /import מאותו קובץ.
חיברתם דיסק של מחשב אחר בתור H: ורוצים לראות את הרשומות שב-BCD שלו, בלי לגעת במאגר של המחשב שלכם. איזה מתג מאפשר זאת?
/store עם הנתיב לקובץ ה-BCD שעל הדיסק הזה, יחד עם /enum.
להוסיף אפשרות לתפריט
נניח שהתקנתם Windows נוספת ורוצים שתופיע בתפריט. אלה שלושה ניסיונות ראשונים שטכנאים עושים, ולמה אף אחד מהם לא מוסיף שורה:
- להעתיק את תיקיית Windows לכונן אחר: Windows Boot Manager לא סורק כוננים ולא מחפש התקנות, ולכן העותק פשוט לא קיים מבחינתו.
- לסמן את המחיצה החדשה כפעילה: זה משנה רק מאיזו מחיצה הקושחה מתחילה, ולא נוגע בתוכן התפריט.
- להוסיף פריט בלשונית Startup של msconfig: הלשונית הזו עוסקת בתוכנות שרצות אחרי הכניסה של משתמש, לא באתחול.
המסקנה מהכישלונות: התפריט הוא בדיוק רשימת הרשומות שב-BCD, ולא יותר. כדי להוסיף שורה צריך רשומה שבה מוגדרות המחיצה והנתיבים, ו-bcdedit נותן שתי דרכים לבנות אותה:
| מה משווים | bcdedit /copy | bcdedit /create |
|---|---|---|
| נקודת ההתחלה | עותק של רשומה קיימת, עם כל האלמנטים שלה | רשומה ריקה |
| מה נשאר להגדיר | רק מה ששונה, בדרך כלל המחיצה | הכול: device, osdevice, path, systemroot |
| מקום בתפריט | מצטרפת לסוף התפריט מעצמה | מוסיפים אותה בעצמכם, עם /displayorder ו-/addlast |
| מה מודפס | ה-GUID של הרשומה החדשה | ה-GUID של הרשומה החדשה |
את ה-GUID שהפקודה מדפיסה מעתיקים לפקודות ההמשך, כי דרכו פונים לרשומה החדשה.
תרחיש 11: התקנה שנייה של Windows בכונן E
במחשב יש Windows 11 אחת ב-C:. התקינו עותק נוסף בכונן E:, ורוצים שיופיע בתפריט כאפשרות נוספת, בלי לשנות מה עולה כברירת מחדל.
rem clone the running entry under a new name
bcdedit /copy {current} /d "Windows 11 on E"
rem the command prints the new GUID; use it below
bcdedit /set {f40f9548-1dc2-475a-9eaa-20244ce7e60b} device partition=E:
bcdedit /set {f40f9548-1dc2-475a-9eaa-20244ce7e60b} osdevice partition=E:הפקודה הראשונה מודיעה שהעותק נוצר ומדפיסה את ה-GUID שלו בסוגריים מסולסלים, וזה ה-GUID שבשתי השורות הבאות. העותק כבר מכיל את path (\Windows\system32\winload.exe) ואת systemroot (\Windows), ולכן מספיק להחליף בו את המחיצה. הוא נוסף לסוף התפריט, וברירת המחדל לא זזה.
אילו בחרו ב-/create, הרשימה הייתה ארוכה יותר:
bcdedit /create /d "Windows 11 on E" /application osloader
bcdedit /set {NEW-GUID} device partition=E:
bcdedit /set {NEW-GUID} osdevice partition=E:
bcdedit /set {NEW-GUID} path \Windows\system32\winload.exe
bcdedit /set {NEW-GUID} systemroot \Windows
bcdedit /displayorder {NEW-GUID} /addlastהטעות הנפוצה היא לוותר על רשומה חדשה ולשנות device ו-osdevice ישירות ב-{current}. כך לא נוספת שום אפשרות: הרשומה היחידה פשוט מצביעה מעכשיו על E:, והמערכת שעולה מתחלפת.
תרחיש 12: אפשרות קבועה של Safe Mode לצד הרגילה
רוצים שבתפריט יהיו שתי שורות: Windows 11 הרגילה, ולצידה שורה שתמיד מעלה מצב בטוח.
bcdedit /copy {current} /d "Windows 11 Safe Mode"
bcdedit /set {GUID-OF-NEW-ENTRY} safeboot minimalהעותק יורש את כל ההגדרות של הרשומה הרגילה, ומקבל רק תוספת אחת: safeboot. מי שצריך רשת גם במצב הבטוח כותב network במקום minimal.
שלושה ניסיונות שנראים סבירים ולא משיגים את המטרה:
- להגדיר
safeboot minimalב-{bootmgr}: האלמנט שייך לרשומה של מערכת הפעלה, ומנהל האתחול איננו מערכת הפעלה. - ליצור ב-
/createרשומה ריקה ולתת לה רק safeboot: בלי device, osdevice ו-path אין לה מה לטעון. - לשנות את השם של
{current}ולהוסיף לה safeboot: מקבלים רשומה יחידה שעולה תמיד במצב בטוח, ואין יותר אפשרות רגילה.
תרחיש 13: Windows XP ישנה בתפריט של Windows 10
במחשב BIOS מותקנת Windows 10 ב-C:, ובמחיצה F: נשארה Windows XP. מנהל האתחול של Windows 10 לא יודע עליה, כי אין לה רשומה ב-BCD.
הפתרון הוא רשומה מהסוג הישן, {ntldr}, שתפקידה למסור את השליטה ל-NTLDR:
bcdedit /create {ntldr} /d "Windows XP Legacy"
bcdedit /set {ntldr} device partition=F:
bcdedit /set {ntldr} path \ntldr
bcdedit /displayorder {ntldr} /addlastמה קורה כשבוחרים את Windows XP Legacy? bootmgr מוסר את השליטה לטוען הישן, ומכאן הכול מתנהג כמו ב-XP: NTLDR קורא את boot.ini ומעלה את המערכת. לכן device חייב להצביע על F:, כי שם, בשורש המחיצה, נמצאים הקבצים NTLDR ו-boot.ini.
שני קיצורים נכשלים כאן. מתוך XP אי אפשר לעשות את זה, כי ל-XP אין לא bcdedit ולא bcdboot; ולהפוך את F: למחיצה הפעילה רק ישנה מאיפה הקושחה מתחילה, בלי לגעת ברשימת הרשומות.
טעויות נפוצות
- 'אפתח את ה-BCD בפנקס רשימות ואקליד בו שורה חדשה.' ה-BCD בינארי. רשומות מוסיפים ב-
/copyאו ב-/create. - 'ארשום ב-Registry, תחת CurrentControlSet, מפתח שמצביע על הכונן השני.' רשומות התפריט לא נמצאות ב-Registry של Windows, אלא ב-BCD.
- 'מספיק שהעותק של Windows נמצא על הכונן, ומנהל האתחול כבר ימצא אותו.' הוא לא סורק כוננים. בלי רשומה אין שורה בתפריט.
- 'אם הקושחה תתחיל מהמחיצה של ההתקנה החדשה, שתי המערכות יופיעו בתפריט.' המחיצה שהקושחה מתחילה ממנה לא יוצרת רשומות. התפריט מציג רק את מה שיש ב-BCD.
- 'אוסיף פריט ב-msconfig, בלשונית של התוכנות שעולות עם Windows.' הלשונית Startup מטפלת בתוכנות שעולות אחרי הכניסה של משתמש, לא ברשומות אתחול.
- 'אכנס ל-XP, ומשם ארשום אותה בתפריט של Windows 10.' ב-XP אין bcdedit ואין bcdboot. את הרשומה יוצרים מתוך Windows 10.
בדקו את עצמכם
למה רוב הטכנאים מעדיפים /copy על /create כשמוסיפים התקנה נוספת של Windows?
העותק כבר נושא את path, systemroot ושאר ההגדרות, והוא מצטרף לתפריט מעצמו. נשאר רק להחליף את המחיצה.
בעותק של רשומה הגדרתם safeboot network. מה יקרה כשתבחרו בתפריט את הרשומה המקורית?
היא תעלה כרגיל. safeboot הוגדר רק בעותק, והמקורית לא השתנתה.
Safe Mode בשתי השיטות: boot.ini מול BCD
תרגיל השוואה: אותו טכנאי צריך להעלות מצב בטוח פעם אחת במחשב XP ופעם אחת במחשב Windows 10. הנה מה שהוא עושה בכל מחשב, ומה הוא מקבל:
| היבט | Windows 10 ומעלה, BCD | Windows XP, boot.ini |
|---|---|---|
| הפעולה | bcdedit /set {current} safeboot minimal, שכותבת ערך במאגר | הוספת המתג /safeboot:minimal לשורת המערכת בקובץ |
| צורת השמירה | אלמנט ברשומה של מאגר בינארי | טקסט בקובץ |
| מתי השינוי מורגש | בהפעלה הבאה | בהפעלה הבאה |
| עד מתי הוא נשאר | עד שמסירים את האלמנט | עד שמסירים את המתג |
| הרשאות נדרשות | מנהל | מנהל |
שלוש מתוך חמש השורות זהות בשני הטורים, ומה ששונה הוא רק הצורה: מתג בשורת טקסט מול אלמנט במאגר. לכן גם ב-BCD המצב הבטוח לא מתחיל באמצע העבודה, וגם לא נגמר מעצמו אחרי הפעלה אחת. כדי לחזור לאתחול רגיל מוחקים את האלמנט:
bcdedit /deletevalue {current} safebootב-Windows 10 יש גם דרך גרפית לאותה תוצאה. בלשונית Boot של msconfig מסמנים Safe boot, והחלון כותב את אותו אלמנט ל-BCD.
טעויות נפוצות
- 'ב-BCD ההגדרה מוחקת את עצמה אחרי הפעלה אחת.' היא נשארת עד
/deletevalue. מי שרוצה הפעלה חד-פעמית של רשומה אחרת משתמש ב-/bootsequence. - 'ברגע שהרצתי את הפקודה, Windows עוברת למצב בטוח.' שום דבר לא קורה עד ההפעלה הבאה, בדיוק כמו בעריכה של boot.ini.
- 'בניגוד ל-boot.ini, ל-bcdedit לא צריך הרשאות מנהל.' שתי השיטות דורשות הרשאות מנהל.
בדקו את עצמכם
הגדרתם safeboot network ב-{current} והפעלתם מחדש שלוש פעמים. באיזה מצב עלתה המערכת בפעם השלישית, ומה יחזיר אותה לרגיל?
שוב במצב בטוח עם רשת. רק הסרת האלמנט, ב-bcdedit /deletevalue {current} safeboot או בביטול הסימון ב-msconfig, תחזיר אתחול רגיל.
ניפוי שגיאות, EMS ויומן אתחול
דמיינו מנהל התקן חדש שמפיל את המערכת למסך כחול עוד לפני שמסך הכניסה מופיע. אין Windows פעילה שאפשר לחקור מתוכה, ולכן ה-BCD מציע כמה מצבי אבחון, כל אחד לסוג אחר של בעיה:
| מה צריך | ההגדרה | איפה מגדירים |
|---|---|---|
| לעקוב אחרי הליבה ממחשב שני | ניפוי ליבה (Kernel debugging): /debug או האלמנט debug | ברשומה של מערכת ההפעלה |
| לעקוב אחרי מנהל האתחול או הטוען עצמם | /bootdebug | ברשומה של רכיב האתחול |
| לנהל מרחוק שרת בלי מסך | EMS: /ems או /bootems | במערכת ההפעלה או במנהל האתחול |
| לקבל רשימה של מנהלי ההתקן שנטענו, בלי ציוד נוסף | bootlog | ברשומה של מערכת ההפעלה |
למנהל ההתקן שמפיל את המערכת מתאים ניפוי ליבה. במחשב הבעייתי מדליקים debug ברשומה שלו ומגדירים את החיבור, ואז מחשב שני עם WinDbg, שמחובר בכבל טורי, ברשת או ב-USB, רואה את הליבה כבר מרגע הטעינה:
rem two equivalent ways to turn kernel debugging on for one OS entry
bcdedit /debug {0668fd76-a6be-4642-96a1-40bac1e8a15b} on
bcdedit /set {0668fd76-a6be-4642-96a1-40bac1e8a15b} debug on
rem how the second computer connects
bcdedit /dbgsettings serial debugport:2 baudrate:57600שתי הפקודות שמדליקות שקולות: האחת היא פקודת /debug הייעודית, והשנייה משיגה אותו דבר דרך /set והאלמנט debug. במקום ה-GUID אפשר כמובן לכתוב {current}, ו-off במקום on מכבה את הניפוי. /dbgsettings לא מדליקה דבר, היא רק קובעת את דרך החיבור.
אילו הנפילה הייתה מוקדמת יותר, בזמן שמנהל האתחול או winload עוד עובדים, ניפוי הליבה לא היה עוזר. בשביל השלב הזה יש /bootdebug, שפותחת לניפוי את רכיבי האתחול ולא את הליבה.
תרחיש אחר: שרת בחדר מחשבים, בלי מסך, שהרשת שלו לא עולה. EMS (Emergency Management Services) פותח אליו ערוץ ניהול דרך חיבור טורי, ושלוש פקודות מגדירות אותו:
| פקודה | על מה היא פועלת |
|---|---|
bcdedit /emssettings EMSPORT:2 EMSBAUDRATE:57600 | רק על הגדרות החיבור: פורט ומהירות. אין בה מזהה רשומה ואין on |
/bootems על הרשומה {bootmgr}, עם הערך on | על מנהל האתחול, ולא על מערכת ההפעלה |
/ems על הרשומה {current}, עם הערך on | על מערכת ההפעלה של הרשומה הנוכחית, בפקודה ייעודית בלי /set |
ואם אין מחשב שני בכלל? מספיק bcdedit /set {current} bootlog yes. בהפעלה הבאה Windows כותבת לקובץ ntbtlog.txt שבתיקייה %SystemRoot% את רשימת מנהלי ההתקן שנטענו, וההגדרה הזו עומדת לגמרי בפני עצמה, בלי קשר לניפוי.
טעויות נפוצות
- 'הפעלתי
/debug, ועכשיו אחפש בתיקיית Windows קובץ עם השגיאות.'/debugלא כותבת שום קובץ. היא פותחת את הליבה לחיבור של מנפה שגיאות חיצוני, והיומןntbtlog.txtהוא של bootlog. - '
/debugהיא דרך לשמור את ה-BCD כקובץ XML.' גיבוי הוא/export, והקובץ שלו בינארי. - 'מאז שהפעלתי
/debugהמחשב לא נרדם, כנראה היא חוסמת את מצב השינה.' ל-/debugאין שום קשר לניהול צריכת חשמל. - כדי לנפות את הליבה מגדירים kerneldebug ברשומת
{bootmgr}.{bootmgr}הוא מנהל האתחול ולא הליבה. מדליקים debug ברשומה של מערכת ההפעלה. - 'הפעלתי
/bootemsעל{bootmgr}, אז יש עכשיו EMS גם ל-Windows שעולה.' היא חלה על מנהל האתחול בלבד. למערכת ההפעלה משתמשים ב-/ems. - אפשר לתת ל-
/emssettingsמזהה רשומה ו-on./emssettingsמקבלת רק פורט ומהירות. /bootdebugהיא חלק מ-EMS. היא מפעילה ניפוי של שלב האתחול, ואין לה קשר לניהול מרחוק.
בדקו את עצמכם
מנהל רשת רוצה רשימה של מנהלי ההתקן שנטענו בהפעלה האחרונה, ואין לו מחשב שני לחבר. מה הוא מפעיל, ואיפה ימצא את התוצאה?
את bootlog ברשומה של המערכת. הרשימה תיכתב ל-ntbtlog.txt בתיקייה %SystemRoot%.
רוצים EMS גם בשלב של מנהל האתחול וגם במערכת עצמה. אילו שתי פקודות מריצים?
למנהל האתחול: /bootems על {bootmgr} עם on. למערכת ההפעלה: /ems על {current} עם on.
תקלות אתחול: איפה מתקנים ובמה
למה צריך סביבה נפרדת: WinRE
המחשב של נועה מציג שגיאת אתחול. הדבר הראשון שהיא מנסה הוא לעלות במצב בטוח, וזה נעצר באותה נקודה בדיוק.
זה צפוי. מצב בטוח הוא עדיין אותה Windows, שעוברת דרך אותו מנהל אתחול ואותו BCD; כשהקלקול נמצא ב-MBR, במגזר האתחול או ב-BCD, השרשרת נקטעת לפני השלב שבו מצב בטוח משנה משהו. מאותה סיבה גם אין מערכת רגילה שאפשר להיכנס אליה ולתקן ממנה.
נועה צריכה מערכת אחרת לגמרי שתעלה במקום: סביבת השחזור Windows RE (Windows Recovery Environment), או דיסק און קי או תקליטור של התקנת Windows, שבהם בוחרים Repair your computer. לעיתים קרובות WinRE מופיעה לבד, אחרי כמה כישלונות אתחול רצופים.
ב-WinRE מחכים לה שני דברים: אשף תיקון אוטומטי בשם Startup Repair, וגם שורת פקודה (Command Prompt) שבה זמינים הכלים האלה:
| כלי | מה הוא עושה כאן |
|---|---|
| bcdedit | עורך את ה-BCD |
| bootrec | מתקן את ה-MBR, את מגזר האתחול ואת ה-BCD |
| bcdboot | מעתיק קובצי אתחול ובונה BCD חדש |
| chkdsk | בודק ומתקן את מערכת הקבצים, ורק אותה. ברשומות האתחול הוא לא נוגע |
בדרך לשם נועה תיכנס כנראה להגדרות הקושחה, כדי שהמחשב יעלה מהדיסק און קי. זה כל מה ששינוי של Boot Order עושה, בוחר התקן; ה-MBR וה-BCD נשארים בדיוק כמו שהיו.
dir על כמה אותיות ולמצוא את תיקיית Windows.טעויות נפוצות
- 'אעלה למצב בטוח עם תמיכה ברשת, ומשם אתקן את ה-BCD.' גם מצב בטוח צריך BCD תקין כדי לעלות בכלל.
- 'אשנה ב-BIOS או ב-UEFI את סדר האתחול, וה-MBR יסתדר.' סדר האתחול רק בוחר התקן. הוא לא כותב כלום לא לסקטור הראשון ולא למאגר האתחול.
- 'אדליק את המחשב כרגיל ואתקן את הקבצים ביד.' המערכת לא מגיעה לשלב שבו אפשר לעבוד בה.
בדקו את עצמכם
אחרי שינוי במחיצות המחשב נעצר עוד לפני ש-Windows עולה, עם הודעה על ה-BCD. מאיפה תריצו את כלי התיקון?
מ-WinRE, או מדיסק התקנה של Windows דרך Repair your computer. לא ממצב בטוח ולא מאתחול רגיל.
פתחתם Command Prompt ב-WinRE, והפקודה dir C:\Windows לא מוצאת כלום. מה הצעד הבא?
לבדוק עם dir אותיות אחרות, למשל D:, כי בסביבת השחזור לכונן של Windows יכולה להיות אות אחרת.
bootrec ו-bcdboot
bootrec הוא הכלי שמתקן את שרשרת האתחול עצמה, ומריצים אותו מתוך WinRE. כל מתג שלו מטפל בחוליה אחרת:
| פקודה | החוליה שהיא מטפלת בה |
|---|---|
bootrec /fixmbr | קוד ה-MBR בסקטור הראשון של הדיסק: נכתב קוד תקין, וטבלת המחיצות לא משתנה |
bootrec /fixboot | מגזר האתחול של מחיצת המערכת, שנכתב מחדש |
bootrec /scanos | חיפוש בדיסקים של התקנות Windows שאין להן רשומה ב-BCD, והצגה שלהן |
bootrec /rebuildbcd | חיפוש של התקנות Windows בכל הדיסקים והצעה להוסיף כל אחת ל-BCD, וכך רשומות האתחול נבנות מחדש |
bcdboot פועל אחרת. כדי להבין מאיפה הוא לוקח את החומר, נסתכל בתיקייה Boot שבתוך תיקיית Windows של מחשב Windows 10:
dir /b %SystemRoot%\BootBootDebuggerFiles.ini
DVD
DVD_EX
EFI
EFI_EX
Fonts
Fonts_EX
Misc
PCAT
Resourcesזה המלאי ש-bcdboot עובד ממנו: PCAT לאתחול במחשבי BIOS, EFI לאתחול במחשבי UEFI. כשמריצים אותו עם נתיב של תיקיית Windows, הוא שולף מ-%SystemRoot%\Boot של אותה התקנה את bootmgr או את bootmgfw.efi ואת הקבצים שנלווים אליהם, ומניח אותם במחיצת המערכת. בסוף הוא בונה שם BCD חדש, ובו רשומה פשוטה שמצביעה על אותה Windows.
הנה סשן שחזור אחד. מחיצת ה-ESP נמחקה בטעות ונוצרה מחדש ריקה בתור T:, ו-Windows נראית ב-WinRE בכונן D:
rem the simplest form: only the source Windows folder
bcdboot D:\Windows
rem name the target system partition and the firmware type
bcdboot D:\Windows /s T: /f UEFI
rem the same, with an English boot menu
bcdboot D:\Windows /s T: /f UEFI /l en-usבשורות האלה רואים את שלושת המתגים החשובים: /s מציין לאיזו מחיצה הקבצים הולכים, /f אומר לאיזה סוג קושחה להכין אותם, ו-/l קובע באיזו שפה יופיע התפריט.
אותה פקודה משמשת גם בלי שום תקלה: מי שפורס תמונת Windows על דיסק חדש מריץ bcdboot כדי להכין לה מחיצת מערכת שאפשר לאתחל ממנה.
מה bcdboot משאיר בשקט? הוא לא מפרמט, לא מנקה קבצים ישנים, לא מוסיף מנהלי התקן ולא נוגע ברישיון. כל העבודה שלו היא קובצי האתחול וה-BCD.
ואם מישהו מציע פשוט להיפטר מהמאגר הפגום ולחכות? אחרי מחיקה כזו מנהל האתחול לא מוצא מאגר בכלל, ואף רכיב לא בונה אותו מחדש בהפעלה הבאה. המחשב רק עובר מתקלה אחת לתקלה אחרת.
טעויות נפוצות
- 'Windows שומרת עותק נסתר של הגדרות האתחול, אז אחרי שאסיר את המאגר הפגום הוא ישוחזר לבד.' אין מנגנון כזה. בלי BCD אין אתחול, ובונים אותו מחדש עם bootrec או bcdboot.
- 'אתקן את ה-BCD דרך boot.ini, או דרך msconfig.' boot.ini לא משתתף באתחול של Windows מודרנית, ו-msconfig דורש מערכת שעולה.
- 'chkdsk עם
/fמתקן כל דבר בדיסק, כולל את ה-BCD.' chkdsk מתקן שגיאות במערכת הקבצים. רשומות אתחול אינן בתחום שלו. - 'sfc מתקן קבצי מערכת, ולכן גם את רשומות האתחול.' sfc בודק את קבצי המערכת המוגנים של Windows. רשומות ב-BCD אינן חלק מהבדיקה שלו.
- 'bcdboot מכין את הדיסק מאפס: מפרמט, מתקין מנהלי התקן ומפעיל את Windows.' הוא רק מעתיק קובצי אתחול ויוצר BCD.
בדקו את עצמכם
Windows מותקנת ותקינה ב-C:\Windows, אבל השורה שלה נעלמה מהתפריט. איזו פקודת bootrec תאתר אותה ותציע להחזיר אותה ל-BCD?
bootrec /rebuildbcd. מי שרוצה רק לראות מה נמצא, בלי להוסיף, מריץ bootrec /scanos.
מחיצת ה-ESP נמחקה ונוצרה מחדש ריקה, בתור S:. איזו פקודה תכניס אליה קובצי אתחול ו-BCD?
bcdboot C:\Windows /s S: /f UEFI, עם האות של תיקיית Windows כפי שהיא מופיעה באותה סביבה.
לקרוא הודעת שגיאה של אתחול
סדרו את השרשרת לפי הזמן: קושחה, MBR ומגזר אתחול, bootmgr שקורא את ה-BCD, winload שטוען את ה-Registry ואת הליבה, ורק בסוף כניסה של משתמש ופרופיל. כל הודעת שגיאה נולדת באחת החוליות, והשם שמופיע בה, של רכיב או של קובץ, מגלה באיזו. ושום דבר שקורה אחרי אותה חוליה לא יכול היה לגרום להודעה.
| ההודעה | מי נכשל ובמה | דרך התיקון |
|---|---|---|
NTLDR is missing | הטוען של XP, NTLDR, לא נמצא | Recovery Console של XP |
BOOTMGR is missing | הקובץ bootmgr, מנהל האתחול של Vista והלאה במחשב BIOS, חסר | מתוך WinRE או דיסק ההתקנה: Startup Repair, bootrec או bcdboot |
File: \Boot\BCD עם Status: 0xc000000f | מנהל האתחול כבר רץ, אבל לא מוצא את מאגר ה-BCD או לא מצליח לקרוא אותו | מתוך WinRE: bootrec /rebuildbcd או bcdboot |
מכאן ש-BOOTMGR is missing מגיעה מהשלב שבו מחפשים את bootmgr עצמו. ה-Registry עוד לא נקרא באותו רגע, הוא שייך לשלב של winload, ו-boot.ini ו-NTLDR הם בכלל חלק משרשרת אחרת, של XP.
בהודעת 0xc000000f החוליה ידועה מראש, כי היא מציינת את \Boot\BCD בשמו. אילו הבעיה הייתה בהמשך, ההודעה הייתה מציינת קובץ אחר: את ה-hive בשם SYSTEM, למשל, או קובץ של הליבה.
ופרופיל של משתמש נמצא בקצה השני של השרשרת, אחרי שהמערכת כבר עלתה ומישהו נכנס אליה. הוא לא יכול לגרום לאף הודעת אתחול.
תרחיש 14: מסך שחור אחרי כיבוי פתאומי
מחשב נייד כבה כשהסוללה נגמרה באמצע עבודה, ובהפעלה הבאה מופיע מסך עם File: \Boot\BCD ו-Status: 0xc000000f.
האבחנה: ההודעה הגיעה ממנהל האתחול, כלומר הוא נטען ורץ. מה שנכשל הוא המאגר שהוא ניסה לקרוא.
התיקון: מאתחלים מדיסק און קי של התקנת Windows, בוחרים Repair your computer ופותחים Command Prompt:
bootrec /scanos
bootrec /rebuildbcd/scanos מראה שנמצאה התקנה ב-C:\Windows, ו-/rebuildbcd שואל אם להוסיף אותה לרשימת האתחול. עונים בחיוב ומפעילים מחדש. ואם גם אחרי זה המחשב לא עולה, bcdboot עם הנתיב של תיקיית Windows ייצור מאפס את קובצי האתחול ואת ה-BCD.
שני כיווני חקירה מיותרים כאן: להריץ sfc, שבודק קבצי מערכת שבמקרה הזה תקינים, או לבנות פרופיל משתמש חדש, כשהמחשב בכלל לא הגיע עד מסך הכניסה.
טעויות נפוצות
- 'כתוב שחסר BOOTMGR, אז בטח boot.ini נמחק, או ש-NTLDR נעלם.' boot.ini ו-NTLDR שייכים ל-XP. ההודעה מדברת על bootmgr.
- 'הודעה על bootmgr חסר אומרת שה-Registry לא נקרא כמו שצריך.' ה-Registry נקרא רק בשלב של winload, אחרי bootmgr, ולכן הוא לא יכול לגרום להודעה הזו.
- 'הופיע 0xc000000f, אז אחד מקובצי המערכת נפגם: SYSTEM, ntoskrnl.exe או הפרופיל.' ההודעה עצמה נוקבת ב-
\Boot\BCD. תקלה בקבצים האחרים הייתה מציגה את השם שלהם, ופרופיל נטען רק אחרי הכניסה.
בדקו את עצמכם
במחשב BIOS עם Windows 8.1 מופיעה ההודעה BOOTMGR is missing. האם כדאי לחפש בעיה ב-boot.ini?
לא. Windows 8.1 לא משתמשת ב-boot.ini בכלל. חסר מנהל האתחול bootmgr, ומתקנים מ-WinRE או מדיסק ההתקנה.
במחשב XP מופיעה ההודעה NTLDR is missing. האם bootrec הוא הכלי הנכון?
לא. זו תקלה של XP, ומטפלים בה מ-Recovery Console של XP.
%SystemRoot%: תיקיית Windows בלי לנחש איפה היא
מה יש בתוך המשתנה, ומי השכנים שלו
נפתח בהרצה: חמש פקודות echo בחלון cmd של מחשב Windows 10.
echo %SystemRoot%
echo %systemroot%
echo %windir%
echo %SystemDrive%
echo %SystemRoot%\System32\driversC:\Windows
C:\Windows
C:\Windows
C:
C:\Windows\System32\driversהשורה הראשונה מראה מה cmd עושה עם שם שעטוף בשני סימני אחוז: הוא מציב במקומו את הערך של משתנה הסביבה (Environment variable) בשם הזה, כלומר טקסט ששמור תחת השם וזמין לכל תוכנית וסקריפט. הערך כאן הוא נתיב מלא של תיקיית ההתקנה של Windows, אות כונן ותיקייה יחד.
השורה השנייה, באותיות קטנות, הדפיסה בדיוק אותו דבר, כי ב-Windows שמות של משתני סביבה לא רגישים לגודל האותיות. השלישית מראה ש-%windir% הוא תאום של %SystemRoot%, והרביעית ש-%SystemDrive% עוצר באות הכונן.
החמישית מדגימה את השימוש העיקרי: מחברים למשתנה המשך של נתיב, ומקבלים נתיב מלא לתת-תיקייה.
C:\Windows הוא רק הערך במחשב הזה. בהתקנות של NT ושל 2000 שם התיקייה המקובל היה WINNT, כלומר C:\WINNT, ובהתקנה שנעשתה על כונן או תיקייה אחרים יופיע המקום האמיתי, למשל D:\WINDOWS.
| משתנה | ערך לדוגמה | מה הוא מייצג |
|---|---|---|
%SystemRoot% | C:\Windows | תיקיית ההתקנה של Windows |
%windir% | C:\Windows | אותו ערך בדיוק, ואפשר להשתמש באיזה מהשניים שרוצים |
%SystemDrive% | C: | הכונן שעליו Windows נמצאת, בלי שם התיקייה |
%APPDATA% | C:\Users\noa\AppData\Roaming | נתוני היישומים של המשתמש המחובר |
%TEMP% | C:\Users\noa\AppData\Local\Temp | הקבצים הזמניים של המשתמש |
%ALLUSERSPROFILE% | C:\ProgramData | נתונים שכל המשתמשים חולקים, ולא תיקיית המערכת |
בטבלה יש שני סוגים של משתנים. %APPDATA% ו-%TEMP% מצביעים לתוך הפרופיל של מי שמחובר, ולכן לכל משתמש ערך משלו, ואילו %SystemRoot% שייך למחשב, ואותו ערך מופיע אצל כולם. וכמו שראיתם בהרצה, חלון cmd רגיל קרא אותו בלי בעיה, כך שאין בו שום דבר ששמור לליבה.
שימו לב גם לכיוון: המשתנה מדווח איפה Windows כבר הותקנה. הוא לא משמש לבחירת כונן בהתקנה חדשה, לא נושא הרשאות, ואין לו קשר לכתובות בזיכרון.
טעויות נפוצות
%SystemRoot%שווה ל-C:\Windows\System32. System32 היא תת-תיקייה. המשתנה עצמו נעצר ב-C:\Windows.- המשתנה מצביע על
C:\Usersאו עלC:\Program Files. אלה תיקיות של משתמשים ושל תוכנות, ולא תיקיית Windows. %SystemDrive%הוא שם נוסף ל-%SystemRoot%.%SystemDrive%מחזיק רק אות כונן. המשתנה שזהה ל-%SystemRoot%הוא%windir%.%APPDATA%או%TEMP%נותנים את אותה תשובה. אלה תיקיות אישיות, בתוך הפרופיל של המשתמש.- 'כדי שההתקנה הבאה תיכנס ל-D:, אשנה מראש את
%SystemRoot%', או 'בעזרת המשתנה אתן לכל משתמש הרשאות אחרות לתיקייה'. המשתנה רק מדווח איפה Windows כבר נמצאת. הוא לא משפיע על התקנות עתידיות, ואין לו תפקיד בהרשאות. - רק תהליכי ליבה רשאים לקרוא אותו. כל תוכנית, סקריפט או חלון cmd קוראים אותו.
%SystemRoot%הוא הכתובת הפיזית של הליבה בזיכרון. זה נתיב של תיקייה בדיסק, טקסט ולא כתובת.
בדקו את עצמכם
בשרת Windows NT 4.0 שהותקן עם ברירות המחדל על כונן C, מה תדפיס הפקודה echo %SystemRoot%?
C:\WINNT.
סקריפט צריך רק את האות של הכונן שעליו Windows מותקנת. איזה משתנה הוא יקרא?
%SystemDrive%.
מה יש בתוך תיקיית Windows
חלק גדול מהנתיבים החשובים ב-Windows נכתבים כ-%SystemRoot% ועוד המשך. אלה התיקיות שכדאי להכיר:
| תיקייה | תוכן |
|---|---|
%SystemRoot%\System32 | התוכניות והספריות המרכזיות של המערכת, וכלים כמו cmd.exe. ב-Windows של 64 סיביות אלה גרסאות 64 הסיביות |
%SystemRoot%\SysWOW64 | קיימת רק ב-Windows של 64 סיביות: גרסאות 32 הסיביות של ספריות המערכת, בשביל תוכנות של 32 סיביות |
%SystemRoot%\System32\config | קובצי ה-Registry (ה-hives): SYSTEM, SOFTWARE, SAM, SECURITY |
%SystemRoot%\System32\drivers | מנהלי ההתקן, קבצים עם הסיומת .sys כמו ntfs.sys ו-disk.sys |
%SystemRoot%\System32\drivers\etc | קובצי הגדרות רשת, ביניהם hosts |
%SystemRoot%\System32\winevt\Logs | יומני האירועים, למשל System.evtx ו-Security.evtx |
%SystemRoot%\Boot | המקור של קובצי האתחול ש-bcdboot מעתיק למחיצת המערכת |
תיקיית etc, למשל, נראית כך במחשב Windows 10:
dir /b %SystemRoot%\System32\drivers\etchosts
hosts.ics
lmhosts.sam
networks
protocol
servicesהרשימה מסבירה גם איפה לא לחפש. מסמכים ותמונות של משתמשים, כמו Documents ו-Pictures, שייכים לפרופילים תחת C:\Users, למשל C:\Users\noa. תוכנות שמתקינים הולכות ל-Program Files, ותוכנות 32 סיביות במחשב 64 סיביות ל-Program Files (x86); והגדרות האתחול בכלל לא בתיקיית Windows, הן ב-BCD.
עכשיו ל-System32 ול-SysWOW64. הקובץ wow.cmd מדפיס את סוג התהליך שמריץ אותו, ואת הגודל של notepad.exe בשתי התיקיות. כך הוא נראה, וזה הפלט שלו בחלון cmd רגיל:
@echo off
rem wow.cmd: process type, then the size of notepad.exe in both folders
echo %PROCESSOR_ARCHITECTURE%
for %%f in (%SystemRoot%\System32\notepad.exe) do echo System32 copy: %%~zf bytes
for %%f in (%SystemRoot%\SysWOW64\notepad.exe) do echo SysWOW64 copy: %%~zf bytesAMD64
System32 copy: 200704 bytes
SysWOW64 copy: 165888 bytesהתהליך הוא של 64 סיביות (AMD64), והוא רואה שני קבצים שונים. העותק הגדול, ב-System32, הוא הגרסה של 64 סיביות, והעותק שב-SysWOW64 הוא הגרסה של 32 סיביות: השמות אומרים בדיוק את ההפך ממה שנדמה.
עכשיו מריצים את אותו קובץ דרך cmd של 32 סיביות, שנמצא בעצמו ב-SysWOW64:
%SystemRoot%\SysWOW64\cmd.exe /c wow.cmdx86
System32 copy: 165888 bytes
SysWOW64 copy: 165888 bytesהתהליך הזה הוא של 32 סיביות (x86), וכשביקש את הקובץ מ-System32 הוא קיבל את העותק של 165888 בתים, כלומר את זה שב-SysWOW64. Windows מסיטה תהליכים של 32 סיביות שפונים ל-System32 אל SysWOW64, בלי שהם יודעים על כך, וכך כל תוכנה מקבלת ספריות שמתאימות לה.
ומאיפה השם? WOW64 הוא קיצור של Windows 32-bit on Windows 64-bit, השכבה שמריצה תוכנות 32 סיביות על מערכת 64 סיביות, והמספר בשם מתאר אותה ולא את הקבצים. התיקייה משרתת את השכבה הזו בלבד: היא לא גיבוי של System32, ולא יעד להתקנת תוכנות.
התיקייה config חשובה עוד לפני שמישהו נכנס למערכת: מתוכה winload קורא את ה-hive ששמו SYSTEM, ולפיו נקבע אילו שירותים ומנהלי התקן יופעלו. לצידו שמור SAM, מאגר החשבונות המקומיים.
טעויות נפוצות
- 'ב-SysWOW64 יש 64 בשם, אז שם יושבים קובצי 64 הסיביות.' הפוך: שם יושבים קובצי 32 הסיביות, כמו שהראתה ההרצה. ה-64 שייך לשכבת WOW64.
- 'SysWOW64 היא גיבוי של System32', או 'זו עוד תיקייה לתוכנות, כמו Program Files (x86)'. היא מחזיקה ספריות מערכת של 32 סיביות, ותוכנות של משתמשים לא מותקנות בה.
- ב-
System32\configנמצאים disk.sys וחבריו. מנהלי ההתקן ב-System32\drivers. ב-config נמצאים קובצי ה-Registry. - ב-
System32\configשמורים Documents ו-Pictures. הקבצים האישיים נמצאים בפרופיל, תחתC:\Users. - יומני האירועים יושבים ב-
System32\config. הם ב-System32\winevt\Logs. - הגדרות האתחול שמורות ב-
System32\config. הן במאגר ה-BCD, מחוץ לתיקיית Windows.
בדקו את עצמכם
תוכנה ישנה של 32 סיביות ב-Windows 11 של 64 סיביות מבקשת ספריית מערכת מ-System32. מאיזו תיקייה היא תקבל אותה בפועל?
מ-%SystemRoot%\SysWOW64, כי Windows מסיטה אליה את הבקשה.
איפה תחפשו את הקובץ שמחזיק את חשבונות המשתמשים המקומיים?
ב-%SystemRoot%\System32\config, בקובץ SAM.
למה כותבים את המשתנה ולא נתיב קבוע
דמיינו סקריפט התקנה שמעתיק קובץ אל C:\Windows\System32. ברוב המחשבים בארגון הוא עובד, אבל במחשב אחד Windows הותקנה ב-D:\WINDOWS, ובשרת ישן עם Windows 2000 היא ב-C:\WINNT. בשניהם הנתיב מוביל לתיקייה שלא קיימת, והסקריפט נכשל.
החלפת הנתיב ב-%SystemRoot%\System32 פותרת את כל המחשבים בבת אחת, כי בכל אחד מהם המשתנה מחזיק את המקום האמיתי. אותו עיקרון מאפשר לכלי שדרוג או לקובץ הגדרות אחד לעבוד בכל מבנה של התקנה, בלי שמישהו יתקן נתיבים ביד.
וזה הדבר היחיד שהמשתנה נותן. אין בו הרשאות מנהל, נקודות שחזור או גישה ל-boot.ini, ו-PowerShell לא מתקשה עם C:\Windows, כך שגם זה לא הנימוק.
Windows עצמה משתמשת באותו טריק ב-Registry, דרך ערכים מסוג REG_EXPAND_SZ: מחרוזות שבהן מותר לשלב משתני סביבה, שמוחלפים בערכם רק כשמשתמשים בהם. זו השורה ששומרת את הנתיב של שירות ההדפסה:
reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Spooler /v ImagePath
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Spooler
ImagePath REG_EXPAND_SZ %SystemRoot%\System32\spoolsv.exe
בשביל ההשוואה, ערך מסוג REG_SZ שומר את הטקסט כמו שהוא, ומשתנה שכתוב בתוכו נשאר מילולי ולא מוחלף. את הערך SystemRoot שבמפתח CurrentVersion, למשל, Windows שומרת כנתיב מלא:
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v SystemRoot
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion
SystemRoot REG_SZ C:\Windows
תוכנית שקוראת ערך REG_EXPAND_SZ מבצעת את ההחלפה בעצמה. בפייתון זה נראה כך:
import winreg
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SYSTEM\CurrentControlSet\Services\Spooler")
raw, kind = winreg.QueryValueEx(key, "ImagePath") # read the stored text as is
print("type:", "REG_EXPAND_SZ" if kind == winreg.REG_EXPAND_SZ else kind)
print("stored: ", raw)
print("expanded:", winreg.ExpandEnvironmentStrings(raw)) # the variable is replaced on this machinetype: REG_EXPAND_SZ
stored: %SystemRoot%\System32\spoolsv.exe
expanded: C:\Windows\System32\spoolsv.exeהפלט מראה למה הטריק עובד: הטקסט השמור זהה בכל מחשב, וההחלפה קורית רק במחשב שקורא אותו. במחשב שבו Windows נמצאת ב-D:\WINDOWS, אותה שורה הייתה הופכת ל-D:\WINDOWS\System32\spoolsv.exe.
תרחיש 15: Windows על כונן F
Windows הותקנה בכונן F:, בתיקייה WINDOWS. לכן %SystemRoot% שווה ל-F:\WINDOWS, ו-%SystemDrive% שווה ל-F:.
ערך REG_EXPAND_SZ שבו כתוב %SystemRoot%\Fonts מתורגם ל-F:\WINDOWS\Fonts. שלוש תשובות שגויות שכדאי לזהות:
F:\Fonts: כאן התייחסו למשתנה כאילו הוא רק כונן, ושם התיקייה WINDOWS נשמט.C:\WINDOWS\Fonts: כאן הניחו שהכונן הוא תמיד C, ובדיוק את ההנחה הזו המשתנה נועד לבטל.C:\WINNT\Fonts: WINNT היא התיקייה של NT ושל 2000, ולא של ההתקנה הזו.
טעויות נפוצות
- 'בסקריפטים של PowerShell חייבים משתנה, אחרת נתיב כמו
C:\Windowsלא יעבוד.' PowerShell מקבל את הנתיב הזה כרגיל. הנימוק למשתנה הוא המחשבים שבהם Windows לא נמצאת שם. - 'ממילא בכל מחשב זה
C:\Windows, המשתנה רק חוסך הקלדה.' בדיוק להפך: הערך משתנה ממחשב למחשב, ולכן צריך משתנה. - סקריפט שמשתמש במשתנה רץ אוטומטית עם הרשאות מנהל. משתנה הוא טקסט. ההרשאות נקבעות לפי מי שמריץ את הסקריפט.
- דרך %systemroot% אפשר לערוך את boot.ini, ליצור נקודת שחזור או לחלק הרשאות. הוא מחזיק נתיב, ותו לא.
בדקו את עצמכם
Windows מותקנת ב-G:\Sys. לאיזה נתיב יתורגם %SystemRoot%\Boot?
G:\Sys\Boot.
ב-Registry נשמר ערך מסוג REG_SZ עם הטקסט %SystemRoot%\System32\app.dll. מה תקבל תוכנית שקוראת אותו?
את הטקסט כפי שהוא, כולל %SystemRoot%, כי ב-REG_SZ המשתנה לא מוחלף. כדי שיוחלף, הערך צריך להיות מסוג REG_EXPAND_SZ.
%SystemRoot% בחלון cmd, והפקודה set
בחלון cmd ההחלפה של המשתנה קורית לפני שהפקודה רצה, כך ש-cd מקבל נתיב מוכן. מוסיפים תת-תיקייה עם לוכסן הפוך (backslash), והמתג /d מאפשר ל-cd להחליף כונן אם צריך:
cd /d C:\Users
cd /d %systemroot%\system32
cdC:\Windows\System32ה-cd האחרון מראה שהגענו ל-System32 עצמה: לא רמה אחת למעלה, לתיקיית Windows, ולא רמה אחת למטה, ל-System32\drivers.
ועכשיו שתי גרסאות שגויות של אותה פקודה:
cd /d %systemroot%\Windows\system32
cd /d %systemroot% system32The system cannot find the path specified.
The system cannot find the path specified.- בשורה הראשונה Windows מופיעה פעמיים. המשתנה כבר מכיל אותה, והנתיב שמתקבל הוא
C:\Windows\Windows\system32, שאינו קיים. - בשורה השנייה יש רווח במקום לוכסן הפוך, ולכן system32 לא מצטרף לנתיב כתת-תיקייה, ו-cd מחפש תיקייה שאין לה קיום.
עכשיו נשנה משתנה. בהרצה הבאה החלון מגדיר את SystemDrive כ-Z: בעזרת set, ומיד מפעיל ממנו תוכנית פייתון שמדפיסה את אותו משתנה:
set SystemDrive=Z:
echo %SystemDrive%
python -c "import os; print(os.environ['SYSTEMDRIVE'])"Z:
Z:גם echo וגם פייתון הדפיסו Z:, אף שבמחשב עצמו לא השתנה דבר. זו הדרך שבה Windows מנהלת משתני סביבה: לכל תהליך יש סביבה משלו, ותהליך חדש מקבל העתק של הסביבה של מי שהפעיל אותו. set שינתה את הסביבה של החלון, ופייתון נולד ממנו אחרי השינוי.
חלון cmd נפרד, שלא נפתח מהחלון שלנו, הדפיס באותו רגע C: עבור echo %SystemDrive%: הוא קיבל את הסביבה מ-Windows ולא מאיתנו, וכך גם כל תהליך שכבר רץ. השינוי לא נרשם ב-Registry, הוא נעלם יחד עם החלון, ושום תיקייה לא זזה בעקבותיו.
תרחיש 16: SystemRoot שמצביע על תיקייה שאינה קיימת
בחלון cmd מגדירים ל-SystemRoot תיקייה שאינה קיימת בכונן C:, ומנסים להיכנס דרכה ל-System32:
cd /d C:\
set SystemRoot=C:\Spare-OS
echo %SystemRoot%
cd /d %SystemRoot%\System32
cdC:\Spare-OS
The system cannot find the path specified.
C:\הפלט מספר את הסיפור בשלוש שורות. echo מוכיח שהחלון כבר עובד עם הערך החדש; cd מרכיב ממנו את C:\Spare-OS\System32, נתקל בתיקייה שלא קיימת ומדווח על כך; וה-cd שבסוף מראה שלא זזנו מ-C:\.
כלומר cd לא בונה תיקיות חסרות, וגם לא מתעלם מהמשתנה ונופל חזרה ל-C:\Windows\System32. כשגם הכונן עצמו לא קיים, ההודעה שונה אבל התוצאה זהה:
set SystemRoot=Q:\Spare-OS
cd /d %SystemRoot%\System32
cdThe system cannot find the drive specified.
C:\ומה ראו שאר התהליכים? כלום. חלונות cmd אחרים, אלה שכבר פתוחים ואלה שייפתחו בהמשך מתפריט התחל, עדיין מקבלים C:\Windows, ו-Windows ממשיכה לטעון קבצים מהתיקייה שבה היא באמת יושבת, בלי שאף תהליך ייפגע.
טעויות נפוצות
- 'אחרי set כל המחשב עובר לערך החדש, ו-Windows תתחיל לטעון קבצים מהתיקייה שהגדרתי.' השינוי חל על החלון הנוכחי ועל תוכניות שהוא מפעיל מכאן והלאה, ותו לא.
- 'set שומרת את הערך ב-Registry לתמיד.' השינוי חי רק בסביבה של התהליך, ונעלם עם סגירת החלון.
- 'כל חלון cmd שאפתח מעכשיו יקבל את הערך החדש.' חלון חדש שנפתח מתפריט התחל מקבל את הערך המקורי.
- 'אם התיקייה חסרה, cd תיצור אותה.' cd רק עובר בין תיקיות קיימות. ליצירה יש פקודה אחרת, md.
- 'כשמצרפים system32 אחרי המשתנה עם לוכסן הפוך, cd מגיע ל-drivers, או לתיקיית Windows עצמה.' הוא מגיע בדיוק ל-System32, כמו שהראתה ההרצה.
בדקו את עצמכם
בחלון cmd הרצתם set SystemDrive=Y:, ומיד אחר כך הפעלתם מאותו חלון סקריפט פייתון. איזה ערך של SystemDrive רואה הסקריפט?
Y:, כי התהליך שלו נולד מהחלון וקיבל עותק של הסביבה שלו.
ומה יראה חלון cmd שתפתחו אחר כך מתפריט התחל?
את הערך המקורי, בדרך כלל C:.
סיכום
כל הפרק בקצרה, מהקושחה ועד תיקיית Windows.
שרשרת האתחול
- Bootloader הוא הקוד שמביא את מערכת ההפעלה לזיכרון ומוסר לה את השליטה.
- במחשב BIOS עם דיסק MBR: קוד ה-MBR מעביר למגזר האתחול של המחיצה הפעילה, משם עולה bootmgr, שקורא את ה-BCD בתיקייה
\Bootומפעיל את winload.exe. - במחשב UEFI עם דיסק GPT: רשומת אתחול ב-NVRAM מובילה ל-bootmgfw.efi שב-ESP (
\EFI\Microsoft\Boot), וזה טוען את winload.efi לפי מה שכתוב ב-BCD. כשאין ב-NVRAM רשומה מתאימה, הקושחה מנסה את\EFI\Boot\bootx64.efi. - Secure Boot מתיר להריץ רק קוד אתחול חתום, והוא קיים רק ב-UEFI. Legacy Boot נשאר בשביל מערכות וכלים ישנים שאינם תומכים ב-UEFI.
- Windows Boot Manager קורא את ה-BCD, מציג תפריט, ומפעיל את winload, או את winresume בחזרה מתרדמה. winload טוען את ntoskrnl.exe, את ה-HAL, את קובץ ה-Registry בשם SYSTEM ואת מנהלי ההתקן של האתחול, ואחר כך עולים smss.exe ו-wininit.exe.
השיטה הישנה: NTLDR ו-boot.ini
- ב-NT, 2000, XP ו-Server 2003 הטוען הוא NTLDR, והוא קורא את boot.ini: קובץ טקסט מוסתר, עם תכונות מערכת וקריאה בלבד, בשורש של מחיצת המערכת הפעילה.
- ל-boot.ini שני סעיפים: [boot loader], עם timeout (ב-XP ברירת המחדל היא 30) ו-default, ו-[operating systems], עם שורה לכל התקנה.
- בנתיב ARC המספור של rdisk מתחיל ב-0, והמספור של partition ב-1.
- מתגים כמו /fastdetect, /safeboot, /detecthal, /hal=, /maxmem, /sos ו-/bootlog נכתבים בשורת המערכת, ונשארים בתוקף עד שמסירים אותם.
- boot.ini פגום ב-XP מתקנים ב-Recovery Console עם bootcfg /rebuild, או בעריכה של הקובץ ממערכת אחרת.
BCD ו-bcdedit
- BCD החליף את boot.ini מ-Vista: מאגר בינארי במבנה hive, לא טקסט ולא מוצפן, שעורכים ב-bcdedit מחלון מנהל.
- כל רשומה מזוהה ב-GUID קבוע, ויש כינויים כמו
{bootmgr},{current},{default}ו-{ntldr}. דיסקים מזוהים לפי חתימת הדיסק ב-MBR, או לפי GUID ב-GPT. - אלמנטים: description לשם בתפריט, device ו-path לקובץ הטעינה, osdevice ו-systemroot לתיקיית Windows, inherit לירושת הגדרות, ו-default, displayorder ו-timeout ברשומת
{bootmgr}. - RAMDISK OPTIONS מתאר את הדיסק המדומה בזיכרון, שממנו עולה WinPE.
- פקודות: /enum, /set, /deletevalue, /create, /copy, /delete, /export ו-/import לגיבוי ושחזור של המאגר כולו, ו-/store לעבודה על קובץ BCD אחר.
- בתפריט: /default קבוע, /timeout מקבל שניות, /displayorder קובע סדר, /bootsequence חל על הפעלה אחת, ו-displaybootmenu מציג תפריט גם כשיש רשומה אחת.
- מצב בטוח: safeboot minimal (או network) ברשומה, שנשאר עד /deletevalue. אבחון: /debug או debug on לניפוי ליבה, /ems ל-EMS, ו-bootlog ליומן ב-ntbtlog.txt.
תקלות ותיקון
- כש-MBR, מגזר האתחול או ה-BCD פגומים, מתקנים מ-WinRE או מדיסק ההתקנה: bootrec עם /fixmbr, /fixboot, /scanos ו-/rebuildbcd, ו-bcdboot לבנייה מחדש של קובצי האתחול וה-BCD.
- BOOTMGR is missing: מנהל האתחול חסר.
File: \Boot\BCDעם 0xc000000f: המאגר חסר או פגום.
%SystemRoot%
%SystemRoot%הוא תיקיית Windows, בדרך כללC:\Windows(ב-NT וב-2000C:\WINNT), וזהה ל-%windir%.%SystemDrive%הוא הכונן בלבד.- System32 מחזיקה קובצי 64 סיביות ו-SysWOW64 קובצי 32 סיביות, וב-
System32\configנמצאים קובצי ה-Registry. - ערך REG_EXPAND_SZ מחליף את
%SystemRoot%בערך האמיתי, ולכן אותו נתיב עובד בכל התקנה. set משנה משתנה רק בחלון ה-cmd הנוכחי ובתוכניות שהוא מפעיל.