[lttng-tools.git] / src / common / filter / filter-bytecode.h

#ifndef _FILTER_BYTECODE_H
#define _FILTER_BYTECODE_H

/*
 * filter-bytecode.h
 *
 * LTTng filter bytecode
 *
 * Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#include <common/sessiond-comm/sessiond-comm.h>
#include <common/macros.h>

#include "filter-ast.h"

/*
 * offsets are absolute from start of bytecode.
 */

struct field_ref {
	/* Initially, symbol offset. After link, field offset. */
	uint16_t offset;
} LTTNG_PACKED;

struct get_symbol {
	/* Symbol offset. */
	uint16_t offset;
} LTTNG_PACKED;

struct get_index_u16 {
	uint16_t index;
} LTTNG_PACKED;

struct get_index_u64 {
	uint64_t index;
} LTTNG_PACKED;

struct literal_numeric {
	int64_t v;
} LTTNG_PACKED;

struct literal_double {
	double v;
} LTTNG_PACKED;

struct literal_string {
	char string[0];
} LTTNG_PACKED;

enum filter_op {
	FILTER_OP_UNKNOWN			= 0,

	FILTER_OP_RETURN			= 1,

	/* binary */
	FILTER_OP_MUL				= 2,
	FILTER_OP_DIV				= 3,
	FILTER_OP_MOD				= 4,
	FILTER_OP_PLUS				= 5,
	FILTER_OP_MINUS				= 6,
	FILTER_OP_BIT_RSHIFT			= 7,
	FILTER_OP_BIT_LSHIFT			= 8,
	FILTER_OP_BIT_AND			= 9,
	FILTER_OP_BIT_OR			= 10,
	FILTER_OP_BIT_XOR			= 11,

	/* binary comparators */
	FILTER_OP_EQ				= 12,
	FILTER_OP_NE				= 13,
	FILTER_OP_GT				= 14,
	FILTER_OP_LT				= 15,
	FILTER_OP_GE				= 16,
	FILTER_OP_LE				= 17,

	/* string binary comparator: apply to  */
	FILTER_OP_EQ_STRING			= 18,
	FILTER_OP_NE_STRING			= 19,
	FILTER_OP_GT_STRING			= 20,
	FILTER_OP_LT_STRING			= 21,
	FILTER_OP_GE_STRING			= 22,
	FILTER_OP_LE_STRING			= 23,

	/* s64 binary comparator */
	FILTER_OP_EQ_S64			= 24,
	FILTER_OP_NE_S64			= 25,
	FILTER_OP_GT_S64			= 26,
	FILTER_OP_LT_S64			= 27,
	FILTER_OP_GE_S64			= 28,
	FILTER_OP_LE_S64			= 29,

	/* double binary comparator */
	FILTER_OP_EQ_DOUBLE			= 30,
	FILTER_OP_NE_DOUBLE			= 31,
	FILTER_OP_GT_DOUBLE			= 32,
	FILTER_OP_LT_DOUBLE			= 33,
	FILTER_OP_GE_DOUBLE			= 34,
	FILTER_OP_LE_DOUBLE			= 35,

	/* Mixed S64-double binary comparators */
	FILTER_OP_EQ_DOUBLE_S64			= 36,
	FILTER_OP_NE_DOUBLE_S64			= 37,
	FILTER_OP_GT_DOUBLE_S64			= 38,
	FILTER_OP_LT_DOUBLE_S64			= 39,
	FILTER_OP_GE_DOUBLE_S64			= 40,
	FILTER_OP_LE_DOUBLE_S64			= 41,

	FILTER_OP_EQ_S64_DOUBLE			= 42,
	FILTER_OP_NE_S64_DOUBLE			= 43,
	FILTER_OP_GT_S64_DOUBLE			= 44,
	FILTER_OP_LT_S64_DOUBLE			= 45,
	FILTER_OP_GE_S64_DOUBLE			= 46,
	FILTER_OP_LE_S64_DOUBLE			= 47,

	/* unary */
	FILTER_OP_UNARY_PLUS			= 48,
	FILTER_OP_UNARY_MINUS			= 49,
	FILTER_OP_UNARY_NOT			= 50,
	FILTER_OP_UNARY_PLUS_S64		= 51,
	FILTER_OP_UNARY_MINUS_S64		= 52,
	FILTER_OP_UNARY_NOT_S64			= 53,
	FILTER_OP_UNARY_PLUS_DOUBLE		= 54,
	FILTER_OP_UNARY_MINUS_DOUBLE		= 55,
	FILTER_OP_UNARY_NOT_DOUBLE		= 56,

	/* logical */
	FILTER_OP_AND				= 57,
	FILTER_OP_OR				= 58,

