// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//
// The ABI-stable entry points used by trace instrumentation libraries.
//
// These functions are used to write trace records into the trace buffer
// associated with a trace context.
//
// Writing trace records is intended to be very fast but the cost varies
// depending on the size and complexity of the event and any arguments
// which are associated with it.
//
// At this time, there exists only one trace context, the engine's trace context,
// which can be acquired and released using the functions in
// <trace-engine/instrumentation.h>.  In the future, this API may be extended
// to support trace contexts with different scopes.
//
// Client code shouldn't be using these APIs directly.
// See <trace/event.h> for instrumentation macros.
//

#ifndef LIB_TRACE_ENGINE_CONTEXT_H_
#define LIB_TRACE_ENGINE_CONTEXT_H_

#include <lib/trace-engine/types.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <zircon/assert.h>
#include <zircon/compiler.h>
#include <zircon/syscalls/object.h>
#include <zircon/types.h>

__BEGIN_CDECLS

// Opaque type representing a trace context.
// Most functions in this header require a valid trace context to operate.
typedef struct trace_context trace_context_t;

// Opaque type representing a trace context that is held for prolonged
// periods of time.
typedef struct trace_prolonged_context trace_prolonged_context_t;

// Returns true if tracing of the specified category has been enabled.
//
// Use |trace_context_register_category_literal()| if you intend to immediately
// write a record into the trace buffer after checking the category.
//
// |context| must be a valid trace context reference.
// |category_literal| must be a null-terminated static string constant.
//
// This function is thread-safe.
bool trace_context_is_category_enabled(trace_context_t* context, const char* category_literal);

// Registers a copy of a string into the string table.
//
// Writes a string record into the trace buffer if the string was added to the
// string table.  If the string table is full, returns an inline string reference.
//
// |context| must be a valid trace context reference.
// |string| must be the string to register.
// |length| must be the length of the string.
// |out_ref| points to where the registered string reference should be returned.
//
// This function is thread-safe.
void trace_context_register_string_copy(trace_context_t* context, const char* string, size_t length,
                                        trace_string_ref_t* out_ref);

// Registers a copy of a string and returns its string ref.
// Helper for |trace_context_register_thread()|.
static inline trace_string_ref_t trace_context_make_registered_string_copy(trace_context_t* context,
                                                                           const char* string,
                                                                           size_t length) {
  trace_string_ref_t ref;
  trace_context_register_string_copy(context, string, length, &ref);
  return ref;
}

// Registers a string literal into the string table keyed by its address in memory.
//
// The trace context caches the string so that subsequent registrations using
// the same memory address may return the same indexed string reference if
// found in the cache.
//
// Writes a string record into the trace buffer if the string was added to the
// string table.  If the string table is full, returns an inline string reference.
//
// |context| must be a valid trace context reference.
// |string_literal| must be a null-terminated static string constant.
// |out_ref| points to where the registered string reference should be returned.
//
// This function is thread-safe.
void trace_context_register_string_literal(trace_context_t* context, const char* string_literal,
                                           trace_string_ref_t* out_ref);

// Registers a string literal and returns its string ref.
// Helper for |trace_context_register_string_literal()|.
static inline trace_string_ref_t trace_context_make_registered_string_literal(
    trace_context_t* context, const char* string_literal) {
  trace_string_ref_t ref;
  trace_context_register_string_literal(context, string_literal, &ref);
  return ref;
}

// Registers a category into the string table, if it is enabled, keyed by its
// address in memory.
//
// The trace context caches the string so that subsequent registrations using
// the same memory address may return the same indexed string reference if
// found in the cache.
//
// Writes a string record into the trace buffer if the category was added to the
// string table.  If the string table is full, returns an inline string reference.
//
// |context| must be a valid trace context reference.
// |category_literal| must be a null-terminated static string constant.
// |out_ref| points to where the registered string reference should be returned.
//
// Returns true and registers the string if the category is enabled, otherwise
// returns false and does not modify |*out_ref|.
//
// This function is thread-safe.
bool trace_context_register_category_literal(trace_context_t* context, const char* category_literal,
                                             trace_string_ref_t* out_ref);

// Registers the current thread into the thread table.
//
// Writes a process and/or thread kernel object record into the trace buffer if
// the process and/or thread have not previously been described.  Writes a
// thread record into the trace buffer if the thread was added to the thread table.
//
// If the thread table is full, returns an inline thread reference.
//
// |context| must be a valid trace context reference.
// |out_ref| points to where the registered thread reference should be returned.
//
// This function is thread-safe.
void trace_context_register_current_thread(trace_context_t* context, trace_thread_ref_t* out_ref);

