Logging.cpp

/* See Project CHIP LICENSE file for licensing information. */
#include <platform/logging/LogV.h>

#include "qvCHIP.h"

#include <core/CHIPConfig.h>
#include <platform/CHIPDeviceConfig.h>
#include <support/CHIPPlatformMemory.h>
#include <support/logging/Constants.h>

#include <ctype.h>
#include <string.h>

#if CHIP_DEVICE_CONFIG_ENABLE_THREAD
#include <openthread/platform/logging.h>
#include <openthread/platform/memory.h>
#endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD

constexpr uint8_t kPrintfModuleLwip       = 0x01;
constexpr uint8_t kPrintfModuleOpenThread = 0x02;
constexpr uint8_t kPrintfModuleLogging    = 0x03;

namespace chip {
namespace DeviceLayer {

/**
 * Called whenever a log message is emitted by chip or LwIP.
 *
 * This function is intended be overridden by the application to, e.g.,
 * schedule output of queued log entries.
 */
void __attribute__((weak)) OnLogOutput(void) {}

} // namespace DeviceLayer
} // namespace chip

namespace chip {
namespace Logging {
namespace Platform {

/**
 * CHIP log output function.
 */

void LogV(const char * module, uint8_t category, const char * msg, va_list v)
{
    char formattedMsg[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE];
    size_t prefixLen;

    prefixLen = 0;

    // No build-time switches in Qorvo logging module.
    // Add small prefix to show logging category for now.
    formattedMsg[prefixLen++] = '[';
    switch (category)
    {
    case kLogCategory_Error:
        formattedMsg[prefixLen++] = 'E';
        break;
    case kLogCategory_Detail:
        formattedMsg[prefixLen++] = 'D';
        break;
    case kLogCategory_Progress:
    default:
        formattedMsg[prefixLen++] = 'P';
        break;
    }
    formattedMsg[prefixLen++] = ']';
    formattedMsg[prefixLen++] = '[';
    snprintf(formattedMsg + prefixLen, sizeof(formattedMsg) - prefixLen, "][%s] ", module);
    formattedMsg[sizeof(formattedMsg) - 2] = 0; // -2 to allow at least one char for the vsnprintf
    prefixLen                              = strlen(formattedMsg);

    vsnprintf(formattedMsg + prefixLen, sizeof(formattedMsg) - prefixLen, msg, v);

    qvCHIP_Printf(kPrintfModuleLogging, formattedMsg);

    // Let the application know that a log message has been emitted.
    chip::DeviceLayer::OnLogOutput();
}

} // namespace Platform
} // namespace Logging
} // namespace chip

/**
 * LwIP log output function.
 */
extern "C" void LwIPLog(const char * msg, ...)
{
    char formattedMsg[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE];

    va_list v;

    va_start(v, msg);
    size_t len = vsnprintf(formattedMsg, sizeof(formattedMsg), msg, v);
    va_end(v);

    while (len > 0 && isspace(formattedMsg[len - 1]))
    {
        len--;
        formattedMsg[len] = 0;
    }

    qvCHIP_Printf(kPrintfModuleLwip, formattedMsg);

    // Let the application know that a log message has been emitted.
    chip::DeviceLayer::OnLogOutput();
}

#if CHIP_DEVICE_CONFIG_ENABLE_THREAD
extern "C" void otPlatLog(otLogLevel aLogLevel, otLogRegion aLogRegion, const char * aFormat, ...)
{
    char formattedMsg[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE];

    va_list v;

    va_start(v, aFormat);
    vsnprintf(formattedMsg, sizeof(formattedMsg), aFormat, v);
    va_end(v);

    qvCHIP_Printf(kPrintfModuleOpenThread, formattedMsg);

    // Let the application know that a log message has been emitted.
    chip::DeviceLayer::OnLogOutput();
}

// TODO: have qpg6100 openthread platform implementation defines the APIs.
// It is not perfect to have the openthread platform calloc/free
// APIs defined here. If a dedicated source file (e.g. Memory.cpp)
// that includes only the two functions is used, the target file
// Memory.o will be thrown away whening linking the libary because
// there is no one referring the symbols (We are not linking
// the 'platform' library against openthread).
extern "C" void * otPlatCAlloc(size_t aNum, size_t aSize)
{
    return CHIPPlatformMemoryCalloc(aNum, aSize);
}

extern "C" void otPlatFree(void * aPtr)
{
    CHIPPlatformMemoryFree(aPtr);
}
#endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD