mirror of
https://github.com/varun-r-mallya/sysprof.git
synced 2025-12-31 20:36:25 +00:00
372 lines
12 KiB
C
372 lines
12 KiB
C
/* sysprof-capture-types.h
|
|
*
|
|
* Copyright 2016-2019 Christian Hergert <chergert@redhat.com>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* Subject to the terms and conditions of this license, each copyright holder
|
|
* and contributor hereby grants to those receiving rights under this license
|
|
* a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
|
|
* irrevocable (except for failure to satisfy the conditions of this license)
|
|
* patent license to make, have made, use, offer to sell, sell, import, and
|
|
* otherwise transfer this software, where such license applies only to those
|
|
* patent claims, already acquired or hereafter acquired, licensable by such
|
|
* copyright holder or contributor that are necessarily infringed by:
|
|
*
|
|
* (a) their Contribution(s) (the licensed copyrights of copyright holders
|
|
* and non-copyrightable additions of contributors, in source or binary
|
|
* form) alone; or
|
|
*
|
|
* (b) combination of their Contribution(s) with the work of authorship to
|
|
* which such Contribution(s) was added by such copyright holder or
|
|
* contributor, if, at the time the Contribution is added, such addition
|
|
* causes such combination to be necessarily infringed. The patent license
|
|
* shall not apply to any other combinations which include the
|
|
* Contribution.
|
|
*
|
|
* Except as expressly stated above, no rights or licenses from any copyright
|
|
* holder or contributor is granted under this license, whether expressly, by
|
|
* implication, estoppel or otherwise.
|
|
*
|
|
* DISCLAIMER
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
|
|
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <assert.h>
|
|
#include <endian.h>
|
|
#include <glib.h>
|
|
#include <inttypes.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#include "sysprof-clock.h"
|
|
#include "sysprof-macros.h"
|
|
|
|
SYSPROF_BEGIN_DECLS
|
|
|
|
#define SYSPROF_CAPTURE_MAGIC (htole32(0xFDCA975E))
|
|
#define SYSPROF_CAPTURE_ALIGN (sizeof(SysprofCaptureAddress))
|
|
|
|
#if defined(_MSC_VER)
|
|
# define SYSPROF_ALIGNED_BEGIN(_N) __declspec(align (_N))
|
|
# define SYSPROF_ALIGNED_END(_N)
|
|
#else
|
|
# define SYSPROF_ALIGNED_BEGIN(_N)
|
|
# define SYSPROF_ALIGNED_END(_N) __attribute__((aligned ((_N))))
|
|
#endif
|
|
|
|
#define SYSPROF_CAPTURE_ADDRESS_FORMAT "0x%016" PRIx64
|
|
|
|
#if GLIB_SIZEOF_VOID_P == 8
|
|
# define SYSPROF_CAPTURE_JITMAP_MARK SYSPROF_UINT64_CONSTANT(0xE000000000000000)
|
|
#elif GLIB_SIZEOF_VOID_P == 4
|
|
# define SYSPROF_CAPTURE_JITMAP_MARK SYSPROF_UINT64_CONSTANT(0xE0000000)
|
|
#else
|
|
#error Unknown GLIB_SIZEOF_VOID_P
|
|
#endif
|
|
|
|
#define SYSPROF_CAPTURE_CURRENT_TIME (sysprof_clock_get_current_time())
|
|
#define SYSPROF_CAPTURE_COUNTER_INT64 0
|
|
#define SYSPROF_CAPTURE_COUNTER_DOUBLE 1
|
|
|
|
typedef struct _SysprofCaptureReader SysprofCaptureReader;
|
|
typedef struct _SysprofCaptureWriter SysprofCaptureWriter;
|
|
typedef struct _SysprofCaptureCursor SysprofCaptureCursor;
|
|
typedef struct _SysprofCaptureCondition SysprofCaptureCondition;
|
|
|
|
typedef uint64_t SysprofCaptureAddress;
|
|
|
|
typedef struct
|
|
{
|
|
/*
|
|
* The number of frames indexed by SysprofCaptureFrameType
|
|
*/
|
|
size_t frame_count[16];
|
|
|
|
/*
|
|
* Padding for future expansion.
|
|
*/
|
|
size_t padding[48];
|
|
} SysprofCaptureStat;
|
|
|
|
typedef union
|
|
{
|
|
int64_t v64;
|
|
double vdbl;
|
|
} SysprofCaptureCounterValue;
|
|
|
|
typedef enum
|
|
{
|
|
SYSPROF_CAPTURE_FRAME_TIMESTAMP = 1,
|
|
SYSPROF_CAPTURE_FRAME_SAMPLE = 2,
|
|
SYSPROF_CAPTURE_FRAME_MAP = 3,
|
|
SYSPROF_CAPTURE_FRAME_PROCESS = 4,
|
|
SYSPROF_CAPTURE_FRAME_FORK = 5,
|
|
SYSPROF_CAPTURE_FRAME_EXIT = 6,
|
|
SYSPROF_CAPTURE_FRAME_JITMAP = 7,
|
|
SYSPROF_CAPTURE_FRAME_CTRDEF = 8,
|
|
SYSPROF_CAPTURE_FRAME_CTRSET = 9,
|
|
SYSPROF_CAPTURE_FRAME_MARK = 10,
|
|
SYSPROF_CAPTURE_FRAME_METADATA = 11,
|
|
SYSPROF_CAPTURE_FRAME_LOG = 12,
|
|
SYSPROF_CAPTURE_FRAME_FILE_CHUNK = 13,
|
|
SYSPROF_CAPTURE_FRAME_ALLOCATION = 14,
|
|
} SysprofCaptureFrameType;
|
|
|
|
/* Not part of ABI */
|
|
#define SYSPROF_CAPTURE_FRAME_LAST 15
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
uint32_t magic;
|
|
uint32_t version : 8;
|
|
uint32_t little_endian : 1;
|
|
uint32_t padding : 23;
|
|
char capture_time[64];
|
|
int64_t time;
|
|
int64_t end_time;
|
|
char suffix[168];
|
|
} SysprofCaptureFileHeader
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
uint16_t len;
|
|
int16_t cpu;
|
|
int32_t pid;
|
|
int64_t time;
|
|
uint32_t type : 8;
|
|
uint32_t padding1 : 24;
|
|
uint32_t padding2;
|
|
uint8_t data[0];
|
|
} SysprofCaptureFrame
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
uint64_t start;
|
|
uint64_t end;
|
|
uint64_t offset;
|
|
uint64_t inode;
|
|
char filename[0];
|
|
} SysprofCaptureMap
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
uint32_t n_jitmaps;
|
|
uint8_t data[0];
|
|
} SysprofCaptureJitmap
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
char cmdline[0];
|
|
} SysprofCaptureProcess
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
uint32_t n_addrs : 16;
|
|
uint32_t padding1 : 16;
|
|
int32_t tid;
|
|
SysprofCaptureAddress addrs[0];
|
|
} SysprofCaptureSample
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
int32_t child_pid;
|
|
} SysprofCaptureFork
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
} SysprofCaptureExit
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
} SysprofCaptureTimestamp
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
char category[32];
|
|
char name[32];
|
|
char description[52];
|
|
uint32_t id : 24;
|
|
uint32_t type : 8;
|
|
SysprofCaptureCounterValue value;
|
|
} SysprofCaptureCounter
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
uint32_t n_counters : 16;
|
|
uint32_t padding1 : 16;
|
|
uint32_t padding2;
|
|
SysprofCaptureCounter counters[0];
|
|
} SysprofCaptureCounterDefine
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
/*
|
|
* 96 bytes might seem a bit odd, but the counter frame header is 32
|
|
* bytes. So this makes a nice 2-cacheline aligned size which is
|
|
* useful when the number of counters is rather small.
|
|
*/
|
|
uint32_t ids[8];
|
|
SysprofCaptureCounterValue values[8];
|
|
} SysprofCaptureCounterValues
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
uint32_t n_values : 16;
|
|
uint32_t padding1 : 16;
|
|
uint32_t padding2;
|
|
SysprofCaptureCounterValues values[0];
|
|
} SysprofCaptureCounterSet
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
int64_t duration;
|
|
char group[24];
|
|
char name[40];
|
|
char message[0];
|
|
} SysprofCaptureMark
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
char id[40];
|
|
char metadata[0];
|
|
} SysprofCaptureMetadata
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
uint32_t severity : 16;
|
|
uint32_t padding1 : 16;
|
|
uint32_t padding2 : 32;
|
|
char domain[32];
|
|
char message[0];
|
|
} SysprofCaptureLog
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
uint32_t is_last : 1;
|
|
uint32_t padding1 : 15;
|
|
uint32_t len : 16;
|
|
char path[256];
|
|
uint8_t data[0];
|
|
} SysprofCaptureFileChunk
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
SYSPROF_ALIGNED_BEGIN(1)
|
|
typedef struct
|
|
{
|
|
SysprofCaptureFrame frame;
|
|
SysprofCaptureAddress alloc_addr;
|
|
int64_t alloc_size;
|
|
int32_t tid;
|
|
uint32_t n_addrs : 16;
|
|
uint32_t padding1 : 16;
|
|
SysprofCaptureAddress addrs[0];
|
|
} SysprofCaptureAllocation
|
|
SYSPROF_ALIGNED_END(1);
|
|
|
|
static_assert (sizeof (SysprofCaptureFileHeader) == 256, "SysprofCaptureFileHeader changed size");
|
|
static_assert (sizeof (SysprofCaptureFrame) == 24, "SysprofCaptureFrame changed size");
|
|
static_assert (sizeof (SysprofCaptureMap) == 56, "SysprofCaptureMap changed size");
|
|
static_assert (sizeof (SysprofCaptureJitmap) == 28, "SysprofCaptureJitmap changed size");
|
|
static_assert (sizeof (SysprofCaptureProcess) == 24, "SysprofCaptureProcess changed size");
|
|
static_assert (sizeof (SysprofCaptureSample) == 32, "SysprofCaptureSample changed size");
|
|
static_assert (sizeof (SysprofCaptureFork) == 28, "SysprofCaptureFork changed size");
|
|
static_assert (sizeof (SysprofCaptureExit) == 24, "SysprofCaptureExit changed size");
|
|
static_assert (sizeof (SysprofCaptureTimestamp) == 24, "SysprofCaptureTimestamp changed size");
|
|
static_assert (sizeof (SysprofCaptureCounter) == 128, "SysprofCaptureCounter changed size");
|
|
static_assert (sizeof (SysprofCaptureCounterValues) == 96, "SysprofCaptureCounterValues changed size");
|
|
static_assert (sizeof (SysprofCaptureCounterDefine) == 32, "SysprofCaptureCounterDefine changed size");
|
|
static_assert (sizeof (SysprofCaptureCounterSet) == 32, "SysprofCaptureCounterSet changed size");
|
|
static_assert (sizeof (SysprofCaptureMark) == 96, "SysprofCaptureMark changed size");
|
|
static_assert (sizeof (SysprofCaptureMetadata) == 64, "SysprofCaptureMetadata changed size");
|
|
static_assert (sizeof (SysprofCaptureLog) == 64, "SysprofCaptureLog changed size");
|
|
static_assert (sizeof (SysprofCaptureFileChunk) == 284, "SysprofCaptureFileChunk changed size");
|
|
static_assert (sizeof (SysprofCaptureAllocation) == 48, "SysprofCaptureAllocation changed size");
|
|
|
|
static_assert ((offsetof (SysprofCaptureAllocation, addrs) % SYSPROF_CAPTURE_ALIGN) == 0, "SysprofCaptureAllocation.addrs is not aligned");
|
|
static_assert ((offsetof (SysprofCaptureSample, addrs) % SYSPROF_CAPTURE_ALIGN) == 0, "SysprofCaptureSample.addrs is not aligned");
|
|
|
|
static inline int
|
|
sysprof_capture_address_compare (SysprofCaptureAddress a,
|
|
SysprofCaptureAddress b)
|
|
{
|
|
if (a < b)
|
|
return -1;
|
|
if (a > b)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
SYSPROF_END_DECLS
|