![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bootdiskio.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / boot / windows|
Return to bootdiskio.cpp CVS log | Up to [truecrypt] / truecrypt / boot / windows |
1.1 root 1: /*
2: Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
3:
4: Governed by the TrueCrypt License 2.4 the full text of which is contained
5: in the file License.txt included in TrueCrypt binary and source code
6: distribution packages.
7: */
8:
9: #include "Bios.h"
10: #include "BootConsoleIo.h"
11: #include "BootDebug.h"
12: #include "BootDiskIo.h"
13:
14:
15: bool IsLbaSupported (byte drive)
16: {
17: uint16 result = 0;
18: __asm
19: {
20: mov bx, 0x55aa
21: mov dl, drive
22: mov ah, 0x41
23: int 0x13
24: jc err
25: mov result, bx
26: err:
27: }
28:
29: return result == 0xaa55;
30: }
31:
32:
33: void PrintDiskError (BiosResult error, bool write, byte drive, const uint64 *sector, const ChsAddress *chs)
34: {
35: PrintEndl();
36: Print (write ? "Write" : "Read"); Print (" error:");
37: PrintHex (error);
38: Print (" Drive:");
39: Print (drive < TC_FIRST_BIOS_DRIVE ? drive : drive - TC_FIRST_BIOS_DRIVE);
40:
41: if (sector)
42: {
43: Print (" Sector:");
44: Print (*sector);
45: }
46:
47: if (chs)
48: {
49: Print (" CHS:");
50: Print (*chs);
51: }
52:
53: PrintEndl();
54: Beep();
55: }
56:
57:
58: void Print (const ChsAddress &chs)
59: {
60: Print (chs.Cylinder);
61: PrintChar ('/');
62: Print (chs.Head);
63: PrintChar ('/');
64: Print (chs.Sector);
65: }
66:
67:
68: BiosResult ReadWriteSectors (bool write, byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent)
69: {
70: byte cylinderLow = (byte) chs.Cylinder;
71: byte sector = chs.Sector;
72: sector |= byte (chs.Cylinder >> 2) & 0xc0;
73: byte function = write ? 0x03 : 0x02;
74:
75: BiosResult result;
76: __asm
77: {
78: push es
79: mov ax, ds
80: mov es, ax
81: mov bx, ss:buffer
82: mov dl, ss:drive
83: mov ch, ss:cylinderLow
84: mov si, chs
85: mov dh, ss:[si].Head
86: mov cl, ss:sector
87: mov al, ss:sectorCount
88: mov ah, function
89: int 0x13
90: mov result, ah
91: pop es
92: }
93:
94: if (result == BiosResultEccCorrected)
95: result = BiosResultSuccess;
96:
97: if (!silent && result != BiosResultSuccess)
98: PrintDiskError (result, write, drive, nullptr, &chs);
99:
100: return result;
101: }
102:
103:
104: BiosResult ReadSectors (byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent)
105: {
106: return ReadWriteSectors (false, buffer, drive, chs, sectorCount, silent);
107: }
108:
109:
110: BiosResult WriteSectors (byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent)
111: {
112: return ReadWriteSectors (true, buffer, drive, chs, sectorCount, silent);
113: }
114:
115:
116: static BiosResult ReadWriteSectors (bool write, BiosLbaPacket &dapPacket, byte drive, const uint64 §or, uint16 sectorCount, bool silent)
117: {
118: dapPacket.Size = sizeof (dapPacket);
119: dapPacket.Reserved = 0;
120: dapPacket.SectorCount = sectorCount;
121: dapPacket.Sector = sector;
122:
123: byte function = write ? 0x43 : 0x42;
124:
125: BiosResult result;
126: __asm
127: {
128: mov bx, 0x55aa
129: mov dl, drive
130: mov si, [dapPacket]
131: mov ah, function
132: xor al, al
133: int 0x13
134: mov result, ah
135: }
136:
137: if (result == BiosResultEccCorrected)
138: result = BiosResultSuccess;
139:
140: if (!silent && result != BiosResultSuccess)
141: PrintDiskError (result, write, drive, §or);
142:
143: return result;
144: }
145:
146:
147: static BiosResult ReadWriteSectors (bool write, byte *buffer, byte drive, const uint64 §or, uint16 sectorCount, bool silent)
148: {
149: BiosLbaPacket dapPacket;
150: dapPacket.Buffer = (uint32) buffer;
151: return ReadWriteSectors (write, dapPacket, drive, sector, sectorCount, silent);
152: }
153:
154:
155: BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffset, byte drive, const uint64 §or, uint16 sectorCount, bool silent)
156: {
157: BiosLbaPacket dapPacket;
158: dapPacket.Buffer = ((uint32) bufferSegment << 16) | bufferOffset;
159: return ReadWriteSectors (write, dapPacket, drive, sector, sectorCount, silent);
160: }
161:
162:
163: BiosResult ReadSectors (byte *buffer, byte drive, const uint64 §or, uint16 sectorCount, bool silent)
164: {
165: if (IsLbaSupported (drive))
166: return ReadWriteSectors (false, buffer, drive, sector, sectorCount, silent);
167:
168: DriveGeometry geometry;
169:
170: BiosResult result = GetDriveGeometry (drive, geometry, silent);
171: if (result != BiosResultSuccess)
172: return result;
173:
174: ChsAddress chs;
175: LbaToChs (geometry, sector, chs);
176: return ReadWriteSectors (false, buffer, drive, chs, sectorCount, silent);
177: }
178:
179:
180: BiosResult WriteSectors (byte *buffer, byte drive, const uint64 §or, uint16 sectorCount, bool silent)
181: {
182: return ReadWriteSectors (true, buffer, drive, sector, sectorCount, silent);
183: }
184:
185:
186: BiosResult GetDriveGeometry (byte drive, DriveGeometry &geometry, bool silent)
187: {
188: byte maxCylinderLow, maxHead, maxSector;
189: BiosResult result;
190: __asm
191: {
192: push es
193: mov dl, drive
194: mov ah, 0x08
195: int 0x13
196:
197: mov result, ah
198: jc err
199: mov maxCylinderLow, ch
200: mov maxSector, cl
201: mov maxHead, dh
202: err:
203: pop es
204: }
205:
206: if (result == BiosResultSuccess)
207: {
208: geometry.Cylinders = (maxCylinderLow | (uint16 (maxSector & 0xc0) << 2)) + 1;
209: geometry.Heads = maxHead + 1;
210: geometry.Sectors = maxSector & ~0xc0;
211: }
212: else if (!silent)
213: {
214: PrintError ("Cannot get geometry of drive ", true, false);
215: Print (drive);
216: PrintEndl();
217: }
218:
219: return result;
220: }
221:
222:
223: void ChsToLba (const DriveGeometry &geometry, const ChsAddress &chs, uint64 &lba)
224: {
225: lba.HighPart = 0;
226: lba.LowPart = (uint32 (chs.Cylinder) * geometry.Heads + chs.Head) * geometry.Sectors + chs.Sector - 1;
227: }
228:
229:
230: void LbaToChs (const DriveGeometry &geometry, const uint64 &lba, ChsAddress &chs)
231: {
232: chs.Sector = (lba.LowPart % geometry.Sectors) + 1;
233: uint32 ch = lba.LowPart / geometry.Sectors;
234: chs.Head = ch % geometry.Heads;
235: chs.Cylinder = ch / geometry.Heads;
236: }
237:
238:
239: BiosResult ReadMBR (byte drive, MBR &mbr, bool silent)
240: {
241: ChsAddress chs;
242: chs.Cylinder = 0;
243: chs.Head = 0;
244: chs.Sector = 1;
245:
246: return ReadSectors ((byte *) &mbr, drive, chs, 1, silent);
247: }
248:
249:
250: void PartitionEntryMBRToPartition (const PartitionEntryMBR &partEntry, Partition &partition)
251: {
252: partition.Active = partEntry.BootIndicator == 0x80;
253: partition.EndSector.HighPart = 0;
254: partition.EndSector.LowPart = partEntry.StartLBA + partEntry.SectorCountLBA - 1;
255: partition.SectorCount.HighPart = 0;
256: partition.SectorCount.LowPart = partEntry.SectorCountLBA;
257: partition.StartSector.HighPart = 0;
258: partition.StartSector.LowPart = partEntry.StartLBA;
259:
260: partition.StartChsAddress.Cylinder = partEntry.StartCylinder | (uint16 (partEntry.StartCylSector & 0xc0) << 2);
261: partition.StartChsAddress.Head = partEntry.StartHead;
262: partition.StartChsAddress.Sector = partEntry.StartCylSector & ~0xc0;
263:
264: partition.Type = partEntry.Type;
265: }
266:
267:
268: BiosResult GetDrivePartitions (byte drive, Partition *partitionArray, size_t partitionArrayCapacity, size_t &partitionCount, bool activeOnly, bool silent)
269: {
270: MBR mbr;
271: BiosResult result = ReadMBR (drive, mbr, silent);
272: partitionCount = 0;
273:
274: if (result != BiosResultSuccess || mbr.Signature != 0xaa55)
275: return result;
276:
277: size_t partitionArrayPos = 0, partitionNumber;
278:
279: for (partitionNumber = 0;
280: partitionNumber < array_capacity (mbr.Partitions) && partitionArrayPos < partitionArrayCapacity;
281: ++partitionNumber)
282: {
283: const PartitionEntryMBR &partEntry = mbr.Partitions[partitionNumber];
284:
285: if (partEntry.SectorCountLBA > 0)
286: {
287: Partition &partition = partitionArray[partitionArrayPos];
288: PartitionEntryMBRToPartition (partEntry, partition);
289:
290: if (activeOnly && !partition.Active)
291: continue;
292:
293: partition.Drive = drive;
294: partition.Number = partitionNumber;
295:
296: if (partEntry.Type == 0x5 || partEntry.Type == 0xf) // Extended partition
297: {
298: if (IsLbaSupported (drive))
299: {
300: // Find all extended partitions
301: uint64 firstExtStartLBA = partition.StartSector;
302: uint64 extStartLBA = partition.StartSector;
303: MBR extMbr;
304:
305: while (partitionArrayPos < partitionArrayCapacity &&
306: (result = ReadSectors ((byte *) &extMbr, drive, extStartLBA, 1, silent)) == BiosResultSuccess
307: && extMbr.Signature == 0xaa55)
308: {
309: if (extMbr.Partitions[0].SectorCountLBA > 0)
310: {
311: Partition &logPart = partitionArray[partitionArrayPos++];
312: PartitionEntryMBRToPartition (extMbr.Partitions[0], logPart);
313: logPart.Drive = drive;
314:
315: logPart.Number = partitionNumber++;
316: logPart.Primary = false;
317:
318: logPart.StartSector.LowPart += extStartLBA.LowPart;
319: logPart.EndSector.LowPart += extStartLBA.LowPart;
320: }
321:
322: // Secondary extended
323: if (extMbr.Partitions[1].Type != 0x5 && extMbr.Partitions[1].Type == 0xf
324: || extMbr.Partitions[1].SectorCountLBA == 0)
325: break;
326:
327: extStartLBA.LowPart = extMbr.Partitions[1].StartLBA + firstExtStartLBA.LowPart;
328: }
329: }
330: }
331: else
332: {
333: ++partitionArrayPos;
334: partition.Primary = true;
335: }
336: }
337: }
338:
339: partitionCount = partitionArrayPos;
340: return result;
341: }
342:
343:
344: BiosResult GetActivePartition (byte drive, Partition &partition, size_t &partitionCount, bool silent)
345: {
346: return GetDrivePartitions (drive, &partition, 1, partitionCount, true, silent);
347: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.