Linux Audio

Check our new training course

Loading...
v6.2
  1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef __PERF_THREAD_H
  3#define __PERF_THREAD_H
  4
  5#include <linux/refcount.h>
  6#include <linux/rbtree.h>
  7#include <linux/list.h>
  8#include <stdio.h>
  9#include <unistd.h>
 10#include <sys/types.h>
 11#include "srccode.h"
 12#include "symbol_conf.h"
 13#include <strlist.h>
 14#include <intlist.h>
 15#include "rwsem.h"
 16#include "event.h"
 17#include "callchain.h"
 18
 19struct addr_location;
 20struct map;
 21struct perf_record_namespaces;
 22struct thread_stack;
 23struct unwind_libunwind_ops;
 24
 25struct lbr_stitch {
 26	struct list_head		lists;
 27	struct list_head		free_lists;
 28	struct perf_sample		prev_sample;
 29	struct callchain_cursor_node	*prev_lbr_cursor;
 30};
 31
 32struct thread {
 33	union {
 34		struct rb_node	 rb_node;
 35		struct list_head node;
 36	};
 37	struct maps		*maps;
 38	pid_t			pid_; /* Not all tools update this */
 39	pid_t			tid;
 40	pid_t			ppid;
 41	int			cpu;
 42	int			guest_cpu; /* For QEMU thread */
 43	refcount_t		refcnt;
 44	bool			comm_set;
 45	int			comm_len;
 46	bool			dead; /* if set thread has exited */
 47	struct list_head	namespaces_list;
 48	struct rw_semaphore	namespaces_lock;
 49	struct list_head	comm_list;
 50	struct rw_semaphore	comm_lock;
 51	u64			db_id;
 52
 53	void			*priv;
 54	struct thread_stack	*ts;
 55	struct nsinfo		*nsinfo;
 56	struct srccode_state	srccode_state;
 57	bool			filter;
 58	int			filter_entry_depth;
 59
 60	/* LBR call stack stitch */
 61	bool			lbr_stitch_enable;
 62	struct lbr_stitch	*lbr_stitch;
 63};
 64
 65struct machine;
 66struct namespaces;
 67struct comm;
 68
 69struct thread *thread__new(pid_t pid, pid_t tid);
 70int thread__init_maps(struct thread *thread, struct machine *machine);
 71void thread__delete(struct thread *thread);
 72
 73struct thread *thread__get(struct thread *thread);
 74void thread__put(struct thread *thread);
 75
 76static inline void __thread__zput(struct thread **thread)
 77{
 78	thread__put(*thread);
 79	*thread = NULL;
 80}
 81
 82#define thread__zput(thread) __thread__zput(&thread)
 83
 84static inline void thread__exited(struct thread *thread)
 85{
 86	thread->dead = true;
 87}
 88
 89struct namespaces *thread__namespaces(struct thread *thread);
 90int thread__set_namespaces(struct thread *thread, u64 timestamp,
 91			   struct perf_record_namespaces *event);
 92
 93int __thread__set_comm(struct thread *thread, const char *comm, u64 timestamp,
 94		       bool exec);
 95static inline int thread__set_comm(struct thread *thread, const char *comm,
 96				   u64 timestamp)
 97{
 98	return __thread__set_comm(thread, comm, timestamp, false);
 99}
