Quellverzeichnis perf_event.h Sprache: C

/*
* Performance events:
*
*    Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
*    Copyright (C) 2008-2011, Red Hat, Inc., Ingo Molnar
*    Copyright (C) 2008-2011, Red Hat, Inc., Peter Zijlstra
*
* Data type definitions, declarations, prototypes.
*
*    Started by: Thomas Gleixner and Ingo Molnar
*
* For licencing details see kernel-base/COPYING
*/
#ifndef _LINUX_PERF_EVENT_H
#define _LINUX_PERF_EVENT_H

#include <uapi/linux/perf_event.h>
#include <uapi/linux/bpf_perf_event.h>

/*
* Kernel-internal data types and definitions:
*/

#ifdef CONFIG_PERF_EVENTS
# include <asm/perf_event.h>
# include <asm/local64.h>
#endif

#ifdef CONFIG_HAVE_HW_BREAKPOINT
# include <linux/rhashtable-types.h>
# include <asm/hw_breakpoint.h>
#endif

#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/rculist.h>
#include <linux/rcupdate.h>
#include <linux/spinlock.h>
#include <linux/hrtimer.h>
#include <linux/fs.h>
#include <linux/pid_namespace.h>
#include <linux/workqueue.h>
#include <linux/ftrace.h>
#include <linux/cpu.h>
#include <linux/irq_work.h>
#include <linux/static_key.h>
#include <linux/jump_label_ratelimit.h>
#include <linux/atomic.h>
#include <linux/sysfs.h>
#include <linux/perf_regs.h>
#include <linux/cgroup.h>
#include <linux/refcount.h>
#include <linux/security.h>
#include <linux/static_call.h>
#include <linux/lockdep.h>

#include <asm/local.h>

struct perf_callchain_entry {
u64    nr;
u64    ip[]; /* /proc/sys/kernel/perf_event_max_stack */
};

struct perf_callchain_entry_ctx {
struct perf_callchain_entry *entry;
u32    max_stack;
u32    nr;
short    contexts;
bool    contexts_maxed;
};

typedef unsigned long (*perf_copy_f)(void *dst, const void *src,
         unsigned long off, unsigned long len);

struct perf_raw_frag {
union {
  struct perf_raw_frag *next;
  unsigned long  pad;
};
perf_copy_f   copy;
void    *data;
u32    size;
} __packed;

struct perf_raw_record {
struct perf_raw_frag  frag;
u32    size;
};

static __always_inline bool perf_raw_frag_last(const struct perf_raw_frag *frag)
{
return frag->pad < sizeof(u64);
}

/*
* branch stack layout:
*  nr: number of taken branches stored in entries[]
*  hw_idx: The low level index of raw branch records
*          for the most recent branch.
*          -1ULL means invalid/unknown.
*
* Note that nr can vary from sample to sample
* branches (to, from) are stored from most recent
* to least recent, i.e., entries[0] contains the most
* recent branch.
* The entries[] is an abstraction of raw branch records,
* which may not be stored in age order in HW, e.g. Intel LBR.
* The hw_idx is to expose the low level index of raw
* branch record for the most recent branch aka entries[0].
* The hw_idx index is between -1 (unknown) and max depth,
* which can be retrieved in /sys/devices/cpu/caps/branches.
* For the architectures whose raw branch records are
* already stored in age order, the hw_idx should be 0.
*/
struct perf_branch_stack {
u64    nr;
u64    hw_idx;
struct perf_branch_entry entries[];
};

struct task_struct;

/*
* extra PMU register associated with an event
*/
struct hw_perf_event_extra {
u64    config; /* register value */
unsigned int   reg; /* register address or index */
int    alloc; /* extra register already allocated */
int    idx; /* index in shared_regs->regs[] */
};

/**
* hw_perf_event::flag values
*
* PERF_EVENT_FLAG_ARCH bits are reserved for architecture-specific
* usage.
*/
#define PERF_EVENT_FLAG_ARCH  0x0fffffff
#define PERF_EVENT_FLAG_USER_READ_CNT 0x80000000

static_assert((PERF_EVENT_FLAG_USER_READ_CNT & PERF_EVENT_FLAG_ARCH) == 0);

/**
* struct hw_perf_event - performance event hardware details:
*/
struct hw_perf_event {
#ifdef CONFIG_PERF_EVENTS
union {
  struct { /* hardware */
   u64  config;
   u64  config1;
   u64  last_tag;
   u64  dyn_constraint;
   unsigned long config_base;
   unsigned long event_base;
   int  event_base_rdpmc;
   int  idx;
   int  last_cpu;
   int  flags;

   struct hw_perf_event_extra extra_reg;
   struct hw_perf_event_extra branch_reg;
  };
  struct { /* aux / Intel-PT */
   u64  aux_config;
   /*
* For AUX area events, aux_paused cannot be a state
* flag because it can be updated asynchronously to
* state.
*/
   unsigned int aux_paused;
  };
  struct { /* software */
   struct hrtimer hrtimer;
  };
  struct { /* tracepoint */
   /* for tp_event->class */
   struct list_head tp_list;
  };
  struct { /* amd_power */
   u64 pwr_acc;
   u64 ptsc;
  };
#ifdef CONFIG_HAVE_HW_BREAKPOINT
  struct { /* breakpoint */
   /*
* Crufty hack to avoid the chicken and egg
* problem hw_breakpoint has with context
* creation and event initalization.
*/
   struct arch_hw_breakpoint info;
   struct rhlist_head  bp_list;
  };
#endif
  struct { /* amd_iommu */
   u8 iommu_bank;
   u8 iommu_cntr;
   u16 padding;
   u64 conf;
   u64 conf1;
  };
};
/*
* If the event is a per task event, this will point to the task in
* question. See the comment in perf_event_alloc().
*/
struct task_struct  *target;

/*
* PMU would store hardware filter configuration
* here.
*/
void    *addr_filters;

/* Last sync'ed generation of filters */
unsigned long   addr_filters_gen;

/*
* hw_perf_event::state flags; used to track the PERF_EF_* state.
*/

/* the counter is stopped */
#define PERF_HES_STOPPED  0x01

/* event->count up-to-date */
#define PERF_HES_UPTODATE  0x02

#define PERF_HES_ARCH   0x04

int    state;

/*
* The last observed hardware counter value, updated with a
* local64_cmpxchg() such that pmu::read() can be called nested.
*/
local64_t   prev_count;

/*
* The period to start the next sample with.
*/
u64    sample_period;

union {
  struct { /* Sampling */
   /*
* The period we started this sample with.
*/
   u64    last_period;

   /*
* However much is left of the current period;
* note that this is a full 64bit value and
* allows for generation of periods longer
* than hardware might allow.
*/
   local64_t   period_left;
  };
  struct { /* Topdown events counting for context switch */
   u64    saved_metric;
   u64    saved_slots;
  };
};

/*
* State for throttling the event, see __perf_event_overflow() and
* perf_adjust_freq_unthr_context().
*/
u64                             interrupts_seq;
u64    interrupts;

/*
* State for freq target events, see __perf_event_overflow() and
* perf_adjust_freq_unthr_context().
*/
u64    freq_time_stamp;
u64    freq_count_stamp;
#endif /* CONFIG_PERF_EVENTS */
};

struct perf_event;
struct perf_event_pmu_context;

/*
* Common implementation detail of pmu::{start,commit,cancel}_txn
*/

/* txn to add/schedule event on PMU */
#define PERF_PMU_TXN_ADD  0x1

/* txn to read event group from PMU */
#define PERF_PMU_TXN_READ  0x2

/**
* pmu::capabilities flags
*/
#define PERF_PMU_CAP_NO_INTERRUPT 0x0001
#define PERF_PMU_CAP_NO_NMI  0x0002
#define PERF_PMU_CAP_AUX_NO_SG  0x0004
#define PERF_PMU_CAP_EXTENDED_REGS 0x0008
#define PERF_PMU_CAP_EXCLUSIVE  0x0010
#define PERF_PMU_CAP_ITRACE  0x0020
#define PERF_PMU_CAP_NO_EXCLUDE  0x0040
#define PERF_PMU_CAP_AUX_OUTPUT  0x0080
#define PERF_PMU_CAP_EXTENDED_HW_TYPE 0x0100
#define PERF_PMU_CAP_AUX_PAUSE  0x0200
#define PERF_PMU_CAP_AUX_PREFER_LARGE 0x0400

