/////////////////////////////////////////////////////////////////////////////
//
//  log.cpp - Extension to find parse Singularity trace log.
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
#include "singx86.h"

bool fCachedLogStateValid = false;

static ULONG64 c_txtBegin   = 0;
static ULONG64 c_txtLimit   = 0;
static ULONG64 c_txtHead    = 0;
static ULONG64 c_logBegin   = 0;
static ULONG64 c_logLimit   = 0;
static ULONG64 c_logHead    = 0;
static LONG    c_logHeadPos = 0;
static LONG    c_logCount   = 0;

static ULONG64 c_tscOffsets = 0;

static bool    difftsc              = true;
static ULONG64 tsc                  = 0;
static bool    filter_by_cpu        = false;
static bool    filter_by_process    = false;
static bool    filter_by_thread     = false;
static bool    filter_by_tag        = false;
static int     filter_by_class      = 0;
static int     filter_by_not_class  = 0;
static int     filter_by_method     = false;
static int     filter_by_not_method = false;
static bool    filter_by_severity   = false;
static LONG    filter_range_low     = 0;
static LONG    filter_range_high    = 0;

static int filter_cpu     = 0;
static int filter_process = 0;
static int filter_thread  = 0;
static int filter_tag     = 0;
static char filter_class[16][128];
static int filter_class_wild[16];
static bool filter_class_not[16];
static char filter_method[16][128];
static int filter_method_wild[16];
static bool filter_method_not[16];
static int filter_severity = 0;

static char szSymbol[512];
static char *pszSymbol;
static char *pszClass;
static char *pszMethod;

//////////////////////////////////////////////////////////////////////////////
//
static HRESULT Usage()
{
    ExtOut("Usage:\n"
           "    !log {options} {entry}\n"
           "    !log clear\n"
           "Options:\n"
           "    -a                : Print all matching entries.\n"
           "    -c class          : Filter by class (can use tail wild card like `cl*').\n"
           "    -nc class         : Filter out class (can use tail wild card).\n"
           "    -m method         : Filter by method (can use tail wild card).\n"
           "    -nc method        : Filter out method (can use tail wild card).\n"
           "    -p pid            : Filter by process ID.\n"
           "    -t tid            : Filter by thread ID.\n"
           "    -u cpuid          : Filter by cpu ID.\n"
           "    -x tag            : Filter by tag.\n"
           "    -s severity       : Filter by severity.\n"
           "    -r begin[,number] : Filter by range of entry ids.\n"
           "    -n [skip,]number  : Print at most `number' entries (default is 10).\n"
           "    -f                : Display full timespaces instead of indexes and diffs.\n"
           "    -q                : Quiet, not class and method.\n"
           "Examples:\n"
           "    !log -c timer* -d            : Print last entries from timer* class with diffs.\n"
           "    !log -a -c timer* -c irq*    : Print all timer or irq entries.\n"
           "    !log -n 15 -p 020            : Print last 15 entries for process 020.\n"
           "    !log -n 5,10                 : Print the first 10 of the last 15.\n"
           "    !log -c t* -nc ti*           : Print class entries starting with t, but not ti.\n"
           "    !log clear                   : Clear the log.\n"
           "Notes:\n"
           "    Log index numbers count backwards in time from 0.\n"
           "    0 is the most recent log entry, 1 the entry before that, etc.\n"
           "    The -c and -m filters are applied first, followed by -nc and -nm filters.\n"
           "    String and method name comparisons are case insensitive.\n"
          );
    return S_FALSE;
}

HRESULT DumpLogHead(bool detail)
{
    if (detail) {
        ExtOut("     Cycle Count: CPU   EIP    PID TID TAG S Class.Method             : Message\n");
    }
    else {
        ExtOut("     Cycle Count: CPU   EIP    PID TID TAG S: Message\n");
    }
    return S_OK;
}