100
101int thread__set_comm_from_proc(struct thread *thread);
102
103int thread__comm_len(struct thread *thread);
104struct comm *thread__comm(const struct thread *thread);
105struct comm *thread__exec_comm(const struct thread *thread);
106const char *thread__comm_str(struct thread *thread);
107int thread__insert_map(struct thread *thread, struct map *map);
108int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bool do_maps_clone);
109size_t thread__fprintf(struct thread *thread, FILE *fp);
110
111struct thread *thread__main_thread(struct machine *machine, struct thread *thread);
112
113struct map *thread__find_map(struct thread *thread, u8 cpumode, u64 addr,
114			     struct addr_location *al);
115struct map *thread__find_map_fb(struct thread *thread, u8 cpumode, u64 addr,
116				struct addr_location *al);
117
118struct symbol *thread__find_symbol(struct thread *thread, u8 cpumode,
119				   u64 addr, struct addr_location *al);
120struct symbol *thread__find_symbol_fb(struct thread *thread, u8 cpumode,
121				      u64 addr, struct addr_location *al);
122
123void thread__find_cpumode_addr_location(struct thread *thread, u64 addr,
 
124					struct addr_location *al);
125
126int thread__memcpy(struct thread *thread, struct machine *machine,
127		   void *buf, u64 ip, int len, bool *is64bit);
128
129static inline void *thread__priv(struct thread *thread)
130{
131	return thread->priv;
132}
133
134static inline void thread__set_priv(struct thread *thread, void *p)
135{
136	thread->priv = p;
137}
138
139static inline bool thread__is_filtered(struct thread *thread)
140{
141	if (symbol_conf.comm_list &&
142	    !strlist__has_entry(symbol_conf.comm_list, thread__comm_str(thread))) {
143		return true;
144	}
145
146	if (symbol_conf.pid_list &&
147	    !intlist__has_entry(symbol_conf.pid_list, thread->pid_)) {
148		return true;
149	}
150
151	if (symbol_conf.tid_list &&
152	    !intlist__has_entry(symbol_conf.tid_list, thread->tid)) {
153		return true;
154	}
155
156	return false;
157}
158
159void thread__free_stitch_list(struct thread *thread);
160
161void thread__resolve(struct thread *thread, struct addr_location *al,
162		     struct perf_sample *sample);
163
164#endif	/* __PERF_THREAD_H */
v4.10.11
 
  1#ifndef __PERF_THREAD_H
  2#define __PERF_THREAD_H
  3
  4#include <linux/atomic.h>
  5#include <linux/rbtree.h>
  6#include <linux/list.h>
 
  7#include <unistd.h>
  8#include <sys/types.h>
  9#include "symbol.h"
 
 10#include <strlist.h>
 11#include <intlist.h>
 12
 
 
 
 
 
 
 13struct thread_stack;
 14struct unwind_libunwind_ops;
 15
 
 
 
 
 
 
 
 16struct thread {
 17	union {
 18		struct rb_node	 rb_node;
 19		struct list_head node;
 20	};
 21	struct map_groups	*mg;
 22	pid_t			pid_; /* Not all tools update this */
 23	pid_t			tid;
 24	pid_t			ppid;
 25	int			cpu;
 26	atomic_t		refcnt;
 27	char			shortname[3];
 28	bool			comm_set;
 29	int			comm_len;
 30	bool			dead; /* if set thread has exited */
 
 
 31	struct list_head	comm_list;
 
 32	u64			db_id;
 33
 34	void			*priv;
 35	struct thread_stack	*ts;
 36#ifdef HAVE_LIBUNWIND_SUPPORT
 37	void				*addr_space;
 38	struct unwind_libunwind_ops	*unwind_libunwind_ops;
 39#endif
 
 
 
 
 40};
 41
 42struct machine;
 
 43struct comm;
 44
 45struct thread *thread__new(pid_t pid, pid_t tid);
 46int thread__init_map_groups(struct thread *thread, struct machine *machine);
 47void thread__delete(struct thread *thread);
 48
 49struct thread *thread__get(struct thread *thread);
 50void thread__put(struct thread *thread);
 51
 52static inline void __thread__zput(struct thread **thread)
 53{
 54	thread__put(*thread);
 55	*thread = NULL;
 56}
 57
 58#define thread__zput(thread) __thread__zput(&thread)
 59
 60static inline void thread__exited(struct thread *thread)
 61{
 62	thread->dead = true;
 63}
 64
 
 
 
 
 65int __thread__set_comm(struct thread *thread, const char *comm, u64 timestamp,
 66		       bool exec);
 67static inline int thread__set_comm(struct thread *thread, const char *comm,
 68				   u64 timestamp)
 69{
 70	return __thread__set_comm(thread, comm, timestamp, false);
 71}
 72
 73int thread__set_comm_from_proc(struct thread *thread);
 74
 75int thread__comm_len(struct thread *thread);
 76struct comm *thread__comm(const struct thread *thread);
 77struct comm *thread__exec_comm(const struct thread *thread);
 78const char *thread__comm_str(const struct thread *thread);
 79int thread__insert_map(struct thread *thread, struct map *map);
 80int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp);
 81size_t thread__fprintf(struct thread *thread, FILE *fp);
 82
 83struct thread *thread__main_thread(struct machine *machine, struct thread *thread);
 84
 85void thread__find_addr_map(struct thread *thread,
 86			   u8 cpumode, enum map_type type, u64 addr,
 87			   struct addr_location *al);
 
 88
 89void thread__find_addr_location(struct thread *thread,
 90				u8 cpumode, enum map_type type, u64 addr,
 91				struct addr_location *al);
 
 92
 93void thread__find_cpumode_addr_location(struct thread *thread,
 94					enum map_type type, u64 addr,
 95					struct addr_location *al);
 96
 
 
 
 97static inline void *thread__priv(struct thread *thread)
 98{
 99	return thread->priv;
100}
101
102static inline void thread__set_priv(struct thread *thread, void *p)
103{
104	thread->priv = p;
105}
106
107static inline bool thread__is_filtered(struct thread *thread)
108{
109	if (symbol_conf.comm_list &&
110	    !strlist__has_entry(symbol_conf.comm_list, thread__comm_str(thread))) {
111		return true;
112	}
113
114	if (symbol_conf.pid_list &&
115	    !intlist__has_entry(symbol_conf.pid_list, thread->pid_)) {
116		return true;
117	}
118
119	if (symbol_conf.tid_list &&
120	    !intlist__has_entry(symbol_conf.tid_list, thread->tid)) {
121		return true;
122	}
123
124	return false;
125}
 
 
 
 
 
126
127#endif	/* __PERF_THREAD_H */