/**
* pmu::scope
*/
enum perf_pmu_scope {
PERF_PMU_SCOPE_NONE = 0,
PERF_PMU_SCOPE_CORE,
PERF_PMU_SCOPE_DIE,
PERF_PMU_SCOPE_CLUSTER,
PERF_PMU_SCOPE_PKG,
PERF_PMU_SCOPE_SYS_WIDE,
PERF_PMU_MAX_SCOPE,
};

struct perf_output_handle;

#define PMU_NULL_DEV ((void *)(~0UL))

/**
* struct pmu - generic performance monitoring unit
*/
struct pmu {
struct list_head  entry;

spinlock_t   events_lock;
struct list_head  events;

struct module   *module;
struct device   *dev;
struct device   *parent;
const struct attribute_group **attr_groups;
const struct attribute_group **attr_update;
const char   *name;
int    type;

/*
* various common per-pmu feature flags
*/
int    capabilities;

/*
* PMU scope
*/
unsigned int   scope;

struct perf_cpu_pmu_context * __percpu *cpu_pmu_context;
atomic_t   exclusive_cnt; /* < 0: cpu; > 0: tsk */
int    task_ctx_nr;
int    hrtimer_interval_ms;

/* number of address filters this PMU can do */
unsigned int   nr_addr_filters;

/*
* Fully disable/enable this PMU, can be used to protect from the PMI
* as well as for lazy/batch writing of the MSRs.
*/
void (*pmu_enable)  (struct pmu *pmu); /* optional */
void (*pmu_disable)  (struct pmu *pmu); /* optional */

/*
* Try and initialize the event for this PMU.
*
* Returns:
*  -ENOENT -- @event is not for this PMU
*
*  -ENODEV -- @event is for this PMU but PMU not present
*  -EBUSY -- @event is for this PMU but PMU temporarily unavailable
*  -EINVAL -- @event is for this PMU but @event is not valid
*  -EOPNOTSUPP -- @event is for this PMU, @event is valid, but not supported
*  -EACCES -- @event is for this PMU, @event is valid, but no privileges
*
*  0 -- @event is for this PMU and valid
*
* Other error return values are allowed.
*/
int (*event_init)  (struct perf_event *event);

/*
* Notification that the event was mapped or unmapped.  Called
* in the context of the mapping task.
*/
void (*event_mapped)  (struct perf_event *event, struct mm_struct *mm); /* optional */
void (*event_unmapped)  (struct perf_event *event, struct mm_struct *mm); /* optional */

/*
* Flags for ->add()/->del()/ ->start()/->stop(). There are
* matching hw_perf_event::state flags.
*/

/* start the counter when adding    */
#define PERF_EF_START   0x01

/* reload the counter when starting */
#define PERF_EF_RELOAD   0x02

/* update the counter when stopping */
#define PERF_EF_UPDATE   0x04

/* AUX area event, pause tracing */
#define PERF_EF_PAUSE   0x08

/* AUX area event, resume tracing */
#define PERF_EF_RESUME   0x10

/*
* Adds/Removes a counter to/from the PMU, can be done inside a
* transaction, see the ->*_txn() methods.
*
* The add/del callbacks will reserve all hardware resources required
* to service the event, this includes any counter constraint
* scheduling etc.
*
* Called with IRQs disabled and the PMU disabled on the CPU the event
* is on.
*
* ->add() called without PERF_EF_START should result in the same state
*  as ->add() followed by ->stop().
*
* ->del() must always PERF_EF_UPDATE stop an event. If it calls
*  ->stop() that must deal with already being stopped without
*  PERF_EF_UPDATE.
*/
int  (*add)   (struct perf_event *event, int flags);
void (*del)   (struct perf_event *event, int flags);

/*
* Starts/Stops a counter present on the PMU.
*
* The PMI handler should stop the counter when perf_event_overflow()
* returns !0. ->start() will be used to continue.
*
* Also used to change the sample period.
*
* Called with IRQs disabled and the PMU disabled on the CPU the event
* is on -- will be called from NMI context with the PMU generates
* NMIs.
*
* ->stop() with PERF_EF_UPDATE will read the counter and update
*  period/count values like ->read() would.
*
* ->start() with PERF_EF_RELOAD will reprogram the counter
*  value, must be preceded by a ->stop() with PERF_EF_UPDATE.
*
* ->stop() with PERF_EF_PAUSE will stop as simply as possible. Will not
* overlap another ->stop() with PERF_EF_PAUSE nor ->start() with
* PERF_EF_RESUME.
*
* ->start() with PERF_EF_RESUME will start as simply as possible but
* only if the counter is not otherwise stopped. Will not overlap
* another ->start() with PERF_EF_RESUME nor ->stop() with
* PERF_EF_PAUSE.
*
* Notably, PERF_EF_PAUSE/PERF_EF_RESUME *can* be concurrent with other
* ->stop()/->start() invocations, just not itself.
*/
void (*start)   (struct perf_event *event, int flags);
void (*stop)   (struct perf_event *event, int flags);

/*
* Updates the counter value of the event.
*
* For sampling capable PMUs this will also update the software period
* hw_perf_event::period_left field.
*/
void (*read)   (struct perf_event *event);

/*
* Group events scheduling is treated as a transaction, add
* group events as a whole and perform one schedulability test.
* If the test fails, roll back the whole group
*
* Start the transaction, after this ->add() doesn't need to
* do schedulability tests.
*
* Optional.
*/
void (*start_txn)  (struct pmu *pmu, unsigned int txn_flags);
/*
* If ->start_txn() disabled the ->add() schedulability test
* then ->commit_txn() is required to perform one. On success
* the transaction is closed. On error the transaction is kept
* open until ->cancel_txn() is called.
*
* Optional.
*/
int  (*commit_txn)  (struct pmu *pmu);
/*
* Will cancel the transaction, assumes ->del() is called
* for each successful ->add() during the transaction.
*
* Optional.
*/
void (*cancel_txn)  (struct pmu *pmu);

/*
* Will return the value for perf_event_mmap_page::index for this event,
* if no implementation is provided it will default to 0 (see
* perf_event_idx_default).
*/
int (*event_idx)  (struct perf_event *event); /*optional */

/*
* context-switches callback
*/
void (*sched_task)  (struct perf_event_pmu_context *pmu_ctx,
      struct task_struct *task, bool sched_in);

/*
* Kmem cache of PMU specific data
*/
struct kmem_cache  *task_ctx_cache;

/*
* Set up pmu-private data structures for an AUX area
*/
void *(*setup_aux)  (struct perf_event *event, void **pages,
      int nr_pages, bool overwrite);
     /* optional */

/*
* Free pmu-private AUX data structures
*/
void (*free_aux)  (void *aux); /* optional */

/*
* Take a snapshot of the AUX buffer without touching the event
* state, so that preempting ->start()/->stop() callbacks does
* not interfere with their logic. Called in PMI context.
*
* Returns the size of AUX data copied to the output handle.
*
* Optional.
*/
long (*snapshot_aux)  (struct perf_event *event,
      struct perf_output_handle *handle,
      unsigned long size);

/*
* Validate address range filters: make sure the HW supports the
* requested configuration and number of filters; return 0 if the
* supplied filters are valid, -errno otherwise.
*
* Runs in the context of the ioctl()ing process and is not serialized
* with the rest of the PMU callbacks.
*/
int (*addr_filters_validate) (struct list_head *filters);
     /* optional */

/*
* Synchronize address range filter configuration:
* translate hw-agnostic filters into hardware configuration in
* event::hw::addr_filters.
*
* Runs as a part of filter sync sequence that is done in ->start()
* callback by calling perf_event_addr_filters_sync().
*
* May (and should) traverse event::addr_filters::list, for which its
* caller provides necessary serialization.
*/
void (*addr_filters_sync) (struct perf_event *event);
     /* optional */

/*
* Check if event can be used for aux_output purposes for
* events of this PMU.
*
* Runs from perf_event_open(). Should return 0 for "no match"
* or non-zero for "match".
*/
int (*aux_output_match)  (struct perf_event *event);
     /* optional */

/*
* Skip programming this PMU on the given CPU. Typically needed for
* big.LITTLE things.
*/
bool (*filter)   (struct pmu *pmu, int cpu); /* optional */

/*
* Check period value for PERF_EVENT_IOC_PERIOD ioctl.
*/
int (*check_period)  (struct perf_event *event, u64 value); /* optional */
};

enum perf_addr_filter_action_t {
PERF_ADDR_FILTER_ACTION_STOP = 0,
PERF_ADDR_FILTER_ACTION_START,
PERF_ADDR_FILTER_ACTION_FILTER,
};

/**
* struct perf_addr_filter - address range filter definition
* @entry: event's filter list linkage
* @path: object file's path for file-based filters
* @offset: filter range offset
* @size: filter range size (size==0 means single address trigger)
* @action: filter/start/stop
*
* This is a hardware-agnostic filter configuration as specified by the user.
*/
struct perf_addr_filter {
struct list_head  entry;
struct path   path;
unsigned long   offset;
unsigned long   size;
enum perf_addr_filter_action_t action;
};

/**
* struct perf_addr_filters_head - container for address range filters
* @list: list of filters for this event
* @lock: spinlock that serializes accesses to the @list and event's
* (and its children's) filter generations.
* @nr_file_filters: number of file-based filters
*
* A child event will use parent's @list (and therefore @lock), so they are
* bundled together; see perf_event_addr_filters().
*/
struct perf_addr_filters_head {
struct list_head  list;
raw_spinlock_t   lock;
unsigned int   nr_file_filters;
};

struct perf_addr_filter_range {
unsigned long   start;
unsigned long   size;
};

/*
* The normal states are:
*
*            ACTIVE    --.
*               ^        |
*               |        |
*       sched_{in,out}() |
*               |        |
*               v        |
*      ,---> INACTIVE  --+ <-.
*      |                 |   |
*      |                {dis,en}able()
*   sched_in()           |   |
*      |       OFF    <--' --+
*      |                     |
*      `--->  ERROR    ------'
*
* That is:
*
* sched_in:       INACTIVE          -> {ACTIVE,ERROR}
* sched_out:      ACTIVE            -> INACTIVE
* disable:        {ACTIVE,INACTIVE} -> OFF
* enable:         {OFF,ERROR}       -> INACTIVE
*
* Where {OFF,ERROR} are disabled states.
*
* Then we have the {EXIT,REVOKED,DEAD} states which are various shades of
* defunct events:
*
*  - EXIT means task that the even was assigned to died, but child events
*    still live, and further children can still be created. But the event
*    itself will never be active again. It can only transition to
*    {REVOKED,DEAD};
*
*  - REVOKED means the PMU the event was associated with is gone; all
*    functionality is stopped but the event is still alive. Can only
*    transition to DEAD;
*
*  - DEAD event really is DYING tearing down state and freeing bits.
*
*/
enum perf_event_state {
PERF_EVENT_STATE_DEAD  = -5,
PERF_EVENT_STATE_REVOKED = -4, /* pmu gone, must not touch */
PERF_EVENT_STATE_EXIT  = -3, /* task died, still inherit */
PERF_EVENT_STATE_ERROR  = -2, /* scheduling error, can enable */
PERF_EVENT_STATE_OFF  = -1,
PERF_EVENT_STATE_INACTIVE =  0,
PERF_EVENT_STATE_ACTIVE  =  1,
};

struct file;
struct perf_sample_data;

typedef void (*perf_overflow_handler_t)(struct perf_event *,
     struct perf_sample_data *,
     struct pt_regs *regs);

/*
* Event capabilities. For event_caps and groups caps.
*
* PERF_EV_CAP_SOFTWARE: Is a software event.
* PERF_EV_CAP_READ_ACTIVE_PKG: A CPU event (or cgroup event) that can be read
* from any CPU in the package where it is active.
* PERF_EV_CAP_SIBLING: An event with this flag must be a group sibling and
* cannot be a group leader. If an event with this flag is detached from the
* group it is scheduled out and moved into an unrecoverable ERROR state.
* PERF_EV_CAP_READ_SCOPE: A CPU event that can be read from any CPU of the
* PMU scope where it is active.
*/
#define PERF_EV_CAP_SOFTWARE  BIT(0)
#define PERF_EV_CAP_READ_ACTIVE_PKG BIT(1)
#define PERF_EV_CAP_SIBLING  BIT(2)
#define PERF_EV_CAP_READ_SCOPE  BIT(3)

#define SWEVENT_HLIST_BITS  8
#define SWEVENT_HLIST_SIZE  (1 << SWEVENT_HLIST_BITS)

struct swevent_hlist {
struct hlist_head  heads[SWEVENT_HLIST_SIZE];
struct rcu_head   rcu_head;
};

#define PERF_ATTACH_CONTEXT  0x0001
#define PERF_ATTACH_GROUP  0x0002
#define PERF_ATTACH_TASK  0x0004
#define PERF_ATTACH_TASK_DATA  0x0008
#define PERF_ATTACH_GLOBAL_DATA  0x0010
#define PERF_ATTACH_SCHED_CB  0x0020
#define PERF_ATTACH_CHILD  0x0040
#define PERF_ATTACH_EXCLUSIVE  0x0080
#define PERF_ATTACH_CALLCHAIN  0x0100
#define PERF_ATTACH_ITRACE  0x0200

struct bpf_prog;
struct perf_cgroup;
struct perf_buffer;

struct pmu_event_list {
raw_spinlock_t   lock;
struct list_head  list;
};

/*
* event->sibling_list is modified whole holding both ctx->lock and ctx->mutex
* as such iteration must hold either lock. However, since ctx->lock is an IRQ
* safe lock, and is only held by the CPU doing the modification, having IRQs
* disabled is sufficient since it will hold-off the IPIs.
*/
#ifdef CONFIG_PROVE_LOCKING
# define lockdep_assert_event_ctx(event)   \
WARN_ON_ONCE(__lockdep_enabled &&   \
       (this_cpu_read(hardirqs_enabled) && \
        lockdep_is_held(&(event)->ctx->mutex) != LOCK_STATE_HELD))
#else
# define lockdep_assert_event_ctx(event)
#endif

#define for_each_sibling_event(sibling, event)   \
lockdep_assert_event_ctx(event);   \
if ((event)->group_leader == (event))   \
  list_for_each_entry((sibling), &(event)->sibling_list, sibling_list)

