libcamera/libcamera.git - libcamera official repository

diff options

Diffstat (limited to 'test/v4l2_compat')

-rwxr-xr-x

1 files changed, 13 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2018, Google Inc. * * log.cpp - Logging infrastructure */ #include "log.h" #include <cstdio> #include <cstdlib> #include <ctime> #include <fstream> #include <iomanip> #include <iostream> #include <list> #include <string.h> #include <unordered_set> #include "utils.h" /** * \file log.h * \brief Logging infrastructure * * libcamera includes a logging infrastructure used through the library that * allows inspection of internal operation in a user-configurable way. The log * messages are grouped in categories that represent areas of libcamera, and * output of messages for each category can be controlled by independent log * levels. * * The levels are configurable through the LIBCAMERA_LOG_LEVELS environment * variable that contains a comma-separated list of 'category:level' pairs. * * The category names are strings and can include a wildcard ('*') character at * the end to match multiple categories. * * The level are either numeric values, or strings containing the log level * name. The available log levels are DEBUG, INFO, WARN, ERROR and FATAL. Log * message with a level higher than or equal to the configured log level for * their category are output to the log, while other messages are silently * discarded. * * By default log messages are output to stderr. They can be redirected to a log * file by setting the LIBCAMERA_LOG_FILE environment variable to the name of * the file. The file must be writable and is truncated if it exists. If any * error occurs when opening the file, the file is ignored and the log is output * to stderr. */ namespace libcamera { /** * \brief Message logger * * The Logger class handles log configuration. */ class Logger { public: static Logger *instance(); void write(const std::string &msg); private: Logger(); void parseLogFile(); void parseLogLevels(); static LogSeverity parseLogLevel(const std::string &level); friend int logSetFile(const char *file); friend void logSetLevel(const char *category, const char *level); friend LogCategory; void registerCategory(LogCategory *category); void unregisterCategory(LogCategory *category); std::unordered_set<LogCategory *> categories_; std::list<std::pair<std::string, LogSeverity>> levels_; std::ofstream file_; std::ostream *output_; }; /** * \brief Set the log file * \param[in] file Full path to the log file * * This function sets the logging output file to \a file. The previous log file, * if any, is closed, and all new log messages will be written to the new log * file. * * If \a file is a null pointer, the log is directed to stderr. If the * function returns an error, the log file is not changed. * * \return Zero on success, or a negative error code otherwise. */ int logSetFile(const char *file) { Logger *logger = Logger::instance(); if (!file) { logger->output_ = &std::cerr; logger->file_.close(); return 0; } std::ofstream logFile(file); if (!logFile.good()) return -EINVAL; if (logger->output_ != &std::cerr) logger->file_.close(); logger->file_ = std::move(logFile); logger->output_ = &logger->file_; return 0; } /** * \brief Set the log level * \param[in] category Logging category * \param[in] level Log level * * This function sets the log level of \a category to \a level. * \a level shall be one of the following strings: * - "DEBUG" * - "INFO" * - "WARN" * - "ERROR" * - "FATAL" * * "*" is not a valid \a category for this function. */ void logSetLevel(const char *category, const char *level) { Logger *logger = Logger::instance(); LogSeverity severity = Logger::parseLogLevel(level); if (severity == LogInvalid) return; for (LogCategory *c : logger->categories_) if (!strcmp(c->name(), category)) c->setSeverity(severity); } /** * \brief Retrieve the logger instance * * The Logger is a singleton and can't be constructed manually. This function * shall instead be used to retrieve the single global instance of the logger. * * \return The logger instance */ Logger *Logger::instance() { static Logger instance; return &instance; } /** * \brief Write a message to the configured logger output * \param[in] msg The message string */ void Logger::write(const std::string &msg) { output_->write(msg.c_str(), msg.size()); output_->flush(); } /** * \brief Construct a logger */ Logger::Logger() : output_(&std::cerr) { parseLogFile(); parseLogLevels(); } /** * \brief Parse the log output file from the environment * * If the LIBCAMERA_LOG_FILE environment variable is set, open the file it * points to and redirect the logger output to it. Errors are silently ignored * and don't affect the logger output (set to stderr). */ void Logger::parseLogFile() { const char *file = utils::secure_getenv("LIBCAMERA_LOG_FILE"); if (!file) return; file_.open(file); if (file_.good()) output_ = &file_; } /** * \brief Parse the log levels from the environment * * The log levels are stored in the LIBCAMERA_LOG_LEVELS environment variable * as a list of "category:level" pairs, separated by commas (','). Parse the * variable and store the levels to configure all log categories. */ void Logger::parseLogLevels() { const char *debug = utils::secure_getenv("LIBCAMERA_LOG_LEVELS"); if (!debug) return; for (const char *pair = debug; *debug != '\0'; pair = debug) { const char *comma = strchrnul(debug, ','); size_t len = comma - pair; /* Skip over the comma. */ debug = *comma == ',' ? comma + 1 : comma; /* Skip to the next pair if the pair is empty. */ if (!len) continue; std::string category; std::string level; const char *colon = static_cast<const char *>(memchr(pair, ':', len)); if (!colon) { /* 'x' is a shortcut for '*:x'. */ category = "*"; level = std::string(pair, len); } else { category = std::string(pair, colon - pair); level = std::string(colon + 1, comma - colon - 1); } /* Both the category and the level must be specified. */ if (category.empty() || level.empty()) continue; LogSeverity severity = parseLogLevel(level); if (severity == LogInvalid) continue; levels_.push_back({ category, severity }); } } /** * \brief Parse a log level string into a LogSeverity * \param[in] level The log level string * * Log levels can be specified as an integer value in the range from LogDebug to * LogFatal, or as a string corresponding to the severity name in uppercase. Any * other value is invalid. * * \return The log severity, or LogInvalid if the string is invalid */ LogSeverity Logger::parseLogLevel(const std::string &level) { static const char *const names[] = { "DEBUG", "INFO", "WARN", "ERROR", "FATAL", }; int severity; if (std::isdigit(level[0])) { char *endptr; severity = strtoul(level.c_str(), &endptr, 10); if (*endptr != '\0' || severity > LogFatal) severity = LogInvalid; } else { severity = LogInvalid; for (unsigned int i = 0; i < ARRAY_SIZE(names); ++i) { if (names[i] == level) { severity = i; break; } } } return static_cast<LogSeverity>(severity); } /** * \brief Register a log category with the logger * \param[in] category The log category * * Log categories must have unique names. If a category with the same name * already exists this function performs no operation. */ void Logger::registerCategory(LogCategory *category) { categories_.insert(category); const std::string &name = category->name(); for (const std::pair<std::string, LogSeverity> &level : levels_) { bool match = true; for (unsigned int i = 0; i < level.first.size(); ++i) { if (level.first[i] == '*') break; if (i >= name.size() || name[i] != level.first[i]) { match = false; break; } } if (match) { category->setSeverity(level.second); break; } } } /** * \brief Unregister a log category from the logger * \param[in] category The log category * * If the \a category hasn't been registered with the logger this function * performs no operation. */ void Logger::unregisterCategory(LogCategory *category) { categories_.erase(category); } /** * \enum LogSeverity * Log message severity * \var LogDebug * Debug message * \var LogInfo * Informational message * \var LogWarning * Warning message, signals a potential issue * \var LogError * Error message, signals an unrecoverable issue * \var LogFatal * Fatal message, signals an unrecoverable issue and aborts execution */ /** * \class LogCategory * \brief A category of log message * * The LogCategory class represents a category of log messages, related to an * area of the library. It groups all messages belonging to the same category, * and is used to control the log level per group. */ /** * \brief Construct a log category * \param[in] name The category name */ LogCategory::LogCategory(const char *name) : name_(name), severity_(LogSeverity::LogInfo) { Logger::instance()->registerCategory(this); } LogCategory::~LogCategory() { Logger::instance()->unregisterCategory(this); } /** * \fn LogCategory::name() * \brief Retrieve the log category name * \return The log category name */ /** * \fn LogCategory::severity() * \brief Retrieve the severity of the log category * \sa setSeverity() * \return Return the severity of the log category */ /** * \brief Set the severity of the log category * * Messages of severity higher than or equal to the severity of the log category * are printed, other messages are discarded. */ void LogCategory::setSeverity(LogSeverity severity) { severity_ = severity; } /** * \brief Retrieve the default log category * * The default log category is named "default" and is used by the LOG() macro * when no log category is specified. * * \return A pointer to the default log category */


context:
space:
mode: