mirror of
https://github.com/google/pebble.git
synced 2025-07-17 11:36:40 -04:00
224 lines
6.5 KiB
C
224 lines
6.5 KiB
C
/*
|
|
* Copyright 2024 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <logging/log_hashing.h>
|
|
/*
|
|
* This file defines the structures required for Binary Logging. Please see
|
|
* https://docs.google.com/document/d/1AyRGwr8CiilAViha56EiuRSZFiW0fWMcsTfzkNxByZ8
|
|
* for more information.
|
|
*/
|
|
|
|
// SLIP Framing (if not using PULSE). Packet is: END, <packet>, <crc32>, END
|
|
#define END 0xC0
|
|
#define ESC 0xDB
|
|
#define ESC_END 0xDC
|
|
#define ESC_ESC 0xDD
|
|
|
|
// Version
|
|
typedef struct BinLogMessage_Version {
|
|
union {
|
|
struct {
|
|
uint8_t reserved:4;
|
|
uint8_t unhashed_msg:1;
|
|
uint8_t parameterized:1;
|
|
uint8_t tick_count:1;
|
|
uint8_t time_date:1;
|
|
};
|
|
uint8_t version;
|
|
};
|
|
} BinLogMessage_Version;
|
|
|
|
#define BINLOGMSG_VERSION_UNHASHED_MSG (1 << 3)
|
|
#define BINLOGMSG_VERSION_PARAMETERIZED (1 << 2)
|
|
#define BINLOGMSG_VERSION_TICK_COUNT (1 << 1)
|
|
#define BINLOGMSG_VERSION_TIME_DATE (1 << 0)
|
|
|
|
_Static_assert(sizeof(BinLogMessage_Version) == 1, "BinLogMessage_Version size != 1");
|
|
|
|
// Time_Full
|
|
// The times are in UTC. All values are 0 based (i.e., hour is [0,23], minute is [0,59],
|
|
// second is [0,59], millisecond is [0,999]).
|
|
typedef struct Time_Full {
|
|
uint32_t reserved:5;
|
|
uint32_t hour:5;
|
|
uint32_t minute:6;
|
|
uint32_t second:6;
|
|
uint32_t millisecond:10;
|
|
} Time_Full;
|
|
|
|
// Time_Tick
|
|
// Total ticks = (count_high << 32) | count.
|
|
typedef struct Time_Tick {
|
|
uint16_t reserved;
|
|
uint16_t count_high;
|
|
uint32_t count;
|
|
} Time_Tick;
|
|
|
|
// Date
|
|
// The year is an offset from 2000 (e.g. year = 16 is 2016).
|
|
// All remaining values are 1 based (i.e., month is [1,12], day is [1,31]).
|
|
// An invalid/unknown date is identified by (year, month, day) = (0, 0, 0). Thus, Date = 0 is an
|
|
// invalid date, not the start of the epoch, which would be (0, 1, 1).
|
|
typedef struct Date {
|
|
uint16_t year:7;
|
|
uint16_t month:4;
|
|
uint16_t day:5;
|
|
} Date;
|
|
|
|
// MessageID
|
|
typedef struct MessageID {
|
|
union {
|
|
struct {
|
|
uint32_t msg_number:19; // LSB
|
|
uint32_t task_id:4;
|
|
uint32_t str_index_1:3;
|
|
uint32_t str_index_2:3;
|
|
uint32_t reserved:1;
|
|
uint32_t core_number:2; // MSB
|
|
};
|
|
uint32_t msg_id;
|
|
};
|
|
} MessageID;
|
|
|
|
_Static_assert(sizeof(MessageID) == 4, "MessageID size != 4");
|
|
|
|
typedef struct BinLogMessage_Header {
|
|
uint8_t version;
|
|
uint8_t length;
|
|
} BinLogMessage_Header;
|
|
|
|
typedef struct BinLogMessage_Header_v0 {
|
|
uint8_t version;
|
|
uint8_t length;
|
|
uint8_t reserved[2];
|
|
} BinLogMessage_Header_v0;
|
|
#define BINLOGMSG_VERSION_HEADER_V0 (0)
|
|
|
|
typedef struct BinLogMessage_Header_v1 {
|
|
uint8_t version;
|
|
uint8_t length;
|
|
Date date;
|
|
Time_Full time;
|
|
} BinLogMessage_Header_v1;
|
|
#define BINLOGMSG_VERSION_HEADER_V1 (BINLOGMSG_VERSION_TIME_DATE)
|
|
|
|
typedef struct BinLogMessage_Header_v2 {
|
|
uint8_t version;
|
|
uint8_t length;
|
|
uint8_t reserved[2];
|
|
Time_Tick tick_count;
|
|
} BinLogMessage_Header_v2;
|
|
#define BINLOGMSG_VERSION_HEADER_V2 (BINLOGMSG_VERSION_TICK_COUNT)
|
|
|
|
typedef struct BinLogMessage_Header_v3 {
|
|
uint8_t version;
|
|
uint8_t length;
|
|
Date date;
|
|
Time_Full time;
|
|
Time_Tick tick_count;
|
|
} BinLogMessage_Header_v3;
|
|
#define BINLOGMSG_VERSION_HEADER_V3 (BINLOGMSG_VERSION_TIME_DATE | BINLOGMSG_VERSION_TICK_COUNT)
|
|
|
|
typedef struct BinLogMessage_ParamBody {
|
|
MessageID msgid;
|
|
uint32_t payload[0];
|
|
} BinLogMessage_ParamBody;
|
|
|
|
typedef struct BinLogMessage_StringParam {
|
|
uint8_t length;
|
|
uint8_t string[0]; // string[length]
|
|
// uint8_t padding[((length + sizeof(length) + 3) % 4)]
|
|
} BinLogMessage_StringParam;
|
|
|
|
typedef uint32_t BinLogMessage_IntParam;
|
|
|
|
typedef struct BinLogMessage_UnhashedBody {
|
|
uint16_t line_number;
|
|
uint8_t filename[16];
|
|
uint8_t reserved:2;
|
|
uint8_t core_number:2;
|
|
uint8_t task_id:4;
|
|
uint8_t level;
|
|
uint8_t length;
|
|
uint8_t string[0]; // string[length];
|
|
// uint8_t padding[];
|
|
} BinLogMessage_UnhashedBody;
|
|
|
|
|
|
/*
|
|
int len = MAX(strlen(log_string), 255 - sizeof(BinLogMessage_Header_vX))
|
|
typedef struct BinLogMessage_SimpleBody {
|
|
uint8_t string[len];
|
|
uint8_t padding[((sizeof(BinLogMessage_Header_vX) + len + 3) % 4)];
|
|
} BinLogMessage_SimpleBody;
|
|
*/
|
|
|
|
|
|
typedef struct BinLogMessage_Param_v0 {
|
|
BinLogMessage_Header_v0 header;
|
|
BinLogMessage_ParamBody body;
|
|
} BinLogMessage_Param_v0;
|
|
#define BINLOGMSG_VERSION_PARAM_V0 (BINLOGMSG_VERSION_HEADER_V0 | BINLOGMSG_VERSION_PARAMETERIZED)
|
|
|
|
typedef struct BinLogMessage_Param_v1 {
|
|
BinLogMessage_Header_v1 header;
|
|
BinLogMessage_ParamBody body;
|
|
} BinLogMessage_Param_v1;
|
|
#define BINLOGMSG_VERSION_PARAM_V1 (BINLOGMSG_VERSION_HEADER_V1 | BINLOGMSG_VERSION_PARAMETERIZED)
|
|
|
|
typedef struct BinLogMessage_Param_v2 {
|
|
BinLogMessage_Header_v2 header;
|
|
BinLogMessage_ParamBody body;
|
|
} BinLogMessage_Param_v2;
|
|
#define BINLOGMSG_VERSION_PARAM_V2 (BINLOGMSG_VERSION_HEADER_V2 | BINLOGMSG_VERSION_PARAMETERIZED)
|
|
|
|
typedef struct BinLogMessage_Param_v3 {
|
|
BinLogMessage_Header_v3 header;
|
|
BinLogMessage_ParamBody body;
|
|
} BinLogMessage_Param_v3;
|
|
#define BINLOGMSG_VERSION_PARAM_V3 (BINLOGMSG_VERSION_HEADER_V3 | BINLOGMSG_VERSION_PARAMETERIZED)
|
|
|
|
typedef struct BinLogMessage_Unhashed_v0 {
|
|
BinLogMessage_Header_v0 header;
|
|
BinLogMessage_UnhashedBody body;
|
|
} BinLogMessage_Unhashed_v0;
|
|
#define BINLOGMSG_VERSION_UNHASHED_V0 (BINLOGMSG_VERSION_HEADER_V0 | BINLOGMSG_VERSION_UNHASHED_MSG)
|
|
|
|
typedef struct BinLogMessage_Unhashed_v1 {
|
|
BinLogMessage_Header_v1 header;
|
|
BinLogMessage_UnhashedBody body;
|
|
} BinLogMessage_Unhashed_v1;
|
|
#define BINLOGMSG_VERSION_UNHASHED_V1 (BINLOGMSG_VERSION_HEADER_V1 | BINLOGMSG_VERSION_UNHASHED_MSG)
|
|
|
|
typedef struct BinLogMessage_Unhashed_v2 {
|
|
BinLogMessage_Header_v2 header;
|
|
BinLogMessage_UnhashedBody body;
|
|
} BinLogMessage_Unhashed_v2;
|
|
#define BINLOGMSG_VERSION_UNHASHED_V2 (BINLOGMSG_VERSION_HEADER_V2 | BINLOGMSG_VERSION_UNHASHED_MSG)
|
|
|
|
typedef struct BinLogMessage_Unhashed_v3 {
|
|
BinLogMessage_Header_v3 header;
|
|
BinLogMessage_UnhashedBody body;
|
|
} BinLogMessage_Unhashed_v3;
|
|
#define BINLOGMSG_VERSION_UNHASHED_V3 (BINLOGMSG_VERSION_HEADER_V3 | BINLOGMSG_VERSION_UNHASHED_MSG)
|
|
|
|
typedef struct BinLogMessage_String_v1 {
|
|
BinLogMessage_Header_v1 header;
|
|
uint8_t string[0];
|
|
} BinLogMessage_String_v1;
|
|
#define BINLOGMSG_VERSION_STRING_V1 (BINLOGMSG_VERSION_HEADER_V1)
|