/**
* struct perf_event - performance event kernel representation:
*/
struct perf_event {
#ifdef CONFIG_PERF_EVENTS
/*
* entry onto perf_event_context::event_list;
*   modifications require ctx->lock
*   RCU safe iterations.
*/
struct list_head  event_entry;

/*
* Locked for modification by both ctx->mutex and ctx->lock; holding
* either sufficies for read.
*/
struct list_head  sibling_list;
struct list_head  active_list;
/*
* Node on the pinned or flexible tree located at the event context;
*/
struct rb_node   group_node;
u64    group_index;
/*
* We need storage to track the entries in perf_pmu_migrate_context; we
* cannot use the event_entry because of RCU and we want to keep the
* group in tact which avoids us using the other two entries.
*/
struct list_head  migrate_entry;

struct hlist_node  hlist_entry;
struct list_head  active_entry;
int    nr_siblings;

/* Not serialized. Only written during event initialization. */
int    event_caps;
/* The cumulative AND of all event_caps for events in this group. */
int    group_caps;

unsigned int   group_generation;
struct perf_event  *group_leader;
/*
* event->pmu will always point to pmu in which this event belongs.
* Whereas event->pmu_ctx->pmu may point to other pmu when group of
* different pmu events is created.
*/
struct pmu   *pmu;
void    *pmu_private;

enum perf_event_state  state;
unsigned int   attach_state;
local64_t   count;
atomic64_t   child_count;

/*
* These are the total time in nanoseconds that the event
* has been enabled (i.e. eligible to run, and the task has
* been scheduled in, if this is a per-task event)
* and running (scheduled onto the CPU), respectively.
*/
u64    total_time_enabled;
u64    total_time_running;
u64    tstamp;

struct perf_event_attr  attr;
u16    header_size;
u16    id_header_size;
u16    read_size;
struct hw_perf_event  hw;

struct perf_event_context *ctx;
/*
* event->pmu_ctx points to perf_event_pmu_context in which the event
* is added. This pmu_ctx can be of other pmu for sw event when that
* sw event is part of a group which also contains non-sw events.
*/
struct perf_event_pmu_context *pmu_ctx;
atomic_long_t   refcount;

/*
* These accumulate total time (in nanoseconds) that children
* events have been enabled and running, respectively.
*/
atomic64_t   child_total_time_enabled;
atomic64_t   child_total_time_running;

/*
* Protect attach/detach and child_list:
*/
struct mutex   child_mutex;
struct list_head  child_list;
struct perf_event  *parent;

int    oncpu;
int    cpu;

struct list_head  owner_entry;
struct task_struct  *owner;

/* mmap bits */
struct mutex   mmap_mutex;
atomic_t   mmap_count;

struct perf_buffer  *rb;
struct list_head  rb_entry;
unsigned long   rcu_batches;
int    rcu_pending;

/* poll related */
wait_queue_head_t  waitq;
struct fasync_struct  *fasync;

/* delayed work for NMIs and such */
unsigned int   pending_wakeup;
unsigned int   pending_kill;
unsigned int   pending_disable;
unsigned long   pending_addr; /* SIGTRAP */
struct irq_work   pending_irq;
struct irq_work   pending_disable_irq;
struct callback_head  pending_task;
unsigned int   pending_work;

atomic_t   event_limit;

/* address range filters */
struct perf_addr_filters_head addr_filters;
/* vma address array for file-based filders */
struct perf_addr_filter_range *addr_filter_ranges;
unsigned long   addr_filters_gen;

/* for aux_output events */
struct perf_event  *aux_event;

void (*destroy)(struct perf_event *);
struct rcu_head   rcu_head;

struct pid_namespace  *ns;
u64    id;

atomic64_t   lost_samples;

u64    (*clock)(void);
perf_overflow_handler_t  overflow_handler;
void    *overflow_handler_context;
struct bpf_prog   *prog;
u64    bpf_cookie;

#ifdef CONFIG_EVENT_TRACING
struct trace_event_call  *tp_event;
struct event_filter  *filter;
# ifdef CONFIG_FUNCTION_TRACER
struct ftrace_ops               ftrace_ops;
# endif
#endif

#ifdef CONFIG_CGROUP_PERF
struct perf_cgroup  *cgrp; /* cgroup event is attach to */
#endif

#ifdef CONFIG_SECURITY
void *security;
#endif
struct list_head  sb_list;
struct list_head  pmu_list;

/*
* Certain events gets forwarded to another pmu internally by over-
* writing kernel copy of event->attr.type without user being aware
* of it. event->orig_type contains original 'type' requested by
* user.
*/
u32    orig_type;
#endif /* CONFIG_PERF_EVENTS */
};

/*
*           ,-----------------------[1:n]------------------------.
*           V                                                    V
* perf_event_context <-[1:n]-> perf_event_pmu_context <-[1:n]- perf_event
*                                        |                       |
*                                        `--[n:1]-> pmu <-[1:n]--'
*
*
* struct perf_event_pmu_context  lifetime is refcount based and RCU freed
* (similar to perf_event_context). Locking is as if it were a member of
* perf_event_context; specifically:
*
*   modification, both: ctx->mutex && ctx->lock
*   reading, either:    ctx->mutex || ctx->lock
*
* There is one exception to this; namely put_pmu_ctx() isn't always called
* with ctx->mutex held; this means that as long as we can guarantee the epc
* has events the above rules hold.
*
* Specificially, sys_perf_event_open()'s group_leader case depends on
* ctx->mutex pinning the configuration. Since we hold a reference on
* group_leader (through the filedesc) it can't go away, therefore it's
* associated pmu_ctx must exist and cannot change due to ctx->mutex.
*
* perf_event holds a refcount on perf_event_context
* perf_event holds a refcount on perf_event_pmu_context
*/
struct perf_event_pmu_context {
struct pmu   *pmu;
struct perf_event_context       *ctx;

struct list_head  pmu_ctx_entry;

struct list_head  pinned_active;
struct list_head  flexible_active;

/* Used to identify the per-cpu perf_event_pmu_context */
unsigned int   embedded : 1;

unsigned int   nr_events;
unsigned int   nr_cgroups;
unsigned int   nr_freq;

atomic_t   refcount; /* event <-> epc */
struct rcu_head   rcu_head;

/*
* Set when one or more (plausibly active) event can't be scheduled
* due to pmu overcommit or pmu constraints, except tolerant to
* events not necessary to be active due to scheduling constraints,
* such as cgroups.
*/
int    rotate_necessary;
};

static inline bool perf_pmu_ctx_is_active(struct perf_event_pmu_context *epc)
{
return !list_empty(&epc->flexible_active) || !list_empty(&epc->pinned_active);
}

struct perf_event_groups {
struct rb_root   tree;
u64    index;
};

/**
* struct perf_event_context - event context structure
*
* Used as a container for task events and CPU events as well:
*/
struct perf_event_context {
/*
* Protect the states of the events in the list,
* nr_active, and the list:
*/
raw_spinlock_t   lock;
/*
* Protect the list of events.  Locking either mutex or lock
* is sufficient to ensure the list doesn't change; to change
* the list you need to lock both the mutex and the spinlock.
*/
struct mutex   mutex;

struct list_head  pmu_ctx_list;
struct perf_event_groups pinned_groups;
struct perf_event_groups flexible_groups;
struct list_head  event_list;

int    nr_events;
int    nr_user;
int    is_active;

int    nr_stat;
int    nr_freq;
int    rotate_disable;

refcount_t   refcount; /* event <-> ctx */
struct task_struct  *task;

/*
* Context clock, runs when context enabled.
*/
u64    time;
u64    timestamp;
u64    timeoffset;

/*
* These fields let us detect when two contexts have both
* been cloned (inherited) from a common ancestor.
*/
struct perf_event_context *parent_ctx;
u64    parent_gen;
u64    generation;
int    pin_count;
#ifdef CONFIG_CGROUP_PERF
int    nr_cgroups;  /* cgroup evts */
#endif
struct rcu_head   rcu_head;

/*
* The count of events for which using the switch-out fast path
* should be avoided.
*
* Sum (event->pending_work + events with
*    (attr->inherit && (attr->sample_type & PERF_SAMPLE_READ)))
*
* The SIGTRAP is targeted at ctx->task, as such it won't do changing
* that until the signal is delivered.
*/
local_t    nr_no_switch_fast;
};

/**
* struct perf_ctx_data - PMU specific data for a task
* @rcu_head:  To avoid the race on free PMU specific data
* @refcount:  To track users
* @global:    To track system-wide users
* @ctx_cache: Kmem cache of PMU specific data
* @data:      PMU specific data
*
* Currently, the struct is only used in Intel LBR call stack mode to
* save/restore the call stack of a task on context switches.
*
* The rcu_head is used to prevent the race on free the data.
* The data only be allocated when Intel LBR call stack mode is enabled.
* The data will be freed when the mode is disabled.
* The content of the data will only be accessed in context switch, which
* should be protected by rcu_read_lock().
*
* Because of the alignment requirement of Intel Arch LBR, the Kmem cache
* is used to allocate the PMU specific data. The ctx_cache is to track
* the Kmem cache.
*
* Careful: Struct perf_ctx_data is added as a pointer in struct task_struct.
* When system-wide Intel LBR call stack mode is enabled, a buffer with
* constant size will be allocated for each task.
* Also, system memory consumption can further grow when the size of
* struct perf_ctx_data enlarges.
*/
struct perf_ctx_data {
struct rcu_head   rcu_head;
refcount_t   refcount;
int    global;
struct kmem_cache  *ctx_cache;
void    *data;
};

struct perf_cpu_pmu_context {
struct perf_event_pmu_context epc;
struct perf_event_pmu_context *task_epc;

struct list_head  sched_cb_entry;
int    sched_cb_usage;

int    active_oncpu;
int    exclusive;
int    pmu_disable_count;

raw_spinlock_t   hrtimer_lock;
struct hrtimer   hrtimer;
ktime_t    hrtimer_interval;
unsigned int   hrtimer_active;
};

/**
* struct perf_event_cpu_context - per cpu event context structure
*/
struct perf_cpu_context {
struct perf_event_context ctx;
struct perf_event_context *task_ctx;
int    online;

#ifdef CONFIG_CGROUP_PERF
struct perf_cgroup  *cgrp;
#endif

/*
* Per-CPU storage for iterators used in visit_groups_merge. The default
* storage is of size 2 to hold the CPU and any CPU event iterators.
*/
int    heap_size;
struct perf_event  **heap;
struct perf_event  *heap_default[2];
};

struct perf_output_handle {
struct perf_event  *event;
struct perf_buffer  *rb;
unsigned long   wakeup;
unsigned long   size;
union {
  u64   flags;  /* perf_output*() */
  u64   aux_flags; /* perf_aux_output*() */
  struct {
   u64  skip_read : 1;
  };
};
union {
  void   *addr;
  unsigned long  head;
};
int    page;
};

struct bpf_perf_event_data_kern {
bpf_user_pt_regs_t *regs;
struct perf_sample_data *data;
struct perf_event *event;
};

#ifdef CONFIG_CGROUP_PERF

/*
* perf_cgroup_info keeps track of time_enabled for a cgroup.
* This is a per-cpu dynamically allocated data structure.
*/
struct perf_cgroup_info {
u64    time;
u64    timestamp;
u64    timeoffset;
int    active;
};

struct perf_cgroup {
struct cgroup_subsys_state css;
struct perf_cgroup_info __percpu *info;
};

/*
* Must ensure cgroup is pinned (css_get) before calling
* this function. In other words, we cannot call this function
* if there is no cgroup event for the current CPU context.
*/
static inline struct perf_cgroup *
perf_cgroup_from_task(struct task_struct *task, struct perf_event_context *ctx)
{
return container_of(task_css_check(task, perf_event_cgrp_id,
        ctx ? lockdep_is_held(&ctx->lock)
            : true),
       struct perf_cgroup, css);
}
#endif /* CONFIG_CGROUP_PERF */

#ifdef CONFIG_PERF_EVENTS

extern struct perf_event_context *perf_cpu_task_ctx(void);

extern void *perf_aux_output_begin(struct perf_output_handle *handle,
       struct perf_event *event);
extern void perf_aux_output_end(struct perf_output_handle *handle,
    unsigned long size);
extern int perf_aux_output_skip(struct perf_output_handle *handle,
    unsigned long size);
extern void *perf_get_aux(struct perf_output_handle *handle);
extern void perf_aux_output_flag(struct perf_output_handle *handle, u64 flags);
extern void perf_event_itrace_started(struct perf_event *event);

extern int perf_pmu_register(struct pmu *pmu, const char *name, int type);
extern int perf_pmu_unregister(struct pmu *pmu);

extern void __perf_event_task_sched_in(struct task_struct *prev,
           struct task_struct *task);
extern void __perf_event_task_sched_out(struct task_struct *prev,
     struct task_struct *next);
extern int perf_event_init_task(struct task_struct *child, u64 clone_flags);
extern void perf_event_exit_task(struct task_struct *child);
extern void perf_event_free_task(struct task_struct *task);
extern void perf_event_delayed_put(struct task_struct *task);
extern struct file *perf_event_get(unsigned int fd);
extern const struct perf_event *perf_get_event(struct file *file);
extern const struct perf_event_attr *perf_event_attrs(struct perf_event *event);
extern void perf_event_print_debug(void);
extern void perf_pmu_disable(struct pmu *pmu);
extern void perf_pmu_enable(struct pmu *pmu);
extern void perf_sched_cb_dec(struct pmu *pmu);
extern void perf_sched_cb_inc(struct pmu *pmu);
extern int perf_event_task_disable(void);
extern int perf_event_task_enable(void);

extern void perf_pmu_resched(struct pmu *pmu);

extern int perf_event_refresh(struct perf_event *event, int refresh);
extern void perf_event_update_userpage(struct perf_event *event);
extern int perf_event_release_kernel(struct perf_event *event);

extern struct perf_event *
perf_event_create_kernel_counter(struct perf_event_attr *attr,
     int cpu,
     struct task_struct *task,
     perf_overflow_handler_t callback,
     void *context);

extern void perf_pmu_migrate_context(struct pmu *pmu,
         int src_cpu, int dst_cpu);
extern int perf_event_read_local(struct perf_event *event, u64 *value,
     u64 *enabled, u64 *running);
extern u64 perf_event_read_value(struct perf_event *event,
     u64 *enabled, u64 *running);

extern struct perf_callchain_entry *perf_callchain(struct perf_event *event, struct pt_regs *regs);

static inline bool branch_sample_no_flags(const struct perf_event *event)
{
return event->attr.branch_sample_type & PERF_SAMPLE_BRANCH_NO_FLAGS;
}

static inline bool branch_sample_no_cycles(const struct perf_event *event)
{
return event->attr.branch_sample_type & PERF_SAMPLE_BRANCH_NO_CYCLES;
}

static inline bool branch_sample_type(const struct perf_event *event)
{
return event->attr.branch_sample_type & PERF_SAMPLE_BRANCH_TYPE_SAVE;
}

static inline bool branch_sample_hw_index(const struct perf_event *event)
{
return event->attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX;
}

static inline bool branch_sample_priv(const struct perf_event *event)
{
return event->attr.branch_sample_type & PERF_SAMPLE_BRANCH_PRIV_SAVE;
}

static inline bool branch_sample_counters(const struct perf_event *event)
{
return event->attr.branch_sample_type & PERF_SAMPLE_BRANCH_COUNTERS;
}

static inline bool branch_sample_call_stack(const struct perf_event *event)
{
return event->attr.branch_sample_type & PERF_SAMPLE_BRANCH_CALL_STACK;
}

struct perf_sample_data {
/*
* Fields set by perf_sample_data_init() unconditionally,
* group so as to minimize the cachelines touched.
*/
u64    sample_flags;
u64    period;
u64    dyn_size;

/*
* Fields commonly set by __perf_event_header__init_id(),
* group so as to minimize the cachelines touched.
*/
u64    type;
struct {
  u32 pid;
  u32 tid;
}    tid_entry;
u64    time;
u64    id;
struct {
  u32 cpu;
  u32 reserved;
}    cpu_entry;

/*
* The other fields, optionally {set,used} by
* perf_{prepare,output}_sample().
*/
u64    ip;
struct perf_callchain_entry *callchain;
struct perf_raw_record  *raw;
struct perf_branch_stack *br_stack;
u64    *br_stack_cntr;
union perf_sample_weight weight;
union  perf_mem_data_src data_src;
u64    txn;

struct perf_regs  regs_user;
struct perf_regs  regs_intr;
u64    stack_user_size;

u64    stream_id;
u64    cgroup;
u64    addr;
u64    phys_addr;
u64    data_page_size;
u64    code_page_size;
u64    aux_size;
} ____cacheline_aligned;

/* default value for data source */
#define PERF_MEM_NA (PERF_MEM_S(OP, NA)   |\
      PERF_MEM_S(LVL, NA)   |\
      PERF_MEM_S(SNOOP, NA) |\
      PERF_MEM_S(LOCK, NA)  |\
      PERF_MEM_S(TLB, NA)   |\
      PERF_MEM_S(LVLNUM, NA))

static inline void perf_sample_data_init(struct perf_sample_data *data,
      u64 addr, u64 period)
{
/* remaining struct members initialized in perf_prepare_sample() */
data->sample_flags = PERF_SAMPLE_PERIOD;
data->period = period;
data->dyn_size = 0;

if (addr) {
  data->addr = addr;
  data->sample_flags |= PERF_SAMPLE_ADDR;
}
}

static inline void perf_sample_save_callchain(struct perf_sample_data *data,
           struct perf_event *event,
           struct pt_regs *regs)
{
int size = 1;

if (!(event->attr.sample_type & PERF_SAMPLE_CALLCHAIN))
  return;
if (WARN_ON_ONCE(data->sample_flags & PERF_SAMPLE_CALLCHAIN))
  return;

data->callchain = perf_callchain(event, regs);
size += data->callchain->nr;

data->dyn_size += size * sizeof(u64);
data->sample_flags |= PERF_SAMPLE_CALLCHAIN;
}

static inline void perf_sample_save_raw_data(struct perf_sample_data *data,
          struct perf_event *event,
          struct perf_raw_record *raw)
{
struct perf_raw_frag *frag = &raw->frag;
u32 sum = 0;
int size;

if (!(event->attr.sample_type & PERF_SAMPLE_RAW))
  return;
if (WARN_ON_ONCE(data->sample_flags & PERF_SAMPLE_RAW))
  return;

do {
  sum += frag->size;
  if (perf_raw_frag_last(frag))
   break;
  frag = frag->next;
} while (1);

size = round_up(sum + sizeof(u32), sizeof(u64));
raw->size = size - sizeof(u32);
frag->pad = raw->size - sum;

data->raw = raw;
data->dyn_size += size;
data->sample_flags |= PERF_SAMPLE_RAW;
}