HRESULT FindBound(const char *symbol, ULONG64 *ptrval)
{
    HRESULT status = S_OK;
    ULONG64 address;

    EXT_CHECK(g_ExtSymbols->GetOffsetByName(symbol, &address));
    EXT_CHECK(g_ExtData->ReadPointersVirtual(1, address, ptrval));

    ExtVerb("Find(%s) = %p\n", symbol, *ptrval);
  Exit:
    return status;
}

HRESULT SetBound(const char *symbol, ULONG64 ptrval)
{
    HRESULT status = S_OK;
    ULONG64 address;

    EXT_CHECK(g_ExtSymbols->GetOffsetByName(symbol, &address));
    EXT_CHECK(g_ExtData->WritePointersVirtual(1, address, &ptrval));
  Exit:
    return status;
}

HRESULT FindBounds()
{
    HRESULT status = S_OK;

    if (!fCachedLogStateValid) {

        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_txtBegin",
                            &c_txtBegin));
        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_txtLimit",
                            &c_txtLimit));
        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_txtHead",
                            &c_txtHead));

        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_logBegin",
                            &c_logBegin));
        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_logLimit",
                            &c_logLimit));
        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_logHead",
                            &c_logHead));
        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_logHead",
                            &c_logHead));
        EXT_CHECK(FindBound("nt!Class_Microsoft_Singularity_Tracing::c_tscOffsets",
                            &c_tscOffsets));

        c_logHeadPos = (LONG)((c_logHead - c_logBegin) / LogEntryStruct.size);
        c_logCount = (LONG)((c_logLimit - c_logBegin) / LogEntryStruct.size);

        fCachedLogStateValid = true;
        status = S_OK;
    }

  Exit:
    return status;
}

static LONG64 GetTscOffset(int cpuId, PLONG64 pValue)
{
    HRESULT status = S_OK;

    ULONG64 address = c_tscOffsets + cpuId * sizeof(LONG64);
    EXT_CHECK(g_ExtData->ReadPointersVirtual(1, address, (PULONG64)pValue));
    // ExtOut("Cpu %d tscOffset %I64d\n", cpuId, *pValue);
  Exit:
    return status;
}

static ULONG64 IdToEntry(LONG id)
{
    LONG pos = (c_logHeadPos + (c_logCount - (id + 1))) % c_logCount;
    ULONG64 entry = c_logBegin + pos * LogEntryStruct.size;
    return entry;
}

static LONG EntryToId(ULONG64 entry)
{
    LONG pos = (ULONG)((entry - c_logBegin) / LogEntryStruct.size);
    return ((c_logCount - (pos + 1)) + c_logHeadPos) % c_logCount;
}

