/*
 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License (not later!)
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not,  see <http://www.gnu.org/licenses>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
#ifndef _PARSE_EVENTS_H
#define _PARSE_EVENTS_H

#include <stdbool.h>
#include <stdarg.h>
#include <stdio.h>
#include <regex.h>
#include <string.h>

#ifndef __maybe_unused
#define __maybe_unused __attribute__((unused))
#endif

/* ----------------------- trace_seq ----------------------- */


#ifndef TRACE_SEQ_BUF_SIZE
#define TRACE_SEQ_BUF_SIZE 4096
#endif

#ifndef DEBUG_RECORD
#define DEBUG_RECORD 0
#endif

struct pevent_record {
	unsigned long long	ts;
	unsigned long long	offset;
	long long		missed_events;	/* buffer dropped events before */
	int			record_size;	/* size of binary record */
	int			size;		/* size of data */
	void			*data;
	int			cpu;
	int			ref_count;
	int			locked;		/* Do not free, even if ref_count is zero */
	void			*priv;
#if DEBUG_RECORD
	struct pevent_record	*prev;
	struct pevent_record	*next;
	long			alloc_addr;
#endif
};

enum trace_seq_fail {
	TRACE_SEQ__GOOD,
	TRACE_SEQ__BUFFER_POISONED,
	TRACE_SEQ__MEM_ALLOC_FAILED,
};

/*
 * Trace sequences are used to allow a function to call several other functions
 * to create a string of data to use (up to a max of PAGE_SIZE).
 */

struct trace_seq {
	char			*buffer;
	unsigned int		buffer_size;
	unsigned int		len;
	unsigned int		readpos;
	enum trace_seq_fail	state;
};

void trace_seq_init(struct trace_seq *s);
void trace_seq_reset(struct trace_seq *s);
void trace_seq_destroy(struct trace_seq *s);

extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
	__attribute__ ((format (printf, 2, 3)));
extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
	__attribute__ ((format (printf, 2, 0)));

extern int trace_seq_puts(struct trace_seq *s, const char *str);
extern int trace_seq_putc(struct trace_seq *s, unsigned char c);

extern void trace_seq_terminate(struct trace_seq *s);

extern int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp);
extern int trace_seq_do_printf(struct trace_seq *s);


/* ----------------------- pevent ----------------------- */

struct pevent;
struct event_format;

typedef int (*pevent_event_handler_func)(struct trace_seq *s,
					 struct pevent_record *record,
					 struct event_format *event,
					 void *context);

typedef int (*pevent_plugin_load_func)(struct pevent *pevent);
typedef int (*pevent_plugin_unload_func)(struct pevent *pevent);

struct pevent_plugin_option {
	struct pevent_plugin_option	*next;
	void				*handle;
	char				*file;
	char				*name;
	char				*plugin_alias;
	char				*description;
	const char			*value;
	void				*priv;
	int				set;
};

/*
 * Plugin hooks that can be called:
 *
 * PEVENT_PLUGIN_LOADER:  (required)
 *   The function name to initialized the plugin.
 *
 *   int PEVENT_PLUGIN_LOADER(struct pevent *pevent)
 *
 * PEVENT_PLUGIN_UNLOADER:  (optional)
 *   The function called just before unloading
 *
 *   int PEVENT_PLUGIN_UNLOADER(struct pevent *pevent)
 *
 * PEVENT_PLUGIN_OPTIONS:  (optional)
 *   Plugin options that can be set before loading
 *
 *   struct pevent_plugin_option PEVENT_PLUGIN_OPTIONS[] = {
 *	{
 *		.name = "option-name",
 *		.plugin_alias = "overide-file-name", (optional)
 *		.description = "description of option to show users",
 *	},
 *	{
 *		.name = NULL,
 *	},
 *   };
 *
 *   Array must end with .name = NULL;
 *
 *
 *   .plugin_alias is used to give a shorter name to access
 *   the vairable. Useful if a plugin handles more than one event.
 *
 *   If .value is not set, then it is considered a boolean and only
 *   .set will be processed. If .value is defined, then it is considered
 *   a string option and .set will be ignored.
 *
 * PEVENT_PLUGIN_ALIAS: (optional)
 *   The name to use for finding options (uses filename if not defined)
 */