static inline bool has_branch_stack(struct perf_event *event)
{
return event->attr.sample_type & PERF_SAMPLE_BRANCH_STACK;
}

static inline void perf_sample_save_brstack(struct perf_sample_data *data,
         struct perf_event *event,
         struct perf_branch_stack *brs,
         u64 *brs_cntr)
{
int size = sizeof(u64); /* nr */

if (!has_branch_stack(event))
  return;
if (WARN_ON_ONCE(data->sample_flags & PERF_SAMPLE_BRANCH_STACK))
  return;

if (branch_sample_hw_index(event))
  size += sizeof(u64);

brs->nr = min_t(u16, event->attr.sample_max_stack, brs->nr);

size += brs->nr * sizeof(struct perf_branch_entry);

/*
* The extension space for counters is appended after the
* struct perf_branch_stack. It is used to store the occurrences
* of events of each branch.
*/
if (brs_cntr)
  size += brs->nr * sizeof(u64);

data->br_stack = brs;
data->br_stack_cntr = brs_cntr;
data->dyn_size += size;
data->sample_flags |= PERF_SAMPLE_BRANCH_STACK;
}

static inline u32 perf_sample_data_size(struct perf_sample_data *data,
     struct perf_event *event)
{
u32 size = sizeof(struct perf_event_header);

size += event->header_size + event->id_header_size;
size += data->dyn_size;

return size;
}

/*
* Clear all bitfields in the perf_branch_entry.
* The to and from fields are not cleared because they are
* systematically modified by caller.
*/
static inline void perf_clear_branch_entry_bitfields(struct perf_branch_entry *br)
{
br->mispred = 0;
br->predicted = 0;
br->in_tx = 0;
br->abort = 0;
br->cycles = 0;
br->type = 0;
br->spec = PERF_BR_SPEC_NA;
br->reserved = 0;
}

extern void perf_output_sample(struct perf_output_handle *handle,
          struct perf_event_header *header,
          struct perf_sample_data *data,
          struct perf_event *event);
extern void perf_prepare_sample(struct perf_sample_data *data,
    struct perf_event *event,
    struct pt_regs *regs);
extern void perf_prepare_header(struct perf_event_header *header,
    struct perf_sample_data *data,
    struct perf_event *event,
    struct pt_regs *regs);

extern int perf_event_overflow(struct perf_event *event,
     struct perf_sample_data *data,
     struct pt_regs *regs);

extern void perf_event_output_forward(struct perf_event *event,
         struct perf_sample_data *data,
         struct pt_regs *regs);
extern void perf_event_output_backward(struct perf_event *event,
           struct perf_sample_data *data,
           struct pt_regs *regs);
extern int perf_event_output(struct perf_event *event,
        struct perf_sample_data *data,
        struct pt_regs *regs);

static inline bool
is_default_overflow_handler(struct perf_event *event)
{
perf_overflow_handler_t overflow_handler = event->overflow_handler;

if (likely(overflow_handler == perf_event_output_forward))
  return true;
if (unlikely(overflow_handler == perf_event_output_backward))
  return true;
return false;
}

extern void
perf_event_header__init_id(struct perf_event_header *header,
      struct perf_sample_data *data,
      struct perf_event *event);
extern void
perf_event__output_id_sample(struct perf_event *event,
        struct perf_output_handle *handle,
        struct perf_sample_data *sample);

extern void
perf_log_lost_samples(struct perf_event *event, u64 lost);

static inline bool event_has_any_exclude_flag(struct perf_event *event)
{
struct perf_event_attr *attr = &event->attr;

return attr->exclude_idle || attr->exclude_user ||
        attr->exclude_kernel || attr->exclude_hv ||
        attr->exclude_guest || attr->exclude_host;
}

static inline bool is_sampling_event(struct perf_event *event)
{
return event->attr.sample_period != 0;
}

/*
* Return 1 for a software event, 0 for a hardware event
*/
static inline int is_software_event(struct perf_event *event)
{
return event->event_caps & PERF_EV_CAP_SOFTWARE;
}

/*
* Return 1 for event in sw context, 0 for event in hw context
*/
static inline int in_software_context(struct perf_event *event)
{
return event->pmu_ctx->pmu->task_ctx_nr == perf_sw_context;
}

static inline int is_exclusive_pmu(struct pmu *pmu)
{
return pmu->capabilities & PERF_PMU_CAP_EXCLUSIVE;
}

extern struct static_key perf_swevent_enabled[PERF_COUNT_SW_MAX];

extern void ___perf_sw_event(u32, u64, struct pt_regs *, u64);
extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);

#ifndef perf_arch_fetch_caller_regs
static inline void perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip) { }
#endif

/*
* When generating a perf sample in-line, instead of from an interrupt /
* exception, we lack a pt_regs. This is typically used from software events
* like: SW_CONTEXT_SWITCHES, SW_MIGRATIONS and the tie-in with tracepoints.
*
* We typically don't need a full set, but (for x86) do require:
* - ip for PERF_SAMPLE_IP
* - cs for user_mode() tests
* - sp for PERF_SAMPLE_CALLCHAIN
* - eflags for MISC bits and CALLCHAIN (see: perf_hw_regs())
*
* NOTE: assumes @regs is otherwise already 0 filled; this is important for
* things like PERF_SAMPLE_REGS_INTR.
*/
static inline void perf_fetch_caller_regs(struct pt_regs *regs)
{
perf_arch_fetch_caller_regs(regs, CALLER_ADDR0);
}

static __always_inline void
perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
{
if (static_key_false(&perf_swevent_enabled[event_id]))
  __perf_sw_event(event_id, nr, regs, addr);
}

DECLARE_PER_CPU(struct pt_regs, __perf_regs[4]);

/*
* 'Special' version for the scheduler, it hard assumes no recursion,
* which is guaranteed by us not actually scheduling inside other swevents
* because those disable preemption.
*/
static __always_inline void __perf_sw_event_sched(u32 event_id, u64 nr, u64 addr)
{
struct pt_regs *regs = this_cpu_ptr(&__perf_regs[0]);

perf_fetch_caller_regs(regs);
___perf_sw_event(event_id, nr, regs, addr);
}

extern struct static_key_false perf_sched_events;

static __always_inline bool __perf_sw_enabled(int swevt)
{
return static_key_false(&perf_swevent_enabled[swevt]);
}

static inline void perf_event_task_migrate(struct task_struct *task)
{
if (__perf_sw_enabled(PERF_COUNT_SW_CPU_MIGRATIONS))
  task->sched_migrated = 1;
}

static inline void perf_event_task_sched_in(struct task_struct *prev,
         struct task_struct *task)
{
if (static_branch_unlikely(&perf_sched_events))
  __perf_event_task_sched_in(prev, task);

if (__perf_sw_enabled(PERF_COUNT_SW_CPU_MIGRATIONS) &&
     task->sched_migrated) {
  __perf_sw_event_sched(PERF_COUNT_SW_CPU_MIGRATIONS, 1, 0);
  task->sched_migrated = 0;
}
}

static inline void perf_event_task_sched_out(struct task_struct *prev,
          struct task_struct *next)
{
if (__perf_sw_enabled(PERF_COUNT_SW_CONTEXT_SWITCHES))
  __perf_sw_event_sched(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 0);

#ifdef CONFIG_CGROUP_PERF
if (__perf_sw_enabled(PERF_COUNT_SW_CGROUP_SWITCHES) &&
     perf_cgroup_from_task(prev, NULL) !=
     perf_cgroup_from_task(next, NULL))
  __perf_sw_event_sched(PERF_COUNT_SW_CGROUP_SWITCHES, 1, 0);
#endif

if (static_branch_unlikely(&perf_sched_events))
  __perf_event_task_sched_out(prev, next);
}

extern void perf_event_mmap(struct vm_area_struct *vma);

extern void perf_event_ksymbol(u16 ksym_type, u64 addr, u32 len,
          bool unregister, const char *sym);