HRESULT FilterLogEntry(LONG id, LogEntry& log, bool detail)
{
    pszSymbol = NULL;
    pszClass = NULL;
    pszMethod = NULL;

    HRESULT status = S_OK;

    if ((ULONG64)log._text < c_txtBegin || (ULONG64)log._text > c_txtLimit) {
        return S_FALSE;
    }
    if (id < filter_range_low || id >= filter_range_high) {
        return S_FALSE;
    }
    if (filter_by_cpu && log._cpuId != filter_cpu) {
        return S_FALSE;
    }
    if (filter_by_process && log._processId != filter_process) {
        return S_FALSE;
    }
    if (filter_by_thread && log._threadId != filter_thread) {
        return S_FALSE;
    }
    if (filter_by_tag && log._tag != filter_tag) {
        return S_FALSE;
    }
    if (filter_by_severity && log._severity < filter_process) {
        return S_FALSE;
    }

    if (filter_by_class > 0 || filter_by_method > 0 || detail) {
        ULONG64 displacement = 0;

        status = g_ExtSymbols->GetNameByOffset((ULONG64)log._eip,
                                               szSymbol,
                                               arrayof(szSymbol),
                                               NULL,
                                               &displacement);
        if (status == S_OK) {
            CHAR *p;
            pszSymbol = szSymbol;

            if ((p = strrchr(szSymbol, '!')) != NULL) {
                pszSymbol = p + 1;
            }
            if ((p = strchr(szSymbol, ':')) != NULL && p[1] == ':') {
                pszClass = pszSymbol;
                pszMethod = p + 2;
                *p = '\0';

                if ((p = strrchr(pszClass, '_')) != NULL) {
                    pszClass = p + 1;
                }
                if ((p = strrchr(pszMethod, '_')) != NULL) {
                    pszMethod = p + 1;
                }
            }
        }

        PCHAR pszC = pszClass != NULL ? pszClass : (pszSymbol != NULL ? pszSymbol : "::");
        PCHAR pszM = pszMethod ? pszMethod : "::";

        // Do inclusive filters first.
        if (filter_by_class > filter_by_not_class) {
            bool found = false;
            for (int i = 0; i < filter_by_class; i++) {
                if (filter_class_not[i]) {
                    continue;
                }
                if (filter_class_wild[i] > 0) {
                    if (_strnicmp(filter_class[i], pszC, filter_class_wild[i]) == 0) {
                        found = true;
                        break;
                    }
                }
                else {
                    if (_strcmpi(filter_class[i], pszC) == 0) {
                        found = true;
                        break;
                    }
                }
            }
            if (!found) {
                return S_FALSE;
            }
        }
        if (filter_by_method > filter_by_not_method) {
            if (pszMethod == NULL) {
                return S_FALSE;
            }
            bool found = false;
            for (int i = 0; i < filter_by_method; i++) {
                if (filter_method_not[i]) {
                    continue;
                }
                if (filter_method_wild[i] > 0) {
                    if (_strnicmp(filter_method[i], pszM, filter_method_wild[i]) == 0) {
                        found = true;
                        break;
                    }
                }
                else {
                    if (_strcmpi(filter_method[i], pszM) == 0) {
                        found = true;
                        break;
                    }
                }
            }
            if (!found) {
                return S_FALSE;
            }
        }

        // Then do exclusive filters.
        if (filter_by_not_class > 0) {
            for (int i = 0; i < filter_by_class; i++) {
                if (!filter_class_not[i]) {
                    continue;
                }
                if (filter_class_wild[i] > 0) {
                    if (_strnicmp(filter_class[i], pszC, filter_class_wild[i]) == 0) {
                        return S_FALSE;
                    }
                }
                else {
                    if (_strcmpi(filter_class[i], pszC) == 0) {
                        return S_FALSE;
                    }
                }
            }
        }
        if (filter_by_not_method > 0) {
            for (int i = 0; i < filter_by_method; i++) {
                if (!filter_method_not[i]) {
                    continue;
                }
                if (filter_method_wild[i] > 0) {
                    if (_strnicmp(filter_method[i], pszM, filter_method_wild[i]) == 0) {
                        return S_FALSE;
                    }
                }
                else {
                    if (_strcmpi(filter_method[i], pszM) == 0) {
                        return S_FALSE;
                    }
                }
            }
        }
    }
    return S_OK;
}

static PCHAR Skip(PCHAR psz)
{
    while (*psz) {
        psz++;
    }
    return psz + 1;
}


