4 * Copyright (C) 1998-2003 Brian Palmer <brianp@sginet.com>
5 * Copyright (C) 2006 Aleksey Bragin <aleksey@reactos.org>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <ndk/ldrtypes.h>
27 //FIXME: Do a better way to retrieve Arc disk information
28 extern ULONG reactos_disk_count
;
29 extern ARC_DISK_SIGNATURE reactos_arc_disk_info
[];
30 extern char reactos_arc_strings
[32][256];
31 extern char reactos_arc_hardware_data
[HW_MAX_ARC_HEAP_SIZE
];
34 WinLdrCheckForLoadedDll(IN OUT PLOADER_PARAMETER_BLOCK WinLdrBlock
,
36 OUT PLDR_DATA_TABLE_ENTRY
*LoadedEntry
);
39 VOID
DumpMemoryAllocMap(VOID
);
40 VOID
WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock
);
41 VOID
WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock
);
42 VOID
WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock
);
47 AllocateAndInitLPB(PLOADER_PARAMETER_BLOCK
*OutLoaderBlock
)
49 PLOADER_PARAMETER_BLOCK LoaderBlock
;
51 /* Allocate and zero-init the LPB */
52 LoaderBlock
= MmHeapAlloc(sizeof(LOADER_PARAMETER_BLOCK
));
53 RtlZeroMemory(LoaderBlock
, sizeof(LOADER_PARAMETER_BLOCK
));
55 /* Init three critical lists, used right away */
56 InitializeListHead(&LoaderBlock
->LoadOrderListHead
);
57 InitializeListHead(&LoaderBlock
->MemoryDescriptorListHead
);
58 InitializeListHead(&LoaderBlock
->BootDriverListHead
);
60 /* Alloc space for NLS (it will be converted to VA in WinLdrLoadNLS) */
61 LoaderBlock
->NlsData
= MmHeapAlloc(sizeof(NLS_DATA_BLOCK
));
62 if (LoaderBlock
->NlsData
== NULL
)
64 UiMessageBox("Failed to allocate memory for NLS table data!");
67 RtlZeroMemory(LoaderBlock
->NlsData
, sizeof(NLS_DATA_BLOCK
));
69 *OutLoaderBlock
= LoaderBlock
;
74 WinLdrInitializePhase1(PLOADER_PARAMETER_BLOCK LoaderBlock
,
79 /* Examples of correct options and paths */
80 //CHAR Options[] = "/DEBUGPORT=COM1 /BAUDRATE=115200";
81 //CHAR Options[] = "/NODEBUG";
82 //CHAR SystemRoot[] = "\\WINNT\\";
83 //CHAR ArcBoot[] = "multi(0)disk(0)rdisk(0)partition(1)";
85 CHAR HalPath
[] = "\\";
88 ULONG i
, PathSeparator
;
89 PLOADER_PARAMETER_EXTENSION Extension
;
91 LoaderBlock
->u
.I386
.CommonDataArea
= NULL
; // Force No ABIOS support
93 /* Construct SystemRoot and ArcBoot from SystemPath */
94 PathSeparator
= strstr(SystemPath
, "\\") - SystemPath
;
95 strncpy(ArcBoot
, SystemPath
, PathSeparator
);
96 ArcBoot
[PathSeparator
] = 0;
97 strcpy(SystemRoot
, &SystemPath
[PathSeparator
]);
98 strcat(SystemRoot
, "\\");
100 DbgPrint((DPRINT_WINDOWS
, "ArcBoot: %s\n", ArcBoot
));
101 DbgPrint((DPRINT_WINDOWS
, "SystemRoot: %s\n", SystemRoot
));
102 DbgPrint((DPRINT_WINDOWS
, "Options: %s\n", Options
));
104 /* Fill Arc BootDevice */
105 LoaderBlock
->ArcBootDeviceName
= MmHeapAlloc(strlen(ArcBoot
)+1);
106 strcpy(LoaderBlock
->ArcBootDeviceName
, ArcBoot
);
107 LoaderBlock
->ArcBootDeviceName
= PaToVa(LoaderBlock
->ArcBootDeviceName
);
109 /* Fill Arc HalDevice, it matches ArcBoot path */
110 LoaderBlock
->ArcHalDeviceName
= MmHeapAlloc(strlen(ArcBoot
)+1);
111 strcpy(LoaderBlock
->ArcHalDeviceName
, ArcBoot
);
112 LoaderBlock
->ArcHalDeviceName
= PaToVa(LoaderBlock
->ArcHalDeviceName
);
114 /* Fill SystemRoot */
115 LoaderBlock
->NtBootPathName
= MmHeapAlloc(strlen(SystemRoot
)+1);
116 strcpy(LoaderBlock
->NtBootPathName
, SystemRoot
);
117 LoaderBlock
->NtBootPathName
= PaToVa(LoaderBlock
->NtBootPathName
);
119 /* Fill NtHalPathName */
120 LoaderBlock
->NtHalPathName
= MmHeapAlloc(strlen(HalPath
)+1);
121 strcpy(LoaderBlock
->NtHalPathName
, HalPath
);
122 LoaderBlock
->NtHalPathName
= PaToVa(LoaderBlock
->NtHalPathName
);
124 /* Fill load options */
125 LoaderBlock
->LoadOptions
= MmHeapAlloc(strlen(Options
)+1);
126 strcpy(LoaderBlock
->LoadOptions
, Options
);
127 LoaderBlock
->LoadOptions
= PaToVa(LoaderBlock
->LoadOptions
);
130 LoaderBlock
->ArcDiskInformation
= (PARC_DISK_INFORMATION
)MmHeapAlloc(sizeof(ARC_DISK_INFORMATION
));
131 InitializeListHead(&LoaderBlock
->ArcDiskInformation
->DiskSignatureListHead
);
133 /* Convert ARC disk information from freeldr to a correct format */
134 for (i
= 0; i
< reactos_disk_count
; i
++)
136 PARC_DISK_SIGNATURE ArcDiskInfo
;
138 /* Get the ARC structure */
139 ArcDiskInfo
= (PARC_DISK_SIGNATURE
)MmHeapAlloc(sizeof(ARC_DISK_SIGNATURE
));
140 RtlZeroMemory(ArcDiskInfo
, sizeof(ARC_DISK_SIGNATURE
));
142 /* Copy the data over */
143 ArcDiskInfo
->Signature
= reactos_arc_disk_info
[i
].Signature
;
144 ArcDiskInfo
->CheckSum
= reactos_arc_disk_info
[i
].CheckSum
;
146 /* Copy the ARC Name */
147 ArcDiskInfo
->ArcName
= (PCHAR
)MmHeapAlloc(sizeof(CHAR
)*256);
148 strcpy(ArcDiskInfo
->ArcName
, reactos_arc_disk_info
[i
].ArcName
);
149 ArcDiskInfo
->ArcName
= (PCHAR
)PaToVa(ArcDiskInfo
->ArcName
);
151 /* Mark partition table as valid */
152 ArcDiskInfo
->ValidPartitionTable
= TRUE
;
154 /* Insert into the list */
155 InsertTailList(&LoaderBlock
->ArcDiskInformation
->DiskSignatureListHead
,
156 &ArcDiskInfo
->ListEntry
);
159 /* Convert all list's to Virtual address */
161 /* Convert the ArcDisks list to virtual address */
162 List_PaToVa(&LoaderBlock
->ArcDiskInformation
->DiskSignatureListHead
);
163 LoaderBlock
->ArcDiskInformation
= PaToVa(LoaderBlock
->ArcDiskInformation
);
165 /* Convert configuration entries to VA */
166 ConvertConfigToVA(LoaderBlock
->ConfigurationRoot
);
167 LoaderBlock
->ConfigurationRoot
= PaToVa(LoaderBlock
->ConfigurationRoot
);
169 /* Convert all DTE into virtual addresses */
170 List_PaToVa(&LoaderBlock
->LoadOrderListHead
);
172 /* this one will be converted right before switching to
173 virtual paging mode */
174 //List_PaToVa(&LoaderBlock->MemoryDescriptorListHead);
176 /* Convert list of boot drivers */
177 List_PaToVa(&LoaderBlock
->BootDriverListHead
);
179 /* Initialize Extension now */
180 Extension
= MmHeapAlloc(sizeof(LOADER_PARAMETER_EXTENSION
));
181 if (Extension
== NULL
)
183 UiMessageBox("Failed to allocate LPB Extension!");
186 RtlZeroMemory(Extension
, sizeof(LOADER_PARAMETER_EXTENSION
));
188 /* Save size and version information */
189 Extension
->Size
= sizeof(LOADER_PARAMETER_EXTENSION
);
190 Extension
->MajorVersion
= (VersionToBoot
& 0xFF00) >> 8;
191 Extension
->MinorVersion
= VersionToBoot
& 0xFF;
194 LoaderBlock
->Extension
= PaToVa(Extension
);
197 // Last step before going virtual
198 void WinLdrSetupForNt(PLOADER_PARAMETER_BLOCK LoaderBlock
,
207 ULONG BlockSize
, NumPages
;
209 LoaderBlock
->u
.I386
.CommonDataArea
= NULL
;//CommonDataArea;
210 //LoaderBlock->u.I386.MachineType = MachineType; //FIXME: MachineType?
212 /* Allocate 2 pages for PCR */
213 Pcr
= (ULONG_PTR
)MmAllocateMemoryWithType(2 * MM_PAGE_SIZE
, LoaderStartupPcrPage
);
214 *PcrBasePage
= Pcr
>> MM_PAGE_SHIFT
;
218 UiMessageBox("Can't allocate PCR\n");
223 TssSize
= (sizeof(KTSS
) + MM_PAGE_SIZE
) & ~(MM_PAGE_SIZE
- 1);
224 TssPages
= TssSize
/ MM_PAGE_SIZE
;
226 Tss
= (ULONG_PTR
)MmAllocateMemoryWithType(TssSize
, LoaderMemoryData
);
228 *TssBasePage
= Tss
>> MM_PAGE_SHIFT
;
230 /* Allocate space for new GDT + IDT */
231 BlockSize
= NUM_GDT
*sizeof(KGDTENTRY
) + NUM_IDT
*sizeof(KIDTENTRY
);//FIXME: Use GDT/IDT limits here?
232 NumPages
= (BlockSize
+ MM_PAGE_SIZE
- 1) >> MM_PAGE_SHIFT
;
233 *GdtIdt
= (PKGDTENTRY
)MmAllocateMemoryWithType(NumPages
* MM_PAGE_SIZE
, LoaderMemoryData
);
237 UiMessageBox("Can't allocate pages for GDT+IDT!\n");
241 /* Zero newly prepared GDT+IDT */
242 RtlZeroMemory(*GdtIdt
, NumPages
<< MM_PAGE_SHIFT
);
246 WinLdrLoadDeviceDriver(PLOADER_PARAMETER_BLOCK LoaderBlock
,
248 PUNICODE_STRING FilePath
,
250 PLDR_DATA_TABLE_ENTRY
*DriverDTE
)
253 CHAR DriverPath
[1024];
259 // Separate the path to file name and directory path
260 sprintf(DriverPath
, "%wZ", FilePath
);
261 DriverNamePos
= strrchr(DriverPath
, '\\');
262 if (DriverNamePos
!= NULL
)
265 strcpy(DllName
, DriverNamePos
+1);
267 // Cut out the name from the path
268 *(DriverNamePos
+1) = 0;
271 DbgPrint((DPRINT_WINDOWS
, "DriverPath: %s, DllName: %s, LPB %p\n", DriverPath
, DllName
, LoaderBlock
));
274 // Check if driver is already loaded
275 Status
= WinLdrCheckForLoadedDll(LoaderBlock
, DllName
, DriverDTE
);
278 // We've got the pointer to its DTE, just return success
282 // It's not loaded, we have to load it
283 sprintf(FullPath
,"%s%wZ", BootPath
, FilePath
);
284 Status
= WinLdrLoadImage(FullPath
, LoaderBootDriver
, &DriverBase
);
288 // Allocate a DTE for it
289 Status
= WinLdrAllocateDataTableEntry(LoaderBlock
, DllName
, DllName
, DriverBase
, DriverDTE
);
292 DbgPrint((DPRINT_WINDOWS
, "WinLdrAllocateDataTableEntry() failed\n"));
296 // Modify any flags, if needed
297 (*DriverDTE
)->Flags
|= Flags
;
299 // Look for any dependencies it may have, and load them too
300 sprintf(FullPath
,"%s%s", BootPath
, DriverPath
);
301 Status
= WinLdrScanImportDescriptorTable(LoaderBlock
, FullPath
, *DriverDTE
);
304 DbgPrint((DPRINT_WINDOWS
, "WinLdrScanImportDescriptorTable() failed for %s\n",
313 WinLdrLoadBootDrivers(PLOADER_PARAMETER_BLOCK LoaderBlock
,
317 PBOOT_DRIVER_LIST_ENTRY BootDriver
;
320 // Walk through the boot drivers list
321 NextBd
= LoaderBlock
->BootDriverListHead
.Flink
;
323 while (NextBd
!= &LoaderBlock
->BootDriverListHead
)
325 BootDriver
= CONTAINING_RECORD(NextBd
, BOOT_DRIVER_LIST_ENTRY
, ListEntry
);
327 DbgPrint((DPRINT_WINDOWS
, "BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver
->FilePath
,
328 BootDriver
->DataTableEntry
, &BootDriver
->RegistryPath
));
330 // Paths are relative (FIXME: Are they always relative?)
333 Status
= WinLdrLoadDeviceDriver(LoaderBlock
, BootPath
, &BootDriver
->FilePath
,
334 0, &BootDriver
->DataTableEntry
);
336 // If loading failed - cry loudly
337 //FIXME: Maybe remove it from the list and try to continue?
340 UiMessageBox("Can't load boot driver!");
344 // Convert the RegistryPath and DTE addresses to VA since we are not going to use it anymore
345 BootDriver
->RegistryPath
.Buffer
= PaToVa(BootDriver
->RegistryPath
.Buffer
);
346 BootDriver
->DataTableEntry
= PaToVa(BootDriver
->DataTableEntry
);
348 NextBd
= BootDriver
->ListEntry
.Flink
;
355 LoadAndBootWindows(PCSTR OperatingSystemName
, WORD OperatingSystemVersion
)
358 CHAR SystemPath
[512], SearchPath
[512];
361 CHAR BootOptions
[256];
362 PVOID NtosBase
= NULL
, HalBase
= NULL
, KdComBase
= NULL
;
366 PLOADER_PARAMETER_BLOCK LoaderBlock
, LoaderBlockVA
;
367 KERNEL_ENTRY_POINT KiSystemStartup
;
368 PLDR_DATA_TABLE_ENTRY KernelDTE
, HalDTE
, KdComDTE
= NULL
;
374 //sprintf(MsgBuffer,"Booting Microsoft(R) Windows(R) OS version '%04x' is not implemented yet", OperatingSystemVersion);
375 //UiMessageBox(MsgBuffer);
377 // Open the operating system section
378 // specified in the .ini file
379 if (!IniOpenSection(OperatingSystemName
, &SectionId
))
381 sprintf(MsgBuffer
,"Operating System section '%s' not found in freeldr.ini", OperatingSystemName
);
382 UiMessageBox(MsgBuffer
);
387 UiDrawStatusText("Detecting Hardware...");
388 UiDrawProgressBarCenter(1, 100, "Loading Windows...");
390 /* Make sure the system path is set in the .ini file */
391 if (!IniReadSettingByName(SectionId
, "SystemPath", SystemPath
, sizeof(SystemPath
)))
393 UiMessageBox("System path not specified for selected operating system.");
397 /* Read booting options */
398 if (!IniReadSettingByName(SectionId
, "Options", BootOptions
, sizeof(BootOptions
)))
400 /* Nothing read, make the string empty */
401 strcpy(BootOptions
, "");
404 /* Normalize system path */
405 if (!MachDiskNormalizeSystemPath(SystemPath
, sizeof(SystemPath
)))
407 UiMessageBox("Invalid system path");
411 /* Let user know we started loading */
412 UiDrawStatusText("Loading...");
414 /* Try to open system drive */
415 BootDevice
= 0xffffffff;
416 if (!FsOpenSystemVolume(SystemPath
, BootPath
, &BootDevice
))
418 UiMessageBox("Failed to open boot drive.");
422 /* append a backslash */
423 if ((strlen(BootPath
)==0) ||
424 BootPath
[strlen(BootPath
)] != '\\')
425 strcat(BootPath
, "\\");
427 DbgPrint((DPRINT_WINDOWS
,"SystemRoot: '%s'\n", BootPath
));
429 /* Allocate and minimalistic-initialize LPB */
430 AllocateAndInitLPB(&LoaderBlock
);
432 /* Detect hardware */
434 LoaderBlock
->ConfigurationRoot
= MmHeapAlloc(16 * 1024);
435 RtlCopyMemory(LoaderBlock
->ConfigurationRoot
,
436 (PVOID
)reactos_arc_hardware_data
, 16 * 1024);
439 strcpy(FileName
, BootPath
);
440 strcat(FileName
, "SYSTEM32\\NTOSKRNL.EXE");
441 Status
= WinLdrLoadImage(FileName
, LoaderSystemCode
, &NtosBase
);
442 DbgPrint((DPRINT_WINDOWS
, "Ntos loaded with status %d at %p\n", Status
, NtosBase
));
445 strcpy(FileName
, BootPath
);
446 strcat(FileName
, "SYSTEM32\\HAL.DLL");
447 Status
= WinLdrLoadImage(FileName
, LoaderHalCode
, &HalBase
);
448 DbgPrint((DPRINT_WINDOWS
, "HAL loaded with status %d at %p\n", Status
, HalBase
));
450 /* Load kernel-debugger support dll */
451 if (OperatingSystemVersion
> _WIN32_WINNT_WIN2K
)
453 strcpy(FileName
, BootPath
);
454 strcat(FileName
, "SYSTEM32\\KDCOM.DLL");
455 Status
= WinLdrLoadImage(FileName
, LoaderBootDriver
, &KdComBase
);
456 DbgPrint((DPRINT_WINDOWS
, "KdCom loaded with status %d at %p\n", Status
, KdComBase
));
459 /* Allocate data table entries for above-loaded modules */
460 WinLdrAllocateDataTableEntry(LoaderBlock
, "ntoskrnl.exe",
461 "WINNT\\SYSTEM32\\NTOSKRNL.EXE", NtosBase
, &KernelDTE
);
462 WinLdrAllocateDataTableEntry(LoaderBlock
, "hal.dll",
463 "WINNT\\SYSTEM32\\HAL.DLL", HalBase
, &HalDTE
);
464 if (OperatingSystemVersion
> _WIN32_WINNT_WIN2K
)
466 WinLdrAllocateDataTableEntry(LoaderBlock
, "kdcom.dll",
467 "WINNT\\SYSTEM32\\KDCOM.DLL", KdComBase
, &KdComDTE
);
470 /* Load all referenced DLLs for kernel, HAL and kdcom.dll */
471 strcpy(SearchPath
, BootPath
);
472 strcat(SearchPath
, "SYSTEM32\\");
473 WinLdrScanImportDescriptorTable(LoaderBlock
, SearchPath
, KernelDTE
);
474 WinLdrScanImportDescriptorTable(LoaderBlock
, SearchPath
, HalDTE
);
476 WinLdrScanImportDescriptorTable(LoaderBlock
, SearchPath
, KdComDTE
);
478 /* Load Hive, and then NLS data, OEM font, and prepare boot drivers list */
479 Status
= WinLdrLoadAndScanSystemHive(LoaderBlock
, BootPath
);
480 DbgPrint((DPRINT_WINDOWS
, "SYSTEM hive loaded and scanned with status %d\n", Status
));
482 /* Load boot drivers */
483 Status
= WinLdrLoadBootDrivers(LoaderBlock
, BootPath
);
484 DbgPrint((DPRINT_WINDOWS
, "Boot drivers loaded with status %d\n", Status
));
486 /* Initialize Phase 1 - no drivers loading anymore */
487 WinLdrInitializePhase1(LoaderBlock
, BootOptions
, SystemPath
, OperatingSystemVersion
);
489 /* Alloc PCR, TSS, do magic things with the GDT/IDT */
490 WinLdrSetupForNt(LoaderBlock
, &GdtIdt
, &PcrBasePage
, &TssBasePage
);
492 /* Save entry-point pointer and Loader block VAs */
493 KiSystemStartup
= (KERNEL_ENTRY_POINT
)KernelDTE
->EntryPoint
;
494 LoaderBlockVA
= PaToVa(LoaderBlock
);
496 /* "Stop all motors", change videomode */
497 DiskStopFloppyMotor();
498 MachVideoPrepareForReactOS(FALSE
);
501 //DumpMemoryAllocMap();
503 /* Turn on paging mode of CPU*/
504 WinLdrTurnOnPaging(LoaderBlock
, PcrBasePage
, TssBasePage
, GdtIdt
);
506 DbgPrint((DPRINT_WINDOWS
, "Hello from paged mode, KiSystemStartup %p, LoaderBlockVA %p!\n",
507 KiSystemStartup
, LoaderBlockVA
));
509 WinLdrpDumpMemoryDescriptors(LoaderBlockVA
);
510 WinLdrpDumpBootDriver(LoaderBlockVA
);
511 WinLdrpDumpArcDisks(LoaderBlockVA
);
513 //FIXME: If I substitute this debugging checkpoint, GCC will "optimize away" the code below
515 /*asm(".intel_syntax noprefix\n");
518 asm(".att_syntax\n");*/
521 (*KiSystemStartup
)(LoaderBlockVA
);
527 WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock
)
530 PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor
;
532 NextMd
= LoaderBlock
->MemoryDescriptorListHead
.Flink
;
534 while (NextMd
!= &LoaderBlock
->MemoryDescriptorListHead
)
536 MemoryDescriptor
= CONTAINING_RECORD(NextMd
, MEMORY_ALLOCATION_DESCRIPTOR
, ListEntry
);
538 DbgPrint((DPRINT_WINDOWS
, "BP %08X PC %04X MT %d\n", MemoryDescriptor
->BasePage
,
539 MemoryDescriptor
->PageCount
, MemoryDescriptor
->MemoryType
));
541 NextMd
= MemoryDescriptor
->ListEntry
.Flink
;
546 WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock
)
549 PBOOT_DRIVER_LIST_ENTRY BootDriver
;
551 NextBd
= LoaderBlock
->BootDriverListHead
.Flink
;
553 while (NextBd
!= &LoaderBlock
->BootDriverListHead
)
555 BootDriver
= CONTAINING_RECORD(NextBd
, BOOT_DRIVER_LIST_ENTRY
, ListEntry
);
557 DbgPrint((DPRINT_WINDOWS
, "BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver
->FilePath
,
558 BootDriver
->DataTableEntry
, &BootDriver
->RegistryPath
));
560 NextBd
= BootDriver
->ListEntry
.Flink
;
565 WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock
)
568 PARC_DISK_SIGNATURE ArcDisk
;
570 NextBd
= LoaderBlock
->ArcDiskInformation
->DiskSignatureListHead
.Flink
;
572 while (NextBd
!= &LoaderBlock
->ArcDiskInformation
->DiskSignatureListHead
)
574 ArcDisk
= CONTAINING_RECORD(NextBd
, ARC_DISK_SIGNATURE
, ListEntry
);
576 DbgPrint((DPRINT_WINDOWS
, "ArcDisk %s checksum: 0x%X, signature: 0x%X\n",
577 ArcDisk
->ArcName
, ArcDisk
->CheckSum
, ArcDisk
->Signature
));
579 NextBd
= ArcDisk
->ListEntry
.Flink
;