mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-26 02:36:49 +07:00
4f8f382e63
When synthesizing FORK events, we are trying to create thread objects for the already running tasks on the machine. Normally, for a kernel FORK event, we want to clone the parent's maps because that is what the kernel just did. But when synthesizing, this should not be done. If we do, we end up with overlapping maps as we process the sythesized MMAP2 events that get delivered shortly thereafter. Use the FORK event misc flags in an internal way to signal this situation, so we can elide the map clone when appropriate. Signed-off-by: David S. Miller <davem@davemloft.net> Cc: Don Zickus <dzickus@redhat.com> Cc: Jiri Olsa <jolsa@redhat.com> Cc: Joe Mario <jmario@redhat.com> Link: http://lkml.kernel.org/r/20181030.222404.2085088822877051075.davem@davemloft.net [ Added comment about flag use in machine__process_fork_event(), use ternary op in thread__clone_map_groups() as suggested by Jiri ] Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
137 lines
3.5 KiB
C
137 lines
3.5 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef __PERF_THREAD_H
|
|
#define __PERF_THREAD_H
|
|
|
|
#include <linux/refcount.h>
|
|
#include <linux/rbtree.h>
|
|
#include <linux/list.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include "symbol.h"
|
|
#include <strlist.h>
|
|
#include <intlist.h>
|
|
#include "rwsem.h"
|
|
|
|
struct thread_stack;
|
|
struct unwind_libunwind_ops;
|
|
|
|
struct thread {
|
|
union {
|
|
struct rb_node rb_node;
|
|
struct list_head node;
|
|
};
|
|
struct map_groups *mg;
|
|
pid_t pid_; /* Not all tools update this */
|
|
pid_t tid;
|
|
pid_t ppid;
|
|
int cpu;
|
|
refcount_t refcnt;
|
|
bool comm_set;
|
|
int comm_len;
|
|
bool dead; /* if set thread has exited */
|
|
struct list_head namespaces_list;
|
|
struct rw_semaphore namespaces_lock;
|
|
struct list_head comm_list;
|
|
struct rw_semaphore comm_lock;
|
|
u64 db_id;
|
|
|
|
void *priv;
|
|
struct thread_stack *ts;
|
|
struct nsinfo *nsinfo;
|
|
#ifdef HAVE_LIBUNWIND_SUPPORT
|
|
void *addr_space;
|
|
struct unwind_libunwind_ops *unwind_libunwind_ops;
|
|
#endif
|
|
bool filter;
|
|
int filter_entry_depth;
|
|
};
|
|
|
|
struct machine;
|
|
struct namespaces;
|
|
struct comm;
|
|
|
|
struct thread *thread__new(pid_t pid, pid_t tid);
|
|
int thread__init_map_groups(struct thread *thread, struct machine *machine);
|
|
void thread__delete(struct thread *thread);
|
|
|
|
struct thread *thread__get(struct thread *thread);
|
|
void thread__put(struct thread *thread);
|
|
|
|
static inline void __thread__zput(struct thread **thread)
|
|
{
|
|
thread__put(*thread);
|
|
*thread = NULL;
|
|
}
|
|
|
|
#define thread__zput(thread) __thread__zput(&thread)
|
|
|
|
static inline void thread__exited(struct thread *thread)
|
|
{
|
|
thread->dead = true;
|
|
}
|
|
|
|
struct namespaces *thread__namespaces(const struct thread *thread);
|
|
int thread__set_namespaces(struct thread *thread, u64 timestamp,
|
|
struct namespaces_event *event);
|
|
|
|
int __thread__set_comm(struct thread *thread, const char *comm, u64 timestamp,
|
|
bool exec);
|
|
static inline int thread__set_comm(struct thread *thread, const char *comm,
|
|
u64 timestamp)
|
|
{
|
|
return __thread__set_comm(thread, comm, timestamp, false);
|
|
}
|
|
|
|
int thread__set_comm_from_proc(struct thread *thread);
|
|
|
|
int thread__comm_len(struct thread *thread);
|
|
struct comm *thread__comm(const struct thread *thread);
|
|
struct comm *thread__exec_comm(const struct thread *thread);
|
|
const char *thread__comm_str(const struct thread *thread);
|
|
int thread__insert_map(struct thread *thread, struct map *map);
|
|
int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bool do_maps_clone);
|
|
size_t thread__fprintf(struct thread *thread, FILE *fp);
|
|
|
|
struct thread *thread__main_thread(struct machine *machine, struct thread *thread);
|
|
|
|
struct map *thread__find_map(struct thread *thread, u8 cpumode, u64 addr,
|
|
struct addr_location *al);
|
|
|
|
struct symbol *thread__find_symbol(struct thread *thread, u8 cpumode,
|
|
u64 addr, struct addr_location *al);
|
|
|
|
void thread__find_cpumode_addr_location(struct thread *thread, u64 addr,
|
|
struct addr_location *al);
|
|
|
|
static inline void *thread__priv(struct thread *thread)
|
|
{
|
|
return thread->priv;
|
|
}
|
|
|
|
static inline void thread__set_priv(struct thread *thread, void *p)
|
|
{
|
|
thread->priv = p;
|
|
}
|
|
|
|
static inline bool thread__is_filtered(struct thread *thread)
|
|
{
|
|
if (symbol_conf.comm_list &&
|
|
!strlist__has_entry(symbol_conf.comm_list, thread__comm_str(thread))) {
|
|
return true;
|
|
}
|
|
|
|
if (symbol_conf.pid_list &&
|
|
!intlist__has_entry(symbol_conf.pid_list, thread->pid_)) {
|
|
return true;
|
|
}
|
|
|
|
if (symbol_conf.tid_list &&
|
|
!intlist__has_entry(symbol_conf.tid_list, thread->tid)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#endif /* __PERF_THREAD_H */
|