Return to bootdebug.cpp CVS log

Up to [truecrypt] / truecrypt / boot / windows

Annotation of truecrypt/boot/windows/bootdebug.cpp, revision 1.1

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 "Platform.h"
        !            10: #include "Bios.h"
        !            11: #include "BootConsoleIo.h"
        !            12: #include "BootDiskIo.h"
        !            13: #include "BootDebug.h"
        !            14: 
        !            15: 
        !            16: void InitDebugPort ()
        !            17: {
        !            18:        __asm
        !            19:        {
        !            20:                mov dx, TC_DEBUG_PORT
        !            21:                mov ah, 1
        !            22:                int 0x17
        !            23:                mov dx, TC_DEBUG_PORT
        !            24:                mov ah, 0xe2
        !            25:                int 0x17
        !            26:        }
        !            27: }
        !            28: 
        !            29: 
        !            30: void WriteDebugPort (byte dataByte)
        !            31: {
        !            32:        __asm
        !            33:        {
        !            34:                mov al, dataByte
        !            35:                mov dx, TC_DEBUG_PORT
        !            36:                mov ah, 0
        !            37:                int 0x17
        !            38:        }
        !            39: }
        !            40: 
        !            41: 
        !            42: extern "C" void PrintDebug (uint32 debugVal)
        !            43: {
        !            44:        Print (debugVal);
        !            45:        PrintEndl();
        !            46: }
        !            47: 
        !            48: 
        !            49: void PrintAddress (void *addr)
        !            50: {
        !            51:        uint16 segment = uint16 (uint32 (addr) >> 16);
        !            52:        uint16 offset = uint16 (addr);
        !            53: 
        !            54:        PrintHex (segment);
        !            55:        PrintChar (':');
        !            56:        PrintHex (offset);
        !            57:        Print (" (");
        !            58:        PrintHex (GetLinearAddress (segment, offset));
        !            59:        Print (")");
        !            60: }
        !            61: 
        !            62: 
        !            63: void PrintVal (const char *message, const uint32 value, bool newLine, bool hex)
        !            64: {
        !            65:        Print (message);
        !            66:        Print (": ");
        !            67:        
        !            68:        if (hex)
        !            69:                PrintHex (value);
        !            70:        else
        !            71:                Print (value);
        !            72:        
        !            73:        if (newLine)
        !            74:                PrintEndl();
        !            75: }
        !            76: 
        !            77: 
        !            78: void PrintVal (const char *message, const uint64 &value, bool newLine, bool hex)
        !            79: {
        !            80:        Print (message);
        !            81:        Print (": ");
        !            82:        PrintHex (value);
        !            83:        if (newLine)
        !            84:                PrintEndl();
        !            85: }
        !            86: 
        !            87: 
        !            88: void PrintHexDump (byte *mem, size_t size, uint16 *memSegment)
        !            89: {
        !            90:        const size_t width = 16;
        !            91:        for (size_t pos = 0; pos < size; )
        !            92:        {
        !            93:                for (int pass = 1; pass <= 2; ++pass)
        !            94:                {
        !            95:                        size_t i;
        !            96:                        for (i = 0; i < width && pos < size; ++i)
        !            97:                        {
        !            98:                                byte dataByte;
        !            99:                                if (memSegment)
        !           100:                                {
        !           101:                                        __asm
        !           102:                                        {
        !           103:                                                push es
        !           104:                                                mov si, ss:memSegment
        !           105:                                                mov es, ss:[si]
        !           106:                                                mov si, ss:mem
        !           107:                                                add si, pos
        !           108:                                                mov al, es:[si]
        !           109:                                                mov dataByte, al
        !           110:                                                pop es
        !           111:                                        }
        !           112:                                        pos++;
        !           113:                                }
        !           114:                                else
        !           115:                                        dataByte = mem[pos++];
        !           116: 
        !           117:                                if (pass == 1)
        !           118:                                {
        !           119:                                        PrintHex (dataByte);
        !           120:                                        PrintChar (' ');
        !           121:                                }
        !           122:                                else
        !           123:                                        PrintChar (IsPrintable (dataByte) ? dataByte : '.');
        !           124:                        }
        !           125: 
        !           126:                        if (pass == 1)
        !           127:                        {
        !           128:                                pos -= i;
        !           129:                                PrintChar (' ');
        !           130:                        }
        !           131:                }
        !           132: 
        !           133:                PrintEndl ();
        !           134:        }
        !           135: }
        !           136: 
        !           137: 
        !           138: void PrintHexDump (uint16 memSegment, uint16 memOffset, size_t size)
        !           139: {
        !           140:        PrintHexDump ((byte *) memOffset, size, &memSegment);
        !           141: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.