	/* load field ref */
	FILTER_OP_LOAD_FIELD_REF		= 59,
	FILTER_OP_LOAD_FIELD_REF_STRING		= 60,
	FILTER_OP_LOAD_FIELD_REF_SEQUENCE	= 61,
	FILTER_OP_LOAD_FIELD_REF_S64		= 62,
	FILTER_OP_LOAD_FIELD_REF_DOUBLE		= 63,

	/* load immediate from operand */
	FILTER_OP_LOAD_STRING			= 64,
	FILTER_OP_LOAD_S64			= 65,
	FILTER_OP_LOAD_DOUBLE			= 66,

	/* cast */
	FILTER_OP_CAST_TO_S64			= 67,
	FILTER_OP_CAST_DOUBLE_TO_S64		= 68,
	FILTER_OP_CAST_NOP			= 69,

	/* get context ref */
	FILTER_OP_GET_CONTEXT_REF		= 70,
	FILTER_OP_GET_CONTEXT_REF_STRING	= 71,
	FILTER_OP_GET_CONTEXT_REF_S64		= 72,
	FILTER_OP_GET_CONTEXT_REF_DOUBLE	= 73,

	/* load userspace field ref */
	FILTER_OP_LOAD_FIELD_REF_USER_STRING	= 74,
	FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE	= 75,

	/*
	 * load immediate star globbing pattern (literal string)
	 * from immediate
	 */
	FILTER_OP_LOAD_STAR_GLOB_STRING		= 76,

	/* globbing pattern binary operator: apply to */
	FILTER_OP_EQ_STAR_GLOB_STRING		= 77,
	FILTER_OP_NE_STAR_GLOB_STRING		= 78,

	/*
	 * Instructions for recursive traversal through composed types.
	 */
	FILTER_OP_GET_CONTEXT_ROOT		= 79,
	FILTER_OP_GET_APP_CONTEXT_ROOT		= 80,
	FILTER_OP_GET_PAYLOAD_ROOT		= 81,

	FILTER_OP_GET_SYMBOL			= 82,
	FILTER_OP_GET_SYMBOL_FIELD		= 83,
	FILTER_OP_GET_INDEX_U16			= 84,
	FILTER_OP_GET_INDEX_U64			= 85,

	FILTER_OP_LOAD_FIELD			= 86,
	FILTER_OP_LOAD_FIELD_S8			= 87,
	FILTER_OP_LOAD_FIELD_S16		= 88,
	FILTER_OP_LOAD_FIELD_S32		= 89,
	FILTER_OP_LOAD_FIELD_S64		= 90,
	FILTER_OP_LOAD_FIELD_U8			= 91,
	FILTER_OP_LOAD_FIELD_U16		= 92,
	FILTER_OP_LOAD_FIELD_U32		= 93,
	FILTER_OP_LOAD_FIELD_U64		= 94,
	FILTER_OP_LOAD_FIELD_STRING		= 95,
	FILTER_OP_LOAD_FIELD_SEQUENCE		= 96,
	FILTER_OP_LOAD_FIELD_DOUBLE		= 97,

	FILTER_OP_UNARY_BIT_NOT			= 98,

	FILTER_OP_RETURN_S64			= 99,

	NR_FILTER_OPS,
};

typedef uint8_t filter_opcode_t;

struct load_op {
	filter_opcode_t op;
	char data[0];
	/* data to load. Size known by enum filter_opcode and null-term char. */
} LTTNG_PACKED;

struct binary_op {
	filter_opcode_t op;
} LTTNG_PACKED;

struct unary_op {
	filter_opcode_t op;
} LTTNG_PACKED;

/* skip_offset is absolute from start of bytecode */
struct logical_op {
	filter_opcode_t op;
	uint16_t skip_offset;	/* bytecode insn, if skip second test */
} LTTNG_PACKED;

struct cast_op {
	filter_opcode_t op;
} LTTNG_PACKED;

struct return_op {
	filter_opcode_t op;
} LTTNG_PACKED;

struct lttng_filter_bytecode_alloc {
	uint32_t alloc_len;
	struct lttng_filter_bytecode b;
};

static inline
unsigned int bytecode_get_len(struct lttng_filter_bytecode *bytecode)
{
	return bytecode->len;
}

