MLG Namespace Reference

Namespaces
namespace	Entries
namespace	Types

Functions
int	getSdCardFieldsCount ()
static constexpr uint16_t	computeFieldsRecordLength ()
static size_t	writeFileHeader (Writer &outBuffer)
static size_t	writeSdBlock (Writer &outBuffer)
size_t	writeSdLogLine (Writer &bufferedWriter)
void	resetFileLogging ()

Variables
static uint64_t	binaryLogCount = 0
static const uint16_t	recordLength = computeFieldsRecordLength()
static uint8_t	blockRollCounter = 0

Function Documentation

computeFieldsRecordLength()

static constexpr uint16_t MLG::computeFieldsRecordLength ( )

staticconstexpr

Definition at line 43 of file binary_mlg_logging.cpp.

                                                      {
    uint16_t recLength = 0;
    for (size_t i = 0; i < efi::size(fields); i++) {
        recLength += fields[i].getSize();
    }
 
    return recLength;
}

Here is the call graph for this function:

getSdCardFieldsCount()

int MLG::getSdCardFieldsCount

(

)

Definition at line 39 of file binary_mlg_logging.cpp.

                           {
    return efi::size(fields);
}

Referenced by sdStatistics().

Here is the caller graph for this function:

resetFileLogging()

void MLG::resetFileLogging

(

)

Definition at line 199 of file binary_mlg_logging.cpp.

                        {
    binaryLogCount = 0;
    blockRollCounter = 0;
}

Referenced by sdLogger().

Here is the caller graph for this function:

writeFileHeader()

static size_t MLG::writeFileHeader ( Writer &  outBuffer )

static

Definition at line 56 of file binary_mlg_logging.cpp.

                                                 {
    size_t writen = 0;
    char buffer[Types::Header::Size];
    // File format: MLVLG\0
    strncpy(buffer, "MLVLG", 6);
 
    // Format version = 02
    buffer[6] = 0;
    buffer[7] = 2;
 
    // Timestamp
    buffer[8] = 0;
    buffer[9] = 0;
    buffer[10] = 0;
    buffer[11] = 0;
 
    // Info data start
    buffer[12] = 0;
    buffer[13] = 0;
    buffer[14] = 0;
    buffer[15] = 0;
 
    size_t headerSize = Types::Header::Size + efi::size(fields) * Types::Field::DescriptorSize;
 
    // Data begin index: begins immediately after the header
    buffer[16] = (headerSize >> 24) & 0xFF;
    buffer[17] = (headerSize >> 16) & 0xFF;
    buffer[18] = (headerSize >> 8) & 0xFF;
    buffer[19] = headerSize & 0xFF;
 
    // Record length - length of a single data record: sum size of all fields
    buffer[20] = recordLength >> 8;
    buffer[21] = recordLength & 0xFF;
 
    // Number of logger fields
    int fieldsCount = efi::size(fields);
    buffer[22] = fieldsCount >> 8;
    buffer[23] = fieldsCount;
 
    outBuffer.write(buffer, Types::Header::Size);
    writen += Types::Header::Size;
 
    // Write the actual logger fields, offset by header size (24)
    for (size_t i = 0; i < efi::size(fields); i++) {
        writen += fields[i].writeHeader(outBuffer);
    }
 
    return writen;
}

Referenced by writeSdLogLine().

Here is the call graph for this function:

Here is the caller graph for this function:

writeSdBlock()

static size_t MLG::writeSdBlock ( Writer &  outBuffer )

static

Definition at line 108 of file binary_mlg_logging.cpp.

                                              {
    size_t writen = 0;
    static char buffer[16];
 
    // Offset 0 = Block type, standard data block in this case
    buffer[0] = 0;
 
    // Offset 1 = rolling counter sequence number
    buffer[1] = blockRollCounter++;
 
    // Offset 2, size 2 = Timestamp at 10us resolution
    efitimeus_t nowUs = getTimeNowUs();
    uint16_t timestamp = nowUs / 10;
    buffer[2] = timestamp >> 8;
    buffer[3] = timestamp & 0xFF;
 
    // TODO: check ret value!
    outBuffer.write(buffer, 4);
    writen += 4;
 
    // todo: add a log field for SD card period
    // revSdCardLineTime = nowUs;
 
    packedTime = getTimeNowMs() * 1.0 / TIME_PRECISION;
 
    uint8_t sum = 0;
    for (size_t fieldIndex = 0; fieldIndex < efi::size(fields); fieldIndex++) {
        #if EFI_UNIT_TEST
            if (engine == nullptr) {
                throw std::runtime_error{"Engine pointer is nullptr in writeSdBlock"};
            }
 
            // For tests a global Engine pointer is initialised with the nullptr, and tests that do require it
            // create their own instance and set up the global pointer accordingly.
            // Global static const array of fields in the generated file log_fields_generated.h has fields with
            // addresses const-evaluated against 'nullptr' engine, which effectively means offsets in Engine struct,
            // so if that is the case, we need to account for the offset to whatever
            // real current engine pointer is set to.
            // In tests, we are dealing with ELF on linux, and as far as I'm aware, there are no distributions
            // where the default linker config can map smth before the 4 MB address.
            // If in doubt, check your system for a min text-segment with "ld --verbose | grep -A20 ENTRY"
            // Engine struct is lower than 4MB in size, so we can compare field address against Engine size
            // to find out whether field address was initialised against nullptr engine or not.
 
            constexpr auto engineObjectSize{ sizeof(Engine) };
            static_assert(engineObjectSize < 0x400000);
 
            auto const currentFieldAddress{ reinterpret_cast<uintptr_t>(fields[fieldIndex].getAddr()) };
            auto const fieldNeedsOffset{ currentFieldAddress < engineObjectSize };
            void* const offset{ fieldNeedsOffset ? engine : nullptr };
        #else
            void* const offset{ nullptr };
        #endif
 
        size_t entrySize = fields[fieldIndex].writeData(buffer, offset);
 
        for (size_t byteIndex = 0; byteIndex < entrySize; byteIndex++) {
            // "CRC" at the end is just the sum of all bytes
            sum += buffer[byteIndex];
        }
        // TODO: check ret value!
        outBuffer.write(buffer, entrySize);
        writen += entrySize;
    }
 
    buffer[0] = sum;
    // 1 byte checksum footer
    outBuffer.write(buffer, 1);
    writen += 1;
 
    return writen;
}

Referenced by writeSdLogLine().

Here is the call graph for this function:

Here is the caller graph for this function:

writeSdLogLine()

size_t MLG::writeSdLogLine

(

Writer &

bufferedWriter

)

Definition at line 181 of file binary_mlg_logging.cpp.

                                              {
#if EFI_PROD_CODE
    if (!main_loop_started)
        return 0;
#endif //EFI_PROD_CODE
 
    if (binaryLogCount == 0) {
        binaryLogCount++;
 
        return writeFileHeader(bufferedWriter);
    } else {
        binaryLogCount++;
 
        updateTunerStudioState();
        return writeSdBlock(bufferedWriter);
    }
}

Referenced by mlgLogger().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

binaryLogCount

uint64_t MLG::binaryLogCount = 0

static

Definition at line 52 of file binary_mlg_logging.cpp.

Referenced by resetFileLogging(), and writeSdLogLine().

blockRollCounter

uint8_t MLG::blockRollCounter = 0

static

Definition at line 106 of file binary_mlg_logging.cpp.

Referenced by resetFileLogging(), and writeSdBlock().

recordLength

const uint16_t MLG::recordLength = computeFieldsRecordLength()

static

Definition at line 54 of file binary_mlg_logging.cpp.

Referenced by writeFileHeader().