HRESULT DumpLogEntry(LONG id, LogEntry& log, bool detail)
{
    HRESULT status = S_OK;

    CHAR msg[512];
    BYTE text[256];
    ULONG ret;
    EXT_CHECK(g_ExtData->ReadVirtual((ULONG64)log._text, text, sizeof(text), &ret));
    if (text[0] != (BYTE)log._cycleCount) {
        sprintf(msg, "<%p: message not available>", log._text);
    }
    else {
        CHAR *  pmsg = msg;
        CHAR *  ptxt = (CHAR *)(text + 1);
        CHAR *  sargs[6];
        CHAR *  pstr = Skip(ptxt);

        for (int i = 0 ; i < arrayof(sargs); i++) {
            if ((log._strings & ((ULONG64)1 << i)) != 0) {
                sargs[i] = pstr;
                pstr = Skip(pstr);
            }
            else {
                sargs[i] = NULL;
            }
        }

        while (*ptxt != '\0') {
            if (*ptxt == '{') {
                char * pbeg = ptxt;
                bool bad = false;
                ptxt++;

                int ndx = 0;
                int aln = 0;
                int wid = 0;
                char fmt = 'd';

                if (*ptxt == '{') {
                    *pmsg++ = *ptxt++;
                }
                else if (*ptxt >= '0' && *ptxt <= '9') {

                    // {index,alignment:type width}
                    // Get Index
                    while (*ptxt >= '0' && *ptxt <= '9') {
                        ndx = ndx * 10 + (*ptxt++ - '0');
                    }

                    // Get Alignment
                    if (*ptxt == ',') {
                        ptxt++;
                        while (*ptxt >= '0' && *ptxt <= '9') {
                            aln = aln * 10 + (*ptxt++ - '0');
                        }
                    }

                    // Get FormatString
                    if (*ptxt == ':') {
                        ptxt++;
                        if (*ptxt >= 'a' && *ptxt <= 'z') {
                            fmt = *ptxt++;
                        }
                        else if (*ptxt >= 'A' && *ptxt <= 'Z') {
                            fmt = *ptxt++ - 'A' + 'a';
                        }
                        while (*ptxt >= '0' && *ptxt <= '9') {
                            wid = wid * 10 + (*ptxt++ - '0');
                        }
                    }

                    // Get closing brace.
                    if (*ptxt == '}') {
                        ptxt++;
                    }
                    else {
                        bad = true;
                        ExtErr("Missing closing brace: `%s'\n", ptxt);
                    }

                    if (ndx >= arrayof(sargs)) {
                        bad = true;
                        ExtErr("Aln too large: %d\n", ndx);
                    }

                    if (sargs[ndx] != NULL) {
                        if (wid > 0) {
                            if (aln < wid) {
                                aln = wid;
                            }
                            pmsg += sprintf(pmsg, "%*.*s", aln, wid, sargs[ndx]);
                        }
                        else {
                            pmsg += sprintf(pmsg, "%*s", aln, sargs[ndx]);
                        }
                    }
                    else {
                        if (aln < wid) {
                            aln = wid;
                        }
                        if (fmt == 'x') {
                            if (wid > 0) {
                                pmsg += sprintf(pmsg, "%0*x", aln, log._args[ndx]);
                            }
                            else {
                                pmsg += sprintf(pmsg, "%*x", aln, log._args[ndx]);
                            }
                        }
                        else {
                            pmsg += sprintf(pmsg, "%*d", aln, log._args[ndx]);
                        }
                    }

                    // If the format was bad, then copy it.
                    if (bad) {
                        ExtErr("Format error: `%*s'\n", ptxt - pbeg, pbeg);
                        while (pbeg < ptxt) {
                            *pmsg++ = *pbeg++;
                        }
                    }
                }
            }
            else if (*ptxt == '}') {
                ptxt++;
                *pmsg++ = *ptxt++;
            }
            else if (*ptxt == '\n') {
                ptxt++;
            }
            else {
                *pmsg++ = *ptxt++;
            }
        }
        *pmsg++ = '\0';
    }

    LONG64 tscOffset = 0;
    if (GetTscOffset((int)log._cpuId, &tscOffset) != S_OK) {
        tscOffset = 0;
    }

    ULONG64 cycleCount = log._cycleCount - tscOffset;
    if (difftsc) {
        if (tsc == 0) {
            ExtOut("%16I64x: ", cycleCount);
        }
        else {
            ExtOut("%5d: %9I64x+ ", id, cycleCount - tsc);
        }
    }
    else {
        ExtOut("%16I64x: ", cycleCount);
    }
    tsc = cycleCount;

    if (detail) {
        CHAR name[512] = "";

        if (pszClass != NULL && pszMethod != NULL) {
            sprintf(name, "%s.%s", pszClass, pszMethod);
        }
        else if (pszSymbol != NULL) {
            strcat(name, pszSymbol);
        }

        ExtOut("%03x %p %03x %03x %03x %x %-25.25s: %s\n",
               (ULONG)log._cpuId,
               log._eip,
               (ULONG)log._processId,
               (ULONG)log._threadId,
               (ULONG)log._tag,
               (ULONG)log._severity,
               name,
               msg);
    }
    else {
        ExtOut("%03x %p %03x %03x %03x %x: %s\n",
               (ULONG)log._cpuId,
               log._eip,
               (ULONG)log._processId,
               (ULONG)log._threadId,
               (ULONG)log._tag,
               (ULONG)log._severity,
               msg);
    }

    status = S_OK;
  Exit:
    return status;
}

HRESULT ClearLog()
{
    HRESULT status = S_OK;

    ExtOut("Clearing %p..%p\n", c_logBegin, c_logLimit);
    LogEntryStruct.Clear();
    for (ULONG64 entry = c_logBegin; entry < c_logLimit; entry += LogEntryStruct.size) {
        if ((entry & 0xff) == 0) {
            ExtOut(" %p\r", entry);
        }
        EXT_CHECK(LogEntryStruct.Flush(entry));
    }
    ExtOut("\n");
    EXT_CHECK(SetBound("nt!Class_Microsoft_Singularity_Tracing::c_txtHead", c_txtBegin));
    EXT_CHECK(SetBound("nt!Class_Microsoft_Singularity_Tracing::c_logHead", c_logBegin));

  Exit:
    return status;
}

static ULONG64 GetValue(PCSTR& args, bool fHex)
{
    ULONG base = fHex ? 16 : 10;
    if (*args == '0') {
        fHex = true;
        base = 16;
    }
    ULONG64 value = 0;

    while (*args && *args != ' ' && *args != '\t') {
        if (*args >= '0' && *args <= '9') {
            value = value * base + (*args++ - '0');
        }
        else if (*args >= 'A' && *args <= 'F' && fHex) {
            value = value * base + (*args++ - 'A') + 10;
        }
        else if (*args >= 'a' && *args <= 'f' && fHex) {
            value = value * base + (*args++ - 'a') + 10;
        }
        else {
            break;
        }
    }
    return value;
}

EXT_DECL(log) // Defines: PDEBUG_CLIENT Client, PCSTR args
{
    EXT_ENTER();    // Defines: HRESULT status = S_OK;
    bool detail = true;
    bool doall = false;

    status = FindBounds();

#if TEST_ENTRY
    if (fCachedLogStateValid) {
        for (LONG id = 0; id < 10; id++) {
            ULONG64 entry = IdToEntry(id);
            ULONG bid = EntryToId(entry);
            ExtOut("%4d: %p :%4d\n", id, entry, bid);
        }
        for (LONG id = c_logCount - 10; id < c_logCount; id++) {
            ULONG64 entry = IdToEntry(id);
            ULONG bid = EntryToId(entry);
            ExtOut("%4d: %p :%4d\n", id, entry, bid);
        }
        goto Exit;
    }
#endif

    difftsc = true;

    filter_range_low  = 0;
    filter_range_high = c_logCount;

    filter_by_cpu        = false;
    filter_by_process    = false;
    filter_by_thread     = false;
    filter_by_tag        = false;
    filter_by_class      = 0;
    filter_by_not_class  = 0;
    filter_by_method     = 0;
    filter_by_not_method = 0;
    filter_by_severity   = false;

    filter_cpu      = 0;
    filter_process  = 0;
    filter_thread   = 0;
    filter_tag      = 0;
    filter_severity = 0;

    int limit = 10;
    int skip = 0;
    char *p;

    tsc = 0;
    if (_strcmpi(args, "clear") == 0) {
        return ClearLog();
    }

    while (*args != '\0') {
        // skip whitespace
        while (*args == ' ' || *args == '\t') {
            args++;
        }

        // process argument
        if (*args == '-' || *args == '/') {
            args++;
            switch (*args++) {
              case 'q': // Quiet
              case 'Q':
                detail = false;
                break;

              case 'f': // Full timestamps, not diffs (not absolute value)
              case 'F':
                difftsc = false;
                break;

              case 'a': // All records
              case 'A':
                doall = true;
                limit = 100000;
                break;

              case 'n':
              case 'N':
                if (*args == 'c') {
                    // Not class
                    args++;
                    while (*args == ' ' || *args == '\t') {
                        args++;
                    }
                    filter_class[filter_by_class][0] = '\0';
                    filter_class_wild[filter_by_class] = 0;
                    filter_class_not[filter_by_class] = true;
                    p = filter_class[filter_by_class];
                    while (*args && *args != ' ' && *args != '\t') {
                        *p++ = *args++;
                    }
                    *p = '\0';
                    if ((p = strchr(filter_class[filter_by_class], '*')) != NULL) {
                        filter_class_wild[filter_by_class] = p - filter_class[filter_by_class];
                    }
                    ExtVerb("Filter out class: `%s'\n", filter_class[filter_by_class]);
                    filter_by_class++;
                    filter_by_not_class++;
                }
                else if (*args == 'm') {
                    // Not method
                    args++;
                    while (*args == ' ' || *args == '\t') {
                        args++;
                    }
                    filter_method[filter_by_method][0] = '\0';
                    filter_method_wild[filter_by_method] = 0;
                    filter_method_not[filter_by_method] = true;
                    p = filter_method[filter_by_method];
                    while (*args && *args != ' ' && *args != '\t') {
                        *p++ = *args++;
                    }
                    *p = '\0';
                    if ((p = strchr(filter_method[filter_by_method], '*')) != NULL) {
                        filter_method_wild[filter_by_method] = p - filter_method[filter_by_method];
                    }
                    ExtVerb("Filter not method: `%s'\n", filter_method[filter_by_method]);
                    filter_by_method++;
                    filter_by_not_method++;
                }
                else {
                    // Number of entries to display
                    while (*args == ' ' || *args == '\t') {
                        args++;
                    }
                    limit = (int)GetValue(args, false);
                    if (*args == ',') {
                        skip = limit;
                        args++;
                        limit = (int)GetValue(args, false);
                    }
                    ExtVerb("Limit to: %d (skip %d)\n", limit, skip);
                }
                break;

              case 'r': // filter by range
              case 'R':
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_range_low = (LONG)GetValue(args, false);
                if (filter_range_low < 0) {
                    filter_range_low = 0;
                }
                if (filter_range_low >= c_logCount) {
                    filter_range_low = c_logCount - 1;
                }
                if (*args == ',') {
                    args++;
                    filter_range_high = filter_range_low + (LONG)GetValue(args, false);
                    if (filter_range_high > c_logCount) {
                        filter_range_high = c_logCount;
                    }
                }
                ExtVerb("Range %d..%d\n", filter_range_low, filter_range_high);
                break;

              case 'u': // filter by cpu
              case 'U':
                filter_by_cpu = true;
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_cpu = (int)GetValue(args, true);
                ExtVerb("Filter by cpu: 0x%x\n", filter_cpu);
                break;

              case 'p': // filter by process
              case 'P':
                filter_by_process = true;
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_process = (int)GetValue(args, true);
                ExtVerb("Filter by process: 0x%x\n", filter_process);
                break;

              case 't': // filter by thread
              case 'T':
                filter_by_thread = true;
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_thread = (int)GetValue(args, true);
                ExtVerb("Filter by tid: 0x%x\n", filter_thread);
                break;

              case 'x': // filter by tag
              case 'X':
                filter_by_tag = true;
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_tag = (int)GetValue(args, true);
                ExtVerb("Filter by tag: 0x%x\n", filter_tag);
                break;

              case 'c': // filter by class
              case 'C':
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_class[filter_by_class][0] = '\0';
                filter_class_wild[filter_by_class] = 0;
                filter_class_not[filter_by_class] = false;
                p = filter_class[filter_by_class];
                while (*args && *args != ' ' && *args != '\t') {
                    *p++ = *args++;
                }
                *p = '\0';
                if ((p = strchr(filter_class[filter_by_class], '*')) != NULL) {
                    filter_class_wild[filter_by_class] = p - filter_class[filter_by_class];
                }
                ExtVerb("Filter by class: `%s'\n", filter_class[filter_by_class]);
                filter_by_class++;
                break;

              case 'm': // filter by method
              case 'M':
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_method[filter_by_method][0] = '\0';
                filter_method_wild[filter_by_method] = 0;
                filter_method_not[filter_by_method] = false;
                p = filter_method[filter_by_method];
                while (*args && *args != ' ' && *args != '\t') {
                    *p++ = *args++;
                }
                *p = '\0';
                if ((p = strchr(filter_method[filter_by_method], '*')) != NULL) {
                    filter_method_wild[filter_by_method] = p - filter_method[filter_by_method];
                }
                ExtVerb("Filter by method: `%s'\n", filter_method[filter_by_method]);
                filter_by_method++;
                break;

              case 's': // filter by severity
              case 'S':
                filter_by_severity = true;
                while (*args == ' ' || *args == '\t') {
                    args++;
                }
                filter_severity = (int)GetValue(args, true);
                break;

              case '?': // Help
              case 'h':
              case 'H':
                status = Usage();
                goto Exit;
            }
            while (*args && *args != ' ') {
                args++;
            }
        }
        else {
            break;
        }
    }

    DumpLogHead(detail);

    ULONG64 entry = 0;
    LogEntry log;

    if (*args != '\0') {
        status = ExtEvalU64(&args, &entry);
        if (status == S_OK) {
            if (entry < c_logBegin || entry >= c_logLimit) {
                ExtErr("Entry value %p not supported.\n", entry);
                return S_FALSE;
            }
            EXT_CHECK(LogEntryStruct.Read(entry, &log));
            LONG id = EntryToId(entry);
            status = FilterLogEntry(id, log, detail);
            status = DumpLogEntry(id, log, detail);
            goto Exit;
        }
        else {
            ExtErr("Invalid argument %s.\n", args);
            goto Exit;
        }
    }

    ExtVerb("Range [%d..%d], Skip=%d, Limit=%d\n",
            filter_range_low, filter_range_high, skip, limit);

    // First, we search backward until we find the right number of records
    if (!doall) {
        int find = limit + skip;
        for (LONG id = filter_range_low; id < filter_range_high; id++) {
            entry = IdToEntry(id);

            EXT_CHECK(LogEntryStruct.Read(entry, &log));
            if (log._eip == 0 || log._cycleCount == 0) {
                continue;
            }

            status = FilterLogEntry(id, log, detail);
            if (status == S_OK) {
                find--;
                if (find < 0) {
                    filter_range_high = id;
                    break;
                }
            }
        }
    }
    ExtVerb("Begin: %p, Head: %p, Limit: %p, Base: %p [%d..%d]\n",
            c_logBegin, c_logHead, c_logLimit, entry, filter_range_low, filter_range_high);

    for (LONG id = filter_range_high - 1; id >= filter_range_low; id--) {
        entry = IdToEntry(id);

        EXT_CHECK(LogEntryStruct.Read(entry, &log));
        if (log._eip == 0 || log._cycleCount == 0) {
            continue;
        }

        status = FilterLogEntry(id, log, detail);
        if (status != S_OK) {
            continue;
        }

        status = DumpLogEntry(id, log, detail);
        limit--;
        if (limit <= 0) {
            break;
        }
    }

    EXT_LEAVE();    // Macro includes: return status;
}