#endif /* _FILTER_BYTECODE_H */
Commit	Line	Data
	1	#ifndef _FILTER_BYTECODE_H
	2	#define _FILTER_BYTECODE_H
	3
	4	/*
	5	* filter-bytecode.h
	6	*
	7	* LTTng filter bytecode
	8	*
	9	* Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	10	*
	11	* SPDX-License-Identifier: LGPL-2.1-only
	12	*
	13	*/
	14
	15	#include <common/sessiond-comm/sessiond-comm.h>
	16	#include <common/macros.h>
	17
	18	#include "filter-ast.h"
	19
	20	/*
	21	* offsets are absolute from start of bytecode.
	22	*/
	23
	24	struct field_ref {
	25	/* Initially, symbol offset. After link, field offset. */
	26	uint16_t offset;
	27	} LTTNG_PACKED;
	28
	29	struct get_symbol {
	30	/* Symbol offset. */
	31	uint16_t offset;
	32	} LTTNG_PACKED;
	33
	34	struct get_index_u16 {
	35	uint16_t index;
	36	} LTTNG_PACKED;
	37
	38	struct get_index_u64 {
	39	uint64_t index;
	40	} LTTNG_PACKED;
	41
	42	struct literal_numeric {
	43	int64_t v;
	44	} LTTNG_PACKED;
	45
	46	struct literal_double {
	47	double v;
	48	} LTTNG_PACKED;
	49
	50	struct literal_string {
	51	char string[0];
	52	} LTTNG_PACKED;
	53
	54	enum filter_op {
	55	FILTER_OP_UNKNOWN = 0,
	56
	57	FILTER_OP_RETURN = 1,
	58
	59	/* binary */
	60	FILTER_OP_MUL = 2,
	61	FILTER_OP_DIV = 3,
	62	FILTER_OP_MOD = 4,
	63	FILTER_OP_PLUS = 5,
	64	FILTER_OP_MINUS = 6,
	65	FILTER_OP_BIT_RSHIFT = 7,
	66	FILTER_OP_BIT_LSHIFT = 8,
	67	FILTER_OP_BIT_AND = 9,
	68	FILTER_OP_BIT_OR = 10,
	69	FILTER_OP_BIT_XOR = 11,
	70
	71	/* binary comparators */
	72	FILTER_OP_EQ = 12,
	73	FILTER_OP_NE = 13,
	74	FILTER_OP_GT = 14,
	75	FILTER_OP_LT = 15,
	76	FILTER_OP_GE = 16,
	77	FILTER_OP_LE = 17,
	78
	79	/* string binary comparator: apply to */
	80	FILTER_OP_EQ_STRING = 18,
	81	FILTER_OP_NE_STRING = 19,
	82	FILTER_OP_GT_STRING = 20,
	83	FILTER_OP_LT_STRING = 21,
	84	FILTER_OP_GE_STRING = 22,
	85	FILTER_OP_LE_STRING = 23,
	86
	87	/* s64 binary comparator */
	88	FILTER_OP_EQ_S64 = 24,
	89	FILTER_OP_NE_S64 = 25,
	90	FILTER_OP_GT_S64 = 26,
	91	FILTER_OP_LT_S64 = 27,
	92	FILTER_OP_GE_S64 = 28,
	93	FILTER_OP_LE_S64 = 29,
	94
	95	/* double binary comparator */
	96	FILTER_OP_EQ_DOUBLE = 30,
	97	FILTER_OP_NE_DOUBLE = 31,
	98	FILTER_OP_GT_DOUBLE = 32,
	99	FILTER_OP_LT_DOUBLE = 33,
	100	FILTER_OP_GE_DOUBLE = 34,
	101	FILTER_OP_LE_DOUBLE = 35,
	102
	103	/* Mixed S64-double binary comparators */
	104	FILTER_OP_EQ_DOUBLE_S64 = 36,
	105	FILTER_OP_NE_DOUBLE_S64 = 37,
	106	FILTER_OP_GT_DOUBLE_S64 = 38,
	107	FILTER_OP_LT_DOUBLE_S64 = 39,
	108	FILTER_OP_GE_DOUBLE_S64 = 40,
	109	FILTER_OP_LE_DOUBLE_S64 = 41,
	110
	111	FILTER_OP_EQ_S64_DOUBLE = 42,
	112	FILTER_OP_NE_S64_DOUBLE = 43,
	113	FILTER_OP_GT_S64_DOUBLE = 44,
	114	FILTER_OP_LT_S64_DOUBLE = 45,
	115	FILTER_OP_GE_S64_DOUBLE = 46,
	116	FILTER_OP_LE_S64_DOUBLE = 47,
	117
	118	/* unary */
	119	FILTER_OP_UNARY_PLUS = 48,
	120	FILTER_OP_UNARY_MINUS = 49,
	121	FILTER_OP_UNARY_NOT = 50,
	122	FILTER_OP_UNARY_PLUS_S64 = 51,
	123	FILTER_OP_UNARY_MINUS_S64 = 52,
	124	FILTER_OP_UNARY_NOT_S64 = 53,
	125	FILTER_OP_UNARY_PLUS_DOUBLE = 54,
	126	FILTER_OP_UNARY_MINUS_DOUBLE = 55,
	127	FILTER_OP_UNARY_NOT_DOUBLE = 56,
	128
	129	/* logical */
	130	FILTER_OP_AND = 57,
	131	FILTER_OP_OR = 58,
	132
	133	/* load field ref */
	134	FILTER_OP_LOAD_FIELD_REF = 59,
	135	FILTER_OP_LOAD_FIELD_REF_STRING = 60,
	136	FILTER_OP_LOAD_FIELD_REF_SEQUENCE = 61,
	137	FILTER_OP_LOAD_FIELD_REF_S64 = 62,
	138	FILTER_OP_LOAD_FIELD_REF_DOUBLE = 63,
	139
	140	/* load immediate from operand */
	141	FILTER_OP_LOAD_STRING = 64,
	142	FILTER_OP_LOAD_S64 = 65,
	143	FILTER_OP_LOAD_DOUBLE = 66,
	144
	145	/* cast */
	146	FILTER_OP_CAST_TO_S64 = 67,
	147	FILTER_OP_CAST_DOUBLE_TO_S64 = 68,
	148	FILTER_OP_CAST_NOP = 69,
	149
	150	/* get context ref */
	151	FILTER_OP_GET_CONTEXT_REF = 70,
	152	FILTER_OP_GET_CONTEXT_REF_STRING = 71,
	153	FILTER_OP_GET_CONTEXT_REF_S64 = 72,
	154	FILTER_OP_GET_CONTEXT_REF_DOUBLE = 73,
	155
	156	/* load userspace field ref */
	157	FILTER_OP_LOAD_FIELD_REF_USER_STRING = 74,
	158	FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75,
	159
	160	/*
	161	* load immediate star globbing pattern (literal string)
	162	* from immediate
	163	*/
	164	FILTER_OP_LOAD_STAR_GLOB_STRING = 76,
	165
	166	/* globbing pattern binary operator: apply to */
	167	FILTER_OP_EQ_STAR_GLOB_STRING = 77,
	168	FILTER_OP_NE_STAR_GLOB_STRING = 78,
	169
	170	/*
	171	* Instructions for recursive traversal through composed types.
	172	*/
	173	FILTER_OP_GET_CONTEXT_ROOT = 79,
	174	FILTER_OP_GET_APP_CONTEXT_ROOT = 80,
	175	FILTER_OP_GET_PAYLOAD_ROOT = 81,
	176
	177	FILTER_OP_GET_SYMBOL = 82,
	178	FILTER_OP_GET_SYMBOL_FIELD = 83,
	179	FILTER_OP_GET_INDEX_U16 = 84,
	180	FILTER_OP_GET_INDEX_U64 = 85,
	181
	182	FILTER_OP_LOAD_FIELD = 86,
	183	FILTER_OP_LOAD_FIELD_S8 = 87,
	184	FILTER_OP_LOAD_FIELD_S16 = 88,
	185	FILTER_OP_LOAD_FIELD_S32 = 89,
	186	FILTER_OP_LOAD_FIELD_S64 = 90,
	187	FILTER_OP_LOAD_FIELD_U8 = 91,
	188	FILTER_OP_LOAD_FIELD_U16 = 92,
	189	FILTER_OP_LOAD_FIELD_U32 = 93,
	190	FILTER_OP_LOAD_FIELD_U64 = 94,
	191	FILTER_OP_LOAD_FIELD_STRING = 95,
	192	FILTER_OP_LOAD_FIELD_SEQUENCE = 96,
	193	FILTER_OP_LOAD_FIELD_DOUBLE = 97,
	194
	195	FILTER_OP_UNARY_BIT_NOT = 98,
	196
	197	FILTER_OP_RETURN_S64 = 99,
	198
	199	NR_FILTER_OPS,
	200	};
	201
	202	typedef uint8_t filter_opcode_t;
	203
	204	struct load_op {
	205	filter_opcode_t op;
	206	char data[0];
	207	/* data to load. Size known by enum filter_opcode and null-term char. */
	208	} LTTNG_PACKED;
	209
	210	struct binary_op {
	211	filter_opcode_t op;
	212	} LTTNG_PACKED;
	213
	214	struct unary_op {
	215	filter_opcode_t op;
	216	} LTTNG_PACKED;
	217
	218	/* skip_offset is absolute from start of bytecode */
	219	struct logical_op {
	220	filter_opcode_t op;
	221	uint16_t skip_offset; /* bytecode insn, if skip second test */
	222	} LTTNG_PACKED;
	223
	224	struct cast_op {
	225	filter_opcode_t op;
	226	} LTTNG_PACKED;
	227
	228	struct return_op {
	229	filter_opcode_t op;
	230	} LTTNG_PACKED;
	231
	232	struct lttng_filter_bytecode_alloc {
	233	uint32_t alloc_len;
	234	struct lttng_filter_bytecode b;
	235	};
	236
	237	static inline
	238	unsigned int bytecode_get_len(struct lttng_filter_bytecode *bytecode)
	239	{
	240	return bytecode->len;
	241	}
	242
	243	#endif /* _FILTER_BYTECODE_H */