extern void perf_event_bpf_event(struct bpf_prog *prog,
     enum perf_bpf_event_type type,
     u16 flags);

#define PERF_GUEST_ACTIVE  0x01
#define PERF_GUEST_USER   0x02

struct perf_guest_info_callbacks {
unsigned int   (*state)(void);
unsigned long   (*get_ip)(void);
unsigned int   (*handle_intel_pt_intr)(void);
};

#ifdef CONFIG_GUEST_PERF_EVENTS

extern struct perf_guest_info_callbacks __rcu *perf_guest_cbs;

DECLARE_STATIC_CALL(__perf_guest_state, *perf_guest_cbs->state);
DECLARE_STATIC_CALL(__perf_guest_get_ip, *perf_guest_cbs->get_ip);
DECLARE_STATIC_CALL(__perf_guest_handle_intel_pt_intr, *perf_guest_cbs->handle_intel_pt_intr);

static inline unsigned int perf_guest_state(void)
{
return static_call(__perf_guest_state)();
}

static inline unsigned long perf_guest_get_ip(void)
{
return static_call(__perf_guest_get_ip)();
}

static inline unsigned int perf_guest_handle_intel_pt_intr(void)
{
return static_call(__perf_guest_handle_intel_pt_intr)();
}

extern void perf_register_guest_info_callbacks(struct perf_guest_info_callbacks *cbs);
extern void perf_unregister_guest_info_callbacks(struct perf_guest_info_callbacks *cbs);

#else /* !CONFIG_GUEST_PERF_EVENTS: */

static inline unsigned int perf_guest_state(void)   { return 0; }
static inline unsigned long perf_guest_get_ip(void)   { return 0; }
static inline unsigned int perf_guest_handle_intel_pt_intr(void) { return 0; }

#endif /* !CONFIG_GUEST_PERF_EVENTS */

extern void perf_event_exec(void);
extern void perf_event_comm(struct task_struct *tsk, bool exec);
extern void perf_event_namespaces(struct task_struct *tsk);
extern void perf_event_fork(struct task_struct *tsk);
extern void perf_event_text_poke(const void *addr,
     const void *old_bytes, size_t old_len,
     const void *new_bytes, size_t new_len);

/* Callchains */
DECLARE_PER_CPU(struct perf_callchain_entry, perf_callchain_entry);

extern void perf_callchain_user(struct perf_callchain_entry_ctx *entry, struct pt_regs *regs);
extern void perf_callchain_kernel(struct perf_callchain_entry_ctx *entry, struct pt_regs *regs);
extern struct perf_callchain_entry *
get_perf_callchain(struct pt_regs *regs, u32 init_nr, bool kernel, bool user,
     u32 max_stack, bool crosstask, bool add_mark);
extern int get_callchain_buffers(int max_stack);
extern void put_callchain_buffers(void);
extern struct perf_callchain_entry *get_callchain_entry(int *rctx);
extern void put_callchain_entry(int rctx);

extern int sysctl_perf_event_max_stack;
extern int sysctl_perf_event_max_contexts_per_stack;

static inline int perf_callchain_store_context(struct perf_callchain_entry_ctx *ctx, u64 ip)
{
if (ctx->contexts < sysctl_perf_event_max_contexts_per_stack) {
  struct perf_callchain_entry *entry = ctx->entry;

  entry->ip[entry->nr++] = ip;
  ++ctx->contexts;
  return 0;
} else {
  ctx->contexts_maxed = true;
  return -1; /* no more room, stop walking the stack */
}
}

static inline int perf_callchain_store(struct perf_callchain_entry_ctx *ctx, u64 ip)
{
if (ctx->nr < ctx->max_stack && !ctx->contexts_maxed) {
  struct perf_callchain_entry *entry = ctx->entry;

  entry->ip[entry->nr++] = ip;
  ++ctx->nr;
  return 0;
} else {
  return -1; /* no more room, stop walking the stack */
}
}

extern int sysctl_perf_event_paranoid;
extern int sysctl_perf_event_sample_rate;

extern void perf_sample_event_took(u64 sample_len_ns);

/* Access to perf_event_open(2) syscall. */
#define PERF_SECURITY_OPEN  0

/* Finer grained perf_event_open(2) access control. */
#define PERF_SECURITY_CPU  1
#define PERF_SECURITY_KERNEL  2
#define PERF_SECURITY_TRACEPOINT 3

static inline int perf_is_paranoid(void)
{
return sysctl_perf_event_paranoid > -1;
}

extern int perf_allow_kernel(void);

static inline int perf_allow_cpu(void)
{
if (sysctl_perf_event_paranoid > 0 && !perfmon_capable())
  return -EACCES;

return security_perf_event_open(PERF_SECURITY_CPU);
}

static inline int perf_allow_tracepoint(void)
{
if (sysctl_perf_event_paranoid > -1 && !perfmon_capable())
  return -EPERM;

return security_perf_event_open(PERF_SECURITY_TRACEPOINT);
}

extern int perf_exclude_event(struct perf_event *event, struct pt_regs *regs);

extern void perf_event_init(void);
extern void perf_tp_event(u16 event_type, u64 count, void *record,
     int entry_size, struct pt_regs *regs,
     struct hlist_head *head, int rctx,
     struct task_struct *task);
extern void perf_bp_event(struct perf_event *event, void *data);

extern unsigned long perf_misc_flags(struct perf_event *event, struct pt_regs *regs);
extern unsigned long perf_instruction_pointer(struct perf_event *event,
           struct pt_regs *regs);

#ifndef perf_arch_misc_flags
# define perf_arch_misc_flags(regs) \
  (user_mode(regs) ? PERF_RECORD_MISC_USER : PERF_RECORD_MISC_KERNEL)
# define perf_arch_instruction_pointer(regs) instruction_pointer(regs)
#endif
#ifndef perf_arch_bpf_user_pt_regs
# define perf_arch_bpf_user_pt_regs(regs) regs
#endif

#ifndef perf_arch_guest_misc_flags
static inline unsigned long perf_arch_guest_misc_flags(struct pt_regs *regs)
{
unsigned long guest_state = perf_guest_state();

if (!(guest_state & PERF_GUEST_ACTIVE))
  return 0;

if (guest_state & PERF_GUEST_USER)
  return PERF_RECORD_MISC_GUEST_USER;
else
  return PERF_RECORD_MISC_GUEST_KERNEL;
}
# define perf_arch_guest_misc_flags(regs) perf_arch_guest_misc_flags(regs)
#endif

static inline bool needs_branch_stack(struct perf_event *event)
{
return event->attr.branch_sample_type != 0;
}

static inline bool has_aux(struct perf_event *event)
{
return event->pmu && event->pmu->setup_aux;
}

static inline bool has_aux_action(struct perf_event *event)
{
return event->attr.aux_sample_size ||
        event->attr.aux_pause ||
        event->attr.aux_resume;
}

static inline bool is_write_backward(struct perf_event *event)
{
return !!event->attr.write_backward;
}

static inline bool has_addr_filter(struct perf_event *event)
{
return event->pmu->nr_addr_filters;
}

/*
* An inherited event uses parent's filters
*/
static inline struct perf_addr_filters_head *
perf_event_addr_filters(struct perf_event *event)
{
struct perf_addr_filters_head *ifh = &event->addr_filters;

if (event->parent)
  ifh = &event->parent->addr_filters;

return ifh;
}

static inline struct fasync_struct **perf_event_fasync(struct perf_event *event)
{
/* Only the parent has fasync state */
if (event->parent)
  event = event->parent;
return &event->fasync;
}

extern void perf_event_addr_filters_sync(struct perf_event *event);
extern void perf_report_aux_output_id(struct perf_event *event, u64 hw_id);

extern int perf_output_begin(struct perf_output_handle *handle,
        struct perf_sample_data *data,
        struct perf_event *event, unsigned int size);
extern int perf_output_begin_forward(struct perf_output_handle *handle,
         struct perf_sample_data *data,
         struct perf_event *event,
         unsigned int size);
extern int perf_output_begin_backward(struct perf_output_handle *handle,
          struct perf_sample_data *data,
          struct perf_event *event,
          unsigned int size);

extern void perf_output_end(struct perf_output_handle *handle);
extern unsigned int perf_output_copy(struct perf_output_handle *handle,
         const void *buf, unsigned int len);