// Registers the virtual thread into the thread table.
//
// Writes a thread record into the trace buffer if the virtual thread was added
// to the thread table.
//
// If the thread table is full, returns an inline thread reference.
//
// |context| must be a valid trace context reference.
// |process_koid| is the koid of the process which contains the thread.
//   If ZX_KOID_INVALID is passed, the koid of the current process is used.
// |vthread_literal| must be a null-terminated static string constant.
// |vthread_id| is the id of the virtual thread to register.
// |out_ref| points to where the registered thread reference should be returned.
//
// This function is thread-safe.
void trace_context_register_vthread(trace_context_t* context, zx_koid_t process_koid,
                                    const char* vthread_literal, trace_vthread_id_t vthread_id,
                                    trace_thread_ref_t* out_ref);

// Registers the specified thread into the thread table.
//
// Writes a thread record into the trace buffer if the thread was added to the
// thread table.
//
// If the thread table is full, returns an inline thread reference.
//
// Unlike |trace_context_register_current_thread()|, the caller is responsible for
// writing a process and/or thread kernel object record into the trace buffer
// if the process and/or thread have not previously been described.
//
// |context| must be a valid trace context reference.
// |process_koid| is the koid of the process which contains the thread.
// |thread_koid| is the koid of the thread to register.
// |out_ref| points to where the registered thread reference should be returned.
//
// This function is thread-safe.
void trace_context_register_thread(trace_context_t* context, zx_koid_t process_koid,
                                   zx_koid_t thread_koid, trace_thread_ref_t* out_ref);

// Registers a thread and returns its thread ref.
// Helper for |trace_context_register_thread()|.
static inline trace_thread_ref_t trace_context_make_registered_thread(trace_context_t* context,
                                                                      zx_koid_t process_koid,
                                                                      zx_koid_t thread_koid) {
  trace_thread_ref_t ref;
  trace_context_register_thread(context, process_koid, thread_koid, &ref);
  return ref;
}

// Allocate space for a blob and write its header.
// Returns a pointer to the "raw" contents of the blob,
// which must be filled in by the caller.
// Returns |nullptr| if there is no space in the buffer for |blob_size| bytes,
// or if |blob_size| is larger than TRACE_MAX_BLOB_SIZE.
// |context| must be a valid trace context reference.
// |type| is the blob type.
// |name_ref| is the name of the blob.
// |blob_size| is the size of the binary data to write.
// The caller is required to fill in the blob after we return.
// There is no need to zero out any padding, that has already been done.
void* trace_context_begin_write_blob_record(trace_context_t* context, trace_blob_type_t type,
                                            const trace_string_ref_t* name_ref, size_t blob_size);

// Write a blob of binary data into the trace buffer.
// Discards the record if it cannot be written.
// |context| must be a valid trace context reference.
// |type| is the blob type.
// |name_ref| is the name of the blob.
// |blob| is the binary data to write.
// |blob_size| is the size of the binary data to write.
void trace_context_write_blob_record(trace_context_t* context, trace_blob_type_t type,
                                     const trace_string_ref_t* name_ref, const void* blob,
                                     size_t blob_size);

// Sends an alert.
// |context| must be a valid trace context reference.
// |alert_name| is the name of the alert (max 14 characters).
//
// This function is thread-safe.
void trace_context_send_alert(trace_context_t* context, const char* alert_name);

// Writes a kernel object record for the object reference by the specified handle
// into the trace buffer.  Discards the record if it cannot be written.
//
// Collects the necessary information by querying the object's type and properties.
//
// |context| must be a valid trace context reference.
// |handle| is the handle of the object being described.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_kernel_object_record_for_handle(trace_context_t* context,
                                                         zx_handle_t handle,
                                                         const trace_arg_t* args, size_t num_args);

// Writes a kernel object record for the specified process into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |process_koid| is the koid of the process being described.
// |process_name_ref| is the name of the process.
//
// This function is thread-safe.
void trace_context_write_process_info_record(trace_context_t* context, zx_koid_t process_koid,
                                             const trace_string_ref_t* process_name_ref);

// Writes a kernel object record for the specified thread into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |process_koid| is the koid of the process which contains the thread.
// |thread_koid| is the koid of the thread being described.
// |thread_name_ref| is the name of the thread.
//
// This function is thread-safe.
void trace_context_write_thread_info_record(trace_context_t* context, zx_koid_t process_koid,
                                            zx_koid_t thread_koid,
                                            const trace_string_ref_t* thread_name_ref);

