perfetto/public/consumer_api.h

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * 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.
 */

#ifndef INCLUDE_PERFETTO_PUBLIC_CONSUMER_API_H_
#define INCLUDE_PERFETTO_PUBLIC_CONSUMER_API_H_

#include <stddef.h>
#include <stdint.h>

// Public API for perfetto consumer, exposed to the rest of the Android tree.

namespace perfetto {
namespace consumer {

// State diagram (without error states):
// +-------------+
// | kConnecting |----------------------------+
// +-------------+                            | Create(deferred_start:true)
//        |  Create(deferred_start:false)     V
//        |                            +-------------+
//        |                            | kConfigured |
//        |                            +-------------+
//        |                                   |
//        V                                   | StartTracing()
//   +----------+                             |
//   | kTracing |<----------------------------+
//   +----------+
//        |
//        | [after TraceConfig.duration_ms]
//        V
// +-------------+
// | kTraceEnded |
// +-------------+
enum class State {
  // The trace session failed (e.g. the trace config is malformed or mmap
  // failed). Look at logcat -s perfetto to find out more.
  // This state is final and unrecoverable. The sessions needs to be destroyed
  // and recreated if this error happens.
  kTraceFailed = -3,

  // Failed to connect to the traced daemon.
  // This state is final and unrecoverable. The sessions needs to be destroyed
  // and recreated if this error happens.
  kConnectionError = -2,

  // Not really a state. This is only returned when an invalid handle is passed
  // to PollState().
  kSessionNotFound = -1,

  // Idle state.
  // This state is transitional an internal-only. Client will never see it.
  kIdle = 0,

  // Establishing the connection to the traced daemon.
  // This state is transitional. It is set soon after the Create() call and
  // transitions automatically to:
  // - kConfigured, if |deferred_start| == true in the trace config.
  // - kTracing, if |deferred_start| == false.
  // - An error state, e.g. if cannot reach the traced daemon.
  kConnecting = 1,

  // Tracing configured (buffers allocated) but not started.
  // This state is reached only when setting |deferred_start| == true and is
  // held until the client calls StartTracing().
  kConfigured = 2,

  // Tracing is active.
  // This state lasts for the whole duration of the trace session (i.e.
  // |duration_ms| in the trace config), after which the session transitions
  // either to the kTraceEnded state (if successful) or an error state.
  kTracing = 3,

  // Tracing ended succesfully. The trace buffer can now be retrieved through
  // the ReadTrace() call.
  // This state is final.
  kTraceEnded = 4,
};

using Handle = int64_t;
constexpr Handle kInvalidHandle = -1;

// Signature for callback function provided by the embedder to get notified
// about state changes.
using OnStateChangedCb = void (*)(Handle, State, void* /*callback_arg*/);

// None of the calls below are blocking, unless otherwise specified.

// Enables tracing with the given TraceConfig. If the trace config has the
// |deferred_start| flag set (see trace_config.proto) tracing is initialized
// but not started. An explicit call to StartTracing() must be issued in order
// to start the capture.
// Args:
//   [trace_config_proto, trace_config_len] point to a binary-encoded proto
//     containing the trace config. See //external/perfetto/docs/trace-config.md
//     for more details.
//   callback: a user-defined callback that will be invoked upon state changes.
//     The callback will be invoked on an internal thread and must not block.
//   callback_arg: an optional user-define argument that will be passed back to
//     all callback invocations.
// Return value:
//    Returns a handle that can be used to retrieve the trace or kInvalidHandle
//    in case of failure (e.g., the trace config is malformed).
Handle Create(const void* config_proto,
              size_t config_len,
              OnStateChangedCb callback,
              void* callback_arg);

// Starts recording the trace. Can be used only when setting the
// |deferred_start| flag in the trace config passed to Create().
// If the session is in the kConfigured state it transitions it to the kTracing
// state, starting the trace. In any other state, instead, it does nothing other
// than logging an error message. Hence, this method can be called only once.
// The estimated end-to-end (this call to ftrace enabling) latency is 2-3 ms
// on a Pixel 2.
// TODO(primiano): relax this and allow to recycle handles without
// re-configuring the trace session.
void StartTracing(Handle);

struct TraceBuffer {
  char* begin;
  size_t size;
};

// Retrieves the whole trace buffer. It avoids extra copies by directly mmaping
// the tmp fd passed to the traced daemon.
// Return value:
//   If the trace is ended (state == kTraceEnded) returns a buffer containing
//   the whole trace. This buffer can be parsed directly with libprotobuf.
//   The buffer lifetime is tied to the tracing session and is valid until the
//   Destroy() call.
//   If called before the session reaches the kTraceEnded state, a null buffer
//   is returned.
TraceBuffer ReadTrace(Handle);

// Destroys all the resources associated to the tracing session (connection to
// traced and trace buffer). The handle must not be used after this point.
// It's safe to call this regardless of the handle's current state and validity.
void Destroy(Handle);

// Returns the state of the tracing session (for debugging).
// Return value:
//   Returns the state of the session, if the handle is valid, otherwise returns
//   kSessionNotFound.
State PollState(Handle);

}  // namespace consumer
}  // namespace perfetto

#endif  // INCLUDE_PERFETTO_PUBLIC_CONSUMER_API_H_