extern unsigned int perf_output_skip(struct perf_output_handle *handle,
         unsigned int len);
extern long perf_output_copy_aux(struct perf_output_handle *aux_handle,
     struct perf_output_handle *handle,
     unsigned long from, unsigned long to);
extern int perf_swevent_get_recursion_context(void);
extern void perf_swevent_put_recursion_context(int rctx);
extern u64 perf_swevent_set_period(struct perf_event *event);
extern void perf_event_enable(struct perf_event *event);
extern void perf_event_disable(struct perf_event *event);
extern void perf_event_disable_local(struct perf_event *event);
extern void perf_event_disable_inatomic(struct perf_event *event);
extern void perf_event_task_tick(void);
extern int perf_event_account_interrupt(struct perf_event *event);
extern int perf_event_period(struct perf_event *event, u64 value);
extern u64 perf_event_pause(struct perf_event *event, bool reset);

#else /* !CONFIG_PERF_EVENTS: */

static inline void *
perf_aux_output_begin(struct perf_output_handle *handle,
        struct perf_event *event)    { return NULL; }
static inline void
perf_aux_output_end(struct perf_output_handle *handle, unsigned long size)
         { }
static inline int
perf_aux_output_skip(struct perf_output_handle *handle,
       unsigned long size)    { return -EINVAL; }
static inline void *
perf_get_aux(struct perf_output_handle *handle)    { return NULL; }
static inline void
perf_event_task_migrate(struct task_struct *task)   { }
static inline void
perf_event_task_sched_in(struct task_struct *prev,
    struct task_struct *task)   { }
static inline void
perf_event_task_sched_out(struct task_struct *prev,
     struct task_struct *next)   { }
static inline int perf_event_init_task(struct task_struct *child,
           u64 clone_flags)   { return 0; }
static inline void perf_event_exit_task(struct task_struct *child) { }
static inline void perf_event_free_task(struct task_struct *task) { }
static inline void perf_event_delayed_put(struct task_struct *task) { }
static inline struct file *perf_event_get(unsigned int fd) { return ERR_PTR(-EINVAL); }
static inline const struct perf_event *perf_get_event(struct file *file)
{
return ERR_PTR(-EINVAL);
}
static inline const struct perf_event_attr *perf_event_attrs(struct perf_event *event)
{
return ERR_PTR(-EINVAL);
}
static inline int perf_event_read_local(struct perf_event *event, u64 *value,
     u64 *enabled, u64 *running)
{
return -EINVAL;
}
static inline void perf_event_print_debug(void)    { }
static inline int perf_event_task_disable(void)    { return -EINVAL; }
static inline int perf_event_task_enable(void)    { return -EINVAL; }
static inline int perf_event_refresh(struct perf_event *event, int refresh)
{
return -EINVAL;
}

static inline void
perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr) { }
static inline void
perf_bp_event(struct perf_event *event, void *data)   { }

static inline void perf_event_mmap(struct vm_area_struct *vma)  { }

typedef int (perf_ksymbol_get_name_f)(char *name, int name_len, void *data);
static inline void perf_event_ksymbol(u16 ksym_type, u64 addr, u32 len,
          bool unregister, const char *sym) { }
static inline void perf_event_bpf_event(struct bpf_prog *prog,
     enum perf_bpf_event_type type,
     u16 flags)   { }
static inline void perf_event_exec(void)    { }
static inline void perf_event_comm(struct task_struct *tsk, bool exec) { }
static inline void perf_event_namespaces(struct task_struct *tsk) { }
static inline void perf_event_fork(struct task_struct *tsk)  { }
static inline void perf_event_text_poke(const void *addr,
     const void *old_bytes,
     size_t old_len,
     const void *new_bytes,
     size_t new_len)   { }
static inline void perf_event_init(void)    { }
static inline int  perf_swevent_get_recursion_context(void)  { return -1; }
static inline void perf_swevent_put_recursion_context(int rctx)  { }
static inline u64 perf_swevent_set_period(struct perf_event *event) { return 0; }
static inline void perf_event_enable(struct perf_event *event)  { }
static inline void perf_event_disable(struct perf_event *event)  { }
static inline int __perf_event_disable(void *info)   { return -1; }
static inline void perf_event_task_tick(void)    { }
static inline int perf_event_release_kernel(struct perf_event *event) { return 0; }
static inline int
perf_event_period(struct perf_event *event, u64 value)   { return -EINVAL; }
static inline u64
perf_event_pause(struct perf_event *event, bool reset)   { return 0; }
static inline int
perf_exclude_event(struct perf_event *event, struct pt_regs *regs) { return 0; }

#endif /* !CONFIG_PERF_EVENTS */

#if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_CPU_SUP_INTEL)
extern void perf_restore_debug_store(void);
#else
static inline void perf_restore_debug_store(void)   { }
#endif

#define perf_output_put(handle, x) perf_output_copy((handle), &(x), sizeof(x))

struct perf_pmu_events_attr {
struct device_attribute  attr;
u64    id;
const char   *event_str;
};

struct perf_pmu_events_ht_attr {
struct device_attribute  attr;
u64    id;
const char   *event_str_ht;
const char   *event_str_noht;
};

struct perf_pmu_events_hybrid_attr {
struct device_attribute  attr;
u64    id;
const char   *event_str;
u64    pmu_type;
};

struct perf_pmu_format_hybrid_attr {
struct device_attribute  attr;
u64    pmu_type;
};

ssize_t perf_event_sysfs_show(struct device *dev, struct device_attribute *attr,
         char *page);

#define PMU_EVENT_ATTR(_name, _var, _id, _show)    \
static struct perf_pmu_events_attr _var = {    \
.attr = __ATTR(_name, 0444, _show, NULL),   \
.id   =  _id,       \
};

#define PMU_EVENT_ATTR_STRING(_name, _var, _str)       \
static struct perf_pmu_events_attr _var = {        \
.attr  = __ATTR(_name, 0444, perf_event_sysfs_show, NULL), \
.id  = 0,          \
.event_str = _str,          \
};

#define PMU_EVENT_ATTR_ID(_name, _show, _id)    \
(&((struct perf_pmu_events_attr[]) {    \
  { .attr = __ATTR(_name, 0444, _show, NULL),  \
    .id = _id, }      \
})[0].attr.attr)

#define PMU_FORMAT_ATTR_SHOW(_name, _format)    \
static ssize_t        \
_name##_show(struct device *dev,     \
          struct device_attribute *attr,  \
          char *page)    \
{         \
BUILD_BUG_ON(sizeof(_format) >= PAGE_SIZE);   \
return sprintf(page, _format "\n");    \
}         \

#define PMU_FORMAT_ATTR(_name, _format)     \
PMU_FORMAT_ATTR_SHOW(_name, _format)    \
         \
static struct device_attribute format_attr_##_name = __ATTR_RO(_name)

/* Performance counter hotplug functions */
#ifdef CONFIG_PERF_EVENTS
extern int perf_event_init_cpu(unsigned int cpu);
extern int perf_event_exit_cpu(unsigned int cpu);
#else
# define perf_event_init_cpu  NULL
# define perf_event_exit_cpu  NULL
#endif

extern void arch_perf_update_userpage(struct perf_event *event,
          struct perf_event_mmap_page *userpg,
          u64 now);

/*
* Snapshot branch stack on software events.
*
* Branch stack can be very useful in understanding software events. For
* example, when a long function, e.g. sys_perf_event_open, returns an
* errno, it is not obvious why the function failed. Branch stack could
* provide very helpful information in this type of scenarios.
*
* On software event, it is necessary to stop the hardware branch recorder
* fast. Otherwise, the hardware register/buffer will be flushed with
* entries of the triggering event. Therefore, static call is used to
* stop the hardware recorder.
*/

/*
* cnt is the number of entries allocated for entries.
* Return number of entries copied to .
*/
typedef int (perf_snapshot_branch_stack_t)(struct perf_branch_entry *entries,
        unsigned int cnt);
DECLARE_STATIC_CALL(perf_snapshot_branch_stack, perf_snapshot_branch_stack_t);

#ifndef PERF_NEEDS_LOPWR_CB
static inline void perf_lopwr_cb(bool mode)
{
}
#endif

#endif /* _LINUX_PERF_EVENT_H */

quality97%

¤ Dauer der Verarbeitung: 0.76 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.