// Writes a context switch record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the time of the event, in ticks.
// |cpu_number| is the CPU upon which the context switch occurred.
// |outgoing_thread_state| is the state of the thread which was descheduled from the CPU.
// |outgoing_thread_ref| is the thread which was descheduled from the CPU.
// |incoming_thread_ref| is the thread which was scheduled on the CPU.
//
// This function is thread-safe.
void trace_context_write_context_switch_record(trace_context_t* context, trace_ticks_t event_time,
                                               trace_cpu_number_t cpu_number,
                                               trace_thread_state_t outgoing_thread_state,
                                               const trace_thread_ref_t* outgoing_thread_ref,
                                               const trace_thread_ref_t* incoming_thread_ref,
                                               trace_thread_priority_t outgoing_thread_priority,
                                               trace_thread_priority_t incoming_thread_priority);

// Writes a log record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the time of the event, in ticks.
// |thread_ref| is the thread which wrote the log message.
// |log_message| is the content of the log message.
// |log_message_length| is the length of the log message.
//
// This function is thread-safe.
void trace_context_write_log_record(trace_context_t* context, trace_ticks_t event_time,
                                    const trace_thread_ref_t* thread_ref, const char* log_message,
                                    size_t log_message_length);

// Writes an instant event record with arguments into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |scope| is the scope to which the instant event applies (thread, process, global).
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_instant_event_record(trace_context_t* context, trace_ticks_t event_time,
                                              const trace_thread_ref_t* thread_ref,
                                              const trace_string_ref_t* category_ref,
                                              const trace_string_ref_t* name_ref,
                                              trace_scope_t scope, const trace_arg_t* args,
                                              size_t num_args);

// Writes a counter event record with arguments into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |counter_id| is the correlation id of the counter.
//              Must be unique for a given process, category, and name combination.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_counter_event_record(trace_context_t* context, trace_ticks_t event_time,
                                              const trace_thread_ref_t* thread_ref,
                                              const trace_string_ref_t* category_ref,
                                              const trace_string_ref_t* name_ref,
                                              trace_counter_id_t counter_id,
                                              const trace_arg_t* args, size_t num_args);

// Writes a duration begin event record and a duration end event record with
// arguments into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |start_time| is the start time of the event, in ticks.
// |end_time| is the end time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_duration_event_record(trace_context_t* context, trace_ticks_t start_time,
                                               trace_ticks_t end_time,
                                               const trace_thread_ref_t* thread_ref,
                                               const trace_string_ref_t* category_ref,
                                               const trace_string_ref_t* name_ref,
                                               const trace_arg_t* args, size_t num_args);

// Writes a duration begin event record with arguments into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the start time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_duration_begin_event_record(trace_context_t* context,
                                                     trace_ticks_t event_time,
                                                     const trace_thread_ref_t* thread_ref,
                                                     const trace_string_ref_t* category_ref,
                                                     const trace_string_ref_t* name_ref,
                                                     const trace_arg_t* args, size_t num_args);

// Writes a duration end event record with arguments into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the end time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_duration_end_event_record(trace_context_t* context,
                                                   trace_ticks_t event_time,
                                                   const trace_thread_ref_t* thread_ref,
                                                   const trace_string_ref_t* category_ref,
                                                   const trace_string_ref_t* name_ref,
                                                   const trace_arg_t* args, size_t num_args);

// Writes an asynchronous begin event record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the start time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |async_id| is the correlation id of the asynchronous operation.
//            Must be unique for a given process, category, and name combination.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_async_begin_event_record(
    trace_context_t* context, trace_ticks_t event_time, const trace_thread_ref_t* thread_ref,
    const trace_string_ref_t* category_ref, const trace_string_ref_t* name_ref,
    trace_async_id_t async_id, const trace_arg_t* args, size_t num_args);

// Writes an asynchronous instant event record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |async_id| is the correlation id of the asynchronous operation.
//            Must be unique for a given process, category, and name combination.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_async_instant_event_record(
    trace_context_t* context, trace_ticks_t event_time, const trace_thread_ref_t* thread_ref,
    const trace_string_ref_t* category_ref, const trace_string_ref_t* name_ref,
    trace_async_id_t async_id, const trace_arg_t* args, size_t num_args);

// Writes an asynchronous end event record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the end time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |async_id| is the correlation id of the asynchronous operation.
//            Must be unique for a given process, category, and name combination.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_async_end_event_record(trace_context_t* context, trace_ticks_t event_time,
                                                const trace_thread_ref_t* thread_ref,
                                                const trace_string_ref_t* category_ref,
                                                const trace_string_ref_t* name_ref,
                                                trace_async_id_t async_id, const trace_arg_t* args,
                                                size_t num_args);