#define PEVENT_PLUGIN_LOADER pevent_plugin_loader
#define PEVENT_PLUGIN_UNLOADER pevent_plugin_unloader
#define PEVENT_PLUGIN_OPTIONS pevent_plugin_options
#define PEVENT_PLUGIN_ALIAS pevent_plugin_alias
#define _MAKE_STR(x)	#x
#define MAKE_STR(x)	_MAKE_STR(x)
#define PEVENT_PLUGIN_LOADER_NAME MAKE_STR(PEVENT_PLUGIN_LOADER)
#define PEVENT_PLUGIN_UNLOADER_NAME MAKE_STR(PEVENT_PLUGIN_UNLOADER)
#define PEVENT_PLUGIN_OPTIONS_NAME MAKE_STR(PEVENT_PLUGIN_OPTIONS)
#define PEVENT_PLUGIN_ALIAS_NAME MAKE_STR(PEVENT_PLUGIN_ALIAS)

#define NSECS_PER_SEC		1000000000ULL
#define NSECS_PER_USEC		1000ULL

enum format_flags {
	FIELD_IS_ARRAY		= 1,
	FIELD_IS_POINTER	= 2,
	FIELD_IS_SIGNED		= 4,
	FIELD_IS_STRING		= 8,
	FIELD_IS_DYNAMIC	= 16,
	FIELD_IS_LONG		= 32,
	FIELD_IS_FLAG		= 64,
	FIELD_IS_SYMBOLIC	= 128,
};

struct format_field {
	struct format_field	*next;
	struct event_format	*event;
	char			*type;
	char			*name;
	char			*alias;
	int			offset;
	int			size;
	unsigned int		arraylen;
	unsigned int		elementsize;
	unsigned long		flags;
};

struct format {
	int			nr_common;
	int			n<style>.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="c1"># Enable the creation of Neutron networks for isolated Overcloud</span>
<span class="c1"># traffic and configure each role to assign ports (related</span>
<span class="c1"># to that role) on these networks. This version of the environment</span>
<span class="c1"># has no dedicated VLAN for tunneling, for deployments that use</span>
<span class="c1"># VLAN mode, flat provider networks, etc.</span>
<span class="l l-Scalar l-Scalar-Plain">resource_registry</span><span class="p p-Indicator">:</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::External</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/external.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::InternalApi</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/internal_api.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::StorageMgmt</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/storage_mgmt.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::Storage</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/storage.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::Tenant</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/noop.yaml</span>
  <span class="c1"># Management network is optional and disabled by default.</span>
  <span class="c1"># To enable it, include environments/network-management.yaml</span>
  <span class="c1">#OS::TripleO::Network::Management: ../network/management.yaml</span>

  <span class="c1"># Port assignments for the VIPs</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::Ports::ExternalVipPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/external.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::Ports::InternalApiVipPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/internal_api.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::Ports::StorageVipPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::Ports::StorageMgmtVipPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage_mgmt.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Network::Ports::RedisVipPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/vip.yaml</span>

  <span class="c1"># Port assignments for the controller role</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Controller::Ports::ExternalPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/external.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Controller::Ports::InternalApiPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/internal_api.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Controller::Ports::StoragePort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Controller::Ports::StorageMgmtPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage_mgmt.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Controller::Ports::TenantPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="c1">#OS::TripleO::Controller::Ports::ManagementPort: ../network/ports/management.yaml</span>

  <span class="c1"># Port assignments for the compute role</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Compute::Ports::ExternalPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Compute::Ports::InternalApiPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/internal_api.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Compute::Ports::StoragePort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Compute::Ports::StorageMgmtPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::Compute::Ports::TenantPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="c1">#OS::TripleO::Compute::Ports::ManagementPort: ../network/ports/management.yaml</span>

  <span class="c1"># Port assignments for the ceph storage role</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::CephStorage::Ports::ExternalPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::CephStorage::Ports::InternalApiPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::CephStorage::Ports::StoragePort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::CephStorage::Ports::StorageMgmtPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage_mgmt.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::CephStorage::Ports::TenantPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="c1">#OS::TripleO::CephStorage::Ports::ManagementPort: ../network/ports/management.yaml</span>

  <span class="c1"># Port assignments for the swift storage role</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::SwiftStorage::Ports::ExternalPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::SwiftStorage::Ports::InternalApiPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/internal_api.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::SwiftStorage::Ports::StoragePort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::SwiftStorage::Ports::StorageMgmtPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage_mgmt.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::SwiftStorage::Ports::TenantPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="c1">#OS::TripleO::SwiftStorage::Ports::ManagementPort: ../network/ports/management.yaml</span>

  <span class="c1"># Port assignments for the block storage role</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::BlockStorage::Ports::ExternalPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::BlockStorage::Ports::InternalApiPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/internal_api.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::BlockStorage::Ports::StoragePort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::BlockStorage::Ports::StorageMgmtPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/storage_mgmt.yaml</span>
  <span class="l l-Scalar l-Scalar-Plain">OS::TripleO::BlockStorage::Ports::TenantPort</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">../network/ports/noop.yaml</span>
  <span class="c1">#OS::TripleO::BlockStorage::Ports::ManagementPort: ../network/ports/management.yaml</span>
</pre></div>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div id="lfcollabprojects-footer">
  <div class="gray-diagonal">
    <div class="footer-inner">
      <p>
        &copy; 2015
        <a href="https://opnfv.org/">Open Platform for NFV Project, Inc</a>., a
        Linux Foundation Collaborative Project. All Rights Reserved.
      </p>
      <p>
        Open Platform for NFV and OPNFV are trademarks of the Open Platform for
        NFV Project, Inc.
      </p>
      <p>
        Linux Foundation is a registered trademark of The Linux Foundation.
        Linux is a registered
        <a
          href="http://www.linuxfoundation.org/programs/legal/trademark"
          title="Linux Mark Institute"
          >trademark</a
        >
        of Linus Torvalds.
      </p>
      <p>
        Please see our
        <a href="https://opnfv.org/about/bylaws-and-policies/terms-use"
          >terms of use</a
        >,
        <a href="https://opnfv.org/about/bylaws-and-policies/trademarks"
          >trademark policy</a
        >, and
        <a href="https://opnfv.org/about/bylaws-and-policies/privacy-policy"
          >privacy policy</a
        >.
      </p>
    </div>
  </div>
</div>
</div> <!-- id=cgit -->
</body>
</html>
ndian)
{
	pevent->file_bigendian = endian;
}

static inline int pevent_is_host_bigendian(struct pevent *pevent)
{
	return pevent->host_bigendian;
}

static inline void pevent_set_host_bigendian(struct pevent *pevent, int endian)
{
	pevent->host_bigendian = endian;
}

static inline int pevent_is_latency_format(struct pevent *pevent)
{
	return pevent->latency_format;
}

static inline void pevent_set_latency_format(struct pevent *pevent, int lat)
{
	pevent->latency_format = lat;
}

struct pevent *pevent_alloc(void);
void pevent_free(struct pevent *pevent);
void pevent_ref(struct pevent *pevent);
void pevent_unref(struct pevent *pevent);

/* access to the internal parser */
void pevent_buffer_init(const char *buf, unsigned long long size);
enum event_type pevent_read_token(char **tok);
void pevent_free_token(char *token);
int pevent_peek_char(void);
const char *pevent_get_input_buf(void);
unsigned long long pevent_get_input_buf_ptr(void);

/* for debugging */
void pevent_print_funcs(struct pevent *pevent);
void pevent_print_printk(struct pevent *pevent);

/* ----------------------- filtering ----------------------- */

enum filter_boolean_type {
	FILTER_FALSE,
	FILTER_TRUE,
};

enum filter_op_type {
	FILTER_OP_AND = 1,
	FILTER_OP_OR,
	FILTER_OP_NOT,
};

enum filter_cmp_type {
	FILTER_CMP_NONE,
	FILTER_CMP_EQ,
	FILTER_CMP_NE,
	FILTER_CMP_GT,
	FILTER_CMP_LT,
	FILTER_CMP_GE,
	FILTER_CMP_LE,
	FILTER_CMP_MATCH,
	FILTER_CMP_NOT_MATCH,
	FILTER_CMP_REGEX,
	FILTER_CMP_NOT_REGEX,
};

enum filter_exp_type {
	FILTER_EXP_NONE,
	FILTER_EXP_ADD,
	FILTER_EXP_SUB,
	FILTER_EXP_MUL,
	FILTER_EXP_DIV,
	FILTER_EXP_MOD,
	FILTER_EXP_RSHIFT,
	FILTER_EXP_LSHIFT,
	FILTER_EXP_AND,
	FILTER_EXP_OR,
	FILTER_EXP_XOR,
	FILTER_EXP_NOT,
};

enum filter_arg_type {
	FILTER_ARG_NONE,
	FILTER_ARG_BOOLEAN,
	FILTER_ARG_VALUE,
	FILTER_ARG_FIELD,
	FILTER_ARG_EXP,
	FILTER_ARG_OP,
	FILTER_ARG_NUM,
	FILTER_ARG_STR,
};

enum filter_value_type {
	FILTER_NUMBER,
	FILTER_STRING,
	FILTER_CHAR
};

struct fliter_arg;

struct filter_arg_boolean {
	enum filter_boolean_type	value;
};

struct filter_arg_field {
	struct format_field	*field;
};

struct filter_arg_value {
	enum filter_value_type	type;
	union {
		char			*str;
		unsigned long long	val;
	};
};

struct filter_arg_op {
	enum filter_op_type	type;
	struct filter_arg	*left;
	struct filter_arg	*right;
};

struct filter_arg_exp {
	enum filter_exp_type	type;
	struct filter_arg	*left;
	struct filter_arg	*right;
};

struct filter_arg_num {
	enum filter_cmp_type	type;
	struct filter_arg	*left;
	struct filter_arg	*right;
};

struct filter_arg_str {
	enum filter_cmp_type	type;
	struct format_field	*field;
	char			*val;
	char			*buffer;
	regex_t			reg;
};

struct filter_arg {
	enum filter_arg_type	type;
	union {
		struct filter_arg_boolean	boolean;
		struct filter_arg_field		field;
		struct filter_arg_value		value;
		struct filter_arg_op		op;
		struct filter_arg_exp		exp;
		struct filter_arg_num		num;
		struct filter_arg_str		str;
	};
};

struct filter_type {
	int			event_id;
	struct event_format	*event;
	struct filter_arg	*filter;
};

#define PEVENT_FILTER_ERROR_BUFSZ  1024

struct event_filter {
	struct pevent		*pevent;
	int			filters;
	struct filter_type	*event_filters;
	char			error_buffer[PEVENT_FILTER_ERROR_BUFSZ];
};

struct event_filter *pevent_filter_alloc(struct pevent *pevent);

/* for backward compatibility */
#define FILTER_NONE		PEVENT_ERRNO__NO_FILTER
#define FILTER_NOEXIST		PEVENT_ERRNO__FILTER_NOT_FOUND
#define FILTER_MISS		PEVENT_ERRNO__FILTER_MISS
#define FILTER_MATCH		PEVENT_ERRNO__FILTER_MATCH

enum filter_trivial_type {
	FILTER_TRIVIAL_FALSE,
	FILTER_TRIVIAL_TRUE,
	FILTER_TRIVIAL_BOTH,
};

enum pevent_errno pevent_filter_add_filter_str(struct event_filter *filter,
					       const char *filter_str);

enum pevent_errno pevent_filter_match(struct event_filter *filter,
				      struct pevent_record *record);

int pevent_filter_strerror(struct event_filter *filter, enum pevent_errno err,
			   char *buf, size_t buflen);

int pevent_event_filtered(struct event_filter *filter,
			  int event_id);

void pevent_filter_reset(struct event_filter *filter);

int pevent_filter_clear_trivial(struct event_filter *filter,
				 enum filter_trivial_type type);

void pevent_filter_free(struct event_filter *filter);

char *pevent_filter_make_string(struct event_filter *filter, int event_id);

int pevent_filter_remove_event(struct event_filter *filter,
			       int event_id);

int pevent_filter_event_has_trivial(struct event_filter *filter,
				    int event_id,
				    enum filter_trivial_type type);

int pevent_filter_copy(struct event_filter *dest, struct event_filter *source);

int pevent_update_trivial(struct event_filter *dest, struct event_filter *source,
			  enum filter_trivial_type type);

int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2);

#endif /* _PARSE_EVENTS_H */