// Writes a flow begin event record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the start time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |flow_id| is the correlation id of the flow.
//           Must be unique for a given category and name combination.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_flow_begin_event_record(trace_context_t* context, trace_ticks_t event_time,
                                                 const trace_thread_ref_t* thread_ref,
                                                 const trace_string_ref_t* category_ref,
                                                 const trace_string_ref_t* name_ref,
                                                 trace_flow_id_t flow_id, const trace_arg_t* args,
                                                 size_t num_args);

// Writes a flow step event record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |flow_id| is the correlation id of the flow.
//           Must be unique for a given category and name combination.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_flow_step_event_record(trace_context_t* context, trace_ticks_t event_time,
                                                const trace_thread_ref_t* thread_ref,
                                                const trace_string_ref_t* category_ref,
                                                const trace_string_ref_t* name_ref,
                                                trace_flow_id_t flow_id, const trace_arg_t* args,
                                                size_t num_args);

// Writes a flow end event record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the end time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |flow_id| is the correlation id of the flow.
//           Must be unique for a given category and name combination.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_flow_end_event_record(trace_context_t* context, trace_ticks_t event_time,
                                               const trace_thread_ref_t* thread_ref,
                                               const trace_string_ref_t* category_ref,
                                               const trace_string_ref_t* name_ref,
                                               trace_flow_id_t flow_id, const trace_arg_t* args,
                                               size_t num_args);

// Writes a large blob record with metadata into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |event_time| is the time of the event, in ticks.
// |thread_ref| is the thread on which the event occurred.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |blob| is a pointer to the data, and contains |blob_size| bytes.
// |args| contains |num_args| key/value pairs to include in the record, or NULL if none.
//
// This function is thread-safe.
void trace_context_write_blob_event_record(trace_context_t* context, trace_ticks_t event_time,
                                           const trace_thread_ref_t* thread_ref,
                                           const trace_string_ref_t* category_ref,
                                           const trace_string_ref_t* name_ref, const void* blob,
                                           size_t blob_size, const trace_arg_t* args,
                                           size_t num_args);

// Writes a large blob record without metadata into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |category_ref| is the category of the event.
// |name_ref| is the name of the event.
// |blob| is a pointer to the data, and contains |blob_size| bytes.
//
// This function is thread-safe.
void trace_context_write_blob_attachment_record(trace_context_t* context,
                                                const trace_string_ref_t* category_ref,
                                                const trace_string_ref_t* name_ref,
                                                const void* blob, size_t blob_size);

// Writes an initialization record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |ticks_per_second| is the number of |trace_ticks_t| per second used in the trace.
//
// This function is thread-safe.
void trace_context_write_initialization_record(trace_context_t* context,
                                               zx_ticks_t ticks_per_second);

// Writes a string record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |index| is the index of the string, between |TRACE_ENCODED_STRING_REF_MIN_INDEX|
//         and |TRACE_ENCODED_STRING_REF_MAX_INDEX| inclusive.
// |string| is the content of the string.
// |length| is the length of the string; the string will be truncated if it is longer
//          than |TRACE_ENCODED_STRING_REF_MAX_LENGTH|.
//
// This function is thread-safe.
void trace_context_write_string_record(trace_context_t* context, trace_string_index_t index,
                                       const char* string, size_t length);

// Writes a thread record into the trace buffer.
// Discards the record if it cannot be written.
//
// |context| must be a valid trace context reference.
// |index| is the index of the thread, between |TRACE_ENCODED_THREAD_REF_MIN_INDEX|
//         and |TRACE_ENCODED_THREAD_REF_MAX_INDEX| inclusive.
// |process_koid| is the koid of the process which contains the thread.
// |thread_koid| is the koid of the thread being described.
//
// This function is thread-safe.
void trace_context_write_thread_record(trace_context_t* context, trace_thread_index_t index,
                                       zx_koid_t process_koid, zx_koid_t thread_koid);

// Allocates space for a record in the trace buffer.
//
// |context| must be a valid trace context reference.
// |num_bytes| must be a multiple of 8 bytes.
//
// Returns a pointer to the allocated space within the trace buffer with
// 8 byte alignment, or NULL if the trace buffer is full or if |num_bytes|
// exceeds |TRACE_ENCODED_RECORD_MAX_LENGTH|.
//
// This function is thread-safe, fail-fast, and lock-free.
void* trace_context_alloc_record(trace_context_t* context, size_t num_bytes);

trace_buffering_mode_t trace_context_get_buffering_mode(const trace_context_t* context);

__END_CDECLS

#endif  // LIB_TRACE_ENGINE_CONTEXT_H_