From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4330BC7EE29 for ; Fri, 9 Jun 2023 14:51:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241345AbjFIOvA (ORCPT ); Fri, 9 Jun 2023 10:51:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35422 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240804AbjFIOuz (ORCPT ); Fri, 9 Jun 2023 10:50:55 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3521B2738; Fri, 9 Jun 2023 07:50:49 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id AB56261AF0; Fri, 9 Jun 2023 14:50:48 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 87C62C4339C; Fri, 9 Jun 2023 14:50:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1686322248; bh=rvVhbatb1lvA29YGp+RtPgRqH2bZb6kliKLe8iS9EVQ=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=FFhUlOvf+e9sxXjvnLWF+XZvz/Tfw0BYrNE8QBmr7cLSypT36T+igtxrPHEIh23c1 ok5+Jwudt/Vt/hCVqd2NLFBEsDI9554UiMgcUDFBmaC1bp6+86hnsoN/IFXMHRSKVc V0HxA2xoz77k5yQwglyBPydFBlRKAnb1ncwmCj/bNHGRaK1xpt03fGTG/sgZEy+nPJ 9IKfmeKoeXJY+bDU6OtrqiH+7rt0NZ/QCLMiAzYr/vEp1kMo29OSFkgOtEDqwoq8HW +EzMRfUF+2u5iVQUM8BYINYtuJC4xPMeKj+kyxrTgmC1W14Z0oMqA9NkylmwCJ4Vh6 LuJHBpCqSpd/g== Received: by quaco.ghostprotocols.net (Postfix, from userid 1000) id 299F940692; Fri, 9 Jun 2023 11:50:45 -0300 (-03) Date: Fri, 9 Jun 2023 11:50:45 -0300 From: Arnaldo Carvalho de Melo To: Ian Rogers Cc: John Garry , Will Deacon , James Clark , Mike Leach , Leo Yan , Peter Zijlstra , Ingo Molnar , Mark Rutland , Alexander Shishkin , Jiri Olsa , Namhyung Kim , Adrian Hunter , Suzuki K Poulose , "Naveen N. Rao" , Kan Liang , German Gomez , Ali Saidi , Jing Zhang , Athira Rajeev , Miguel Ojeda , ye xingchen , Liam Howlett , Dmitrii Dolgov <9erthalion6@gmail.com>, Yang Jihong , K Prateek Nayak , Changbin Du , Ravi Bangoria , Sean Christopherson , Andi Kleen , "Steinar H. Gunderson" , Yuan Can , Brian Robbins , liuwenyu , Ivan Babrou , Fangrui Song , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, coresight@lists.linaro.org Subject: Re: [PATCH v2 03/26] perf thread: Add accessor functions for thread Message-ID: References: <20230608232823.4027869-1-irogers@google.com> <20230608232823.4027869-4-irogers@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20230608232823.4027869-4-irogers@google.com> X-Url: http://acmel.wordpress.com Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Em Thu, Jun 08, 2023 at 04:28:00PM -0700, Ian Rogers escreveu: > Using accessors will make it easier to add reference count checking in > later patches. > > Signed-off-by: Ian Rogers > --- > tools/perf/arch/arm/tests/dwarf-unwind.c | 2 +- > tools/perf/arch/arm64/tests/dwarf-unwind.c | 2 +- > tools/perf/arch/powerpc/tests/dwarf-unwind.c | 2 +- > tools/perf/arch/x86/tests/dwarf-unwind.c | 2 +- > tools/perf/builtin-c2c.c | 6 +- > tools/perf/builtin-inject.c | 2 +- > tools/perf/builtin-kmem.c | 2 +- > tools/perf/builtin-report.c | 12 +- > tools/perf/builtin-sched.c | 51 +++-- > tools/perf/builtin-script.c | 20 +- > tools/perf/builtin-top.c | 2 +- > tools/perf/builtin-trace.c | 26 ++- > .../scripts/python/Perf-Trace-Util/Context.c | 4 +- > tools/perf/tests/code-reading.c | 2 +- > tools/perf/tests/hists_common.c | 2 +- > tools/perf/tests/hists_cumulate.c | 1 - > tools/perf/tests/hists_output.c | 2 +- > tools/perf/tests/perf-targz-src-pkg | 5 +- > tools/perf/tests/thread-maps-share.c | 13 +- > tools/perf/trace/beauty/pid.c | 4 +- > tools/perf/ui/browsers/hists.c | 19 +- > tools/perf/ui/stdio/hist.c | 2 +- > tools/perf/util/arm-spe.c | 4 +- > tools/perf/util/cs-etm.c | 2 +- > tools/perf/util/data-convert-json.c | 8 +- > tools/perf/util/db-export.c | 16 +- > tools/perf/util/dlfilter.c | 4 +- > tools/perf/util/event.c | 6 +- > tools/perf/util/hist.c | 6 +- > tools/perf/util/intel-bts.c | 2 +- > tools/perf/util/intel-pt.c | 12 +- > tools/perf/util/jitdump.c | 10 +- > tools/perf/util/machine.c | 91 +++++---- > tools/perf/util/map.c | 2 +- > tools/perf/util/maps.c | 2 +- > .../scripting-engines/trace-event-python.c | 14 +- > tools/perf/util/session.c | 2 +- > tools/perf/util/sort.c | 10 +- > tools/perf/util/thread-stack.c | 25 +-- > tools/perf/util/thread.c | 161 +++++++-------- > tools/perf/util/thread.h | 188 +++++++++++++++++- > tools/perf/util/unwind-libdw.c | 6 +- > tools/perf/util/unwind-libunwind-local.c | 6 +- > tools/perf/util/unwind-libunwind.c | 2 +- > tools/perf/util/vdso.c | 2 +- > 45 files changed, 485 insertions(+), 279 deletions(-) > > diff --git a/tools/perf/arch/arm/tests/dwarf-unwind.c b/tools/perf/arch/arm/tests/dwarf-unwind.c > index 566fb6c0eae7..9bc304cb7762 100644 > --- a/tools/perf/arch/arm/tests/dwarf-unwind.c > +++ b/tools/perf/arch/arm/tests/dwarf-unwind.c > @@ -26,7 +26,7 @@ static int sample_ustack(struct perf_sample *sample, > > sp = (unsigned long) regs[PERF_REG_ARM_SP]; > > - map = maps__find(thread->maps, (u64)sp); > + map = maps__find(thread__maps(thread), (u64)sp); > if (!map) { > pr_debug("failed to get stack map\n"); > free(buf); > diff --git a/tools/perf/arch/arm64/tests/dwarf-unwind.c b/tools/perf/arch/arm64/tests/dwarf-unwind.c > index 90a7ef293ce7..b2603d0d3737 100644 > --- a/tools/perf/arch/arm64/tests/dwarf-unwind.c > +++ b/tools/perf/arch/arm64/tests/dwarf-unwind.c > @@ -26,7 +26,7 @@ static int sample_ustack(struct perf_sample *sample, > > sp = (unsigned long) regs[PERF_REG_ARM64_SP]; > > - map = maps__find(thread->maps, (u64)sp); > + map = maps__find(thread__maps(thread), (u64)sp); > if (!map) { > pr_debug("failed to get stack map\n"); > free(buf); > diff --git a/tools/perf/arch/powerpc/tests/dwarf-unwind.c b/tools/perf/arch/powerpc/tests/dwarf-unwind.c > index 32fffb593fbf..5ecf82893b84 100644 > --- a/tools/perf/arch/powerpc/tests/dwarf-unwind.c > +++ b/tools/perf/arch/powerpc/tests/dwarf-unwind.c > @@ -26,7 +26,7 @@ static int sample_ustack(struct perf_sample *sample, > > sp = (unsigned long) regs[PERF_REG_POWERPC_R1]; > > - map = maps__find(thread->maps, (u64)sp); > + map = maps__find(thread__maps(thread), (u64)sp); > if (!map) { > pr_debug("failed to get stack map\n"); > free(buf); > diff --git a/tools/perf/arch/x86/tests/dwarf-unwind.c b/tools/perf/arch/x86/tests/dwarf-unwind.c > index 497593be80f2..5bfec3345d59 100644 > --- a/tools/perf/arch/x86/tests/dwarf-unwind.c > +++ b/tools/perf/arch/x86/tests/dwarf-unwind.c > @@ -26,7 +26,7 @@ static int sample_ustack(struct perf_sample *sample, > > sp = (unsigned long) regs[PERF_REG_X86_SP]; > > - map = maps__find(thread->maps, (u64)sp); > + map = maps__find(thread__maps(thread), (u64)sp); > if (!map) { > pr_debug("failed to get stack map\n"); > free(buf); > diff --git a/tools/perf/builtin-c2c.c b/tools/perf/builtin-c2c.c > index 05dfd98af170..ee41a96f0c73 100644 > --- a/tools/perf/builtin-c2c.c > +++ b/tools/perf/builtin-c2c.c > @@ -293,7 +293,7 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused, > } > > if (c2c.stitch_lbr) > - al.thread->lbr_stitch_enable = true; > + thread__set_lbr_stitch_enable(al.thread, true); > > ret = sample__resolve_callchain(sample, &callchain_cursor, NULL, > evsel, &al, sysctl_perf_event_max_stack); > @@ -1149,14 +1149,14 @@ pid_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, > { > int width = c2c_width(fmt, hpp, he->hists); > > - return scnprintf(hpp->buf, hpp->size, "%*d", width, he->thread->pid_); > + return scnprintf(hpp->buf, hpp->size, "%*d", width, thread__pid(he->thread)); > } > > static int64_t > pid_cmp(struct perf_hpp_fmt *fmt __maybe_unused, > struct hist_entry *left, struct hist_entry *right) > { > - return left->thread->pid_ - right->thread->pid_; > + return thread__pid(left->thread) - thread__pid(right->thread); > } > > static int64_t > diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c > index 61766eead4f4..d9e96d4624c6 100644 > --- a/tools/perf/builtin-inject.c > +++ b/tools/perf/builtin-inject.c > @@ -417,7 +417,7 @@ static struct dso *findnew_dso(int pid, int tid, const char *filename, > } > > vdso = is_vdso_map(filename); > - nsi = nsinfo__get(thread->nsinfo); > + nsi = nsinfo__get(thread__nsinfo(thread)); > > if (vdso) { > /* The vdso maps are always on the host and not the > diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c > index 2150eeced892..fe9439a4fd66 100644 > --- a/tools/perf/builtin-kmem.c > +++ b/tools/perf/builtin-kmem.c > @@ -964,7 +964,7 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused, > if (perf_kmem__skip_sample(sample)) > return 0; > > - dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread->tid); > + dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread__tid(thread)); > > if (evsel->handler != NULL) { > tracepoint_handler f = evsel->handler; > diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c > index c7d526283baf..8ea6ab18534a 100644 > --- a/tools/perf/builtin-report.c > +++ b/tools/perf/builtin-report.c > @@ -292,7 +292,7 @@ static int process_sample_event(struct perf_tool *tool, > } > > if (rep->stitch_lbr) > - al.thread->lbr_stitch_enable = true; > + thread__set_lbr_stitch_enable(al.thread, true); > > if (symbol_conf.hide_unresolved && al.sym == NULL) > goto out_put; > @@ -829,10 +829,10 @@ static struct task *tasks_list(struct task *task, struct machine *machine) > return NULL; > > /* Last one in the chain. */ > - if (thread->ppid == -1) > + if (thread__ppid(thread) == -1) > return task; > > - parent_thread = machine__find_thread(machine, -1, thread->ppid); > + parent_thread = machine__find_thread(machine, -1, thread__ppid(thread)); > if (!parent_thread) > return ERR_PTR(-ENOENT); > > @@ -869,12 +869,12 @@ static void task__print_level(struct task *task, FILE *fp, int level) > struct thread *thread = task->thread; > struct task *child; > int comm_indent = fprintf(fp, " %8d %8d %8d |%*s", > - thread->pid_, thread->tid, thread->ppid, > - level, ""); > + thread__pid(thread), thread__tid(thread), > + thread__ppid(thread), level, ""); > > fprintf(fp, "%s\n", thread__comm_str(thread)); > > - maps__fprintf_task(thread->maps, comm_indent, fp); > + maps__fprintf_task(thread__maps(thread), comm_indent, fp); > > if (!list_empty(&task->children)) { > list_for_each_entry(child, &task->children, list) > diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c > index 3a30c2ac5b47..fd37468c4f62 100644 > --- a/tools/perf/builtin-sched.c > +++ b/tools/perf/builtin-sched.c > @@ -916,12 +916,12 @@ static int replay_fork_event(struct perf_sched *sched, > > if (verbose > 0) { > printf("fork event\n"); > - printf("... parent: %s/%d\n", thread__comm_str(parent), parent->tid); > - printf("... child: %s/%d\n", thread__comm_str(child), child->tid); > + printf("... parent: %s/%d\n", thread__comm_str(parent), thread__tid(parent)); > + printf("... child: %s/%d\n", thread__comm_str(child), thread__tid(child)); > } > > - register_pid(sched, parent->tid, thread__comm_str(parent)); > - register_pid(sched, child->tid, thread__comm_str(child)); > + register_pid(sched, thread__tid(parent), thread__comm_str(parent)); > + register_pid(sched, thread__tid(child), thread__comm_str(child)); > out_put: > thread__put(child); > thread__put(parent); > @@ -1316,7 +1316,7 @@ static int latency_migrate_task_event(struct perf_sched *sched, > if (!atoms) { > if (thread_atoms_insert(sched, migrant)) > goto out_put; > - register_pid(sched, migrant->tid, thread__comm_str(migrant)); > + register_pid(sched, thread__tid(migrant), thread__comm_str(migrant)); > atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid); > if (!atoms) { > pr_err("migration-event: Internal tree error"); > @@ -1359,10 +1359,13 @@ static void output_lat_thread(struct perf_sched *sched, struct work_atoms *work_ > sched->all_runtime += work_list->total_runtime; > sched->all_count += work_list->nb_atoms; > > - if (work_list->num_merged > 1) > - ret = printf(" %s:(%d) ", thread__comm_str(work_list->thread), work_list->num_merged); > - else > - ret = printf(" %s:%d ", thread__comm_str(work_list->thread), work_list->thread->tid); > + if (work_list->num_merged > 1) { > + ret = printf(" %s:(%d) ", thread__comm_str(work_list->thread), > + work_list->num_merged); > + } else { > + ret = printf(" %s:%d ", thread__comm_str(work_list->thread), > + thread__tid(work_list->thread)); > + } > > for (i = 0; i < 24 - ret; i++) > printf(" "); > @@ -1380,11 +1383,15 @@ static void output_lat_thread(struct perf_sched *sched, struct work_atoms *work_ > > static int pid_cmp(struct work_atoms *l, struct work_atoms *r) > { > + pid_t l_tid, r_tid; > + > if (l->thread == r->thread) > return 0; > - if (l->thread->tid < r->thread->tid) > + l_tid = thread__tid(l->thread); > + r_tid = thread__tid(r->thread); > + if (l_tid < r_tid) > return -1; > - if (l->thread->tid > r->thread->tid) > + if (l_tid > r_tid) > return 1; > return (int)(l->thread - r->thread); > } > @@ -1679,14 +1686,14 @@ static int map_switch_event(struct perf_sched *sched, struct evsel *evsel, > > timestamp__scnprintf_usec(timestamp, stimestamp, sizeof(stimestamp)); > color_fprintf(stdout, color, " %12s secs ", stimestamp); > - if (new_shortname || tr->comm_changed || (verbose > 0 && sched_in->tid)) { > + if (new_shortname || tr->comm_changed || (verbose > 0 && thread__tid(sched_in))) { > const char *pid_color = color; > > if (thread__has_color(sched_in)) > pid_color = COLOR_PIDS; > > color_fprintf(stdout, pid_color, "%s => %s:%d", > - tr->shortname, thread__comm_str(sched_in), sched_in->tid); > + tr->shortname, thread__comm_str(sched_in), thread__tid(sched_in)); > tr->comm_changed = false; > } > > @@ -1948,8 +1955,8 @@ static char *timehist_get_commstr(struct thread *thread) > { > static char str[32]; > const char *comm = thread__comm_str(thread); > - pid_t tid = thread->tid; > - pid_t pid = thread->pid_; > + pid_t tid = thread__tid(thread); > + pid_t pid = thread__pid(thread); > int n; > > if (pid == 0) > @@ -2032,7 +2039,7 @@ static char task_state_char(struct thread *thread, int state) > unsigned bit = state ? ffs(state) : 0; > > /* 'I' for idle */ > - if (thread->tid == 0) > + if (thread__tid(thread) == 0) > return 'I'; > > return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?'; > @@ -2067,7 +2074,7 @@ static void timehist_print_sample(struct perf_sched *sched, > for (i = 0; i < max_cpus; ++i) { > /* flag idle times with 'i'; others are sched events */ > if (i == sample->cpu) > - c = (thread->tid == 0) ? 'i' : 's'; > + c = (thread__tid(thread) == 0) ? 'i' : 's'; > else > c = ' '; > printf("%c", c); > @@ -2094,7 +2101,7 @@ static void timehist_print_sample(struct perf_sched *sched, > if (sched->show_wakeups && !sched->show_next) > printf(" %-*s", comm_width, ""); > > - if (thread->tid == 0) > + if (thread__tid(thread) == 0) > goto out; > > if (sched->show_callchain) > @@ -2626,7 +2633,7 @@ static int timehist_sched_change_event(struct perf_tool *tool, > t = ptime->end; > } > > - if (!sched->idle_hist || thread->tid == 0) { > + if (!sched->idle_hist || thread__tid(thread) == 0) { > if (!cpu_list || test_bit(sample->cpu, cpu_bitmap)) > timehist_update_runtime_stats(tr, t, tprev); > > @@ -2634,7 +2641,7 @@ static int timehist_sched_change_event(struct perf_tool *tool, > struct idle_thread_runtime *itr = (void *)tr; > struct thread_runtime *last_tr; > > - BUG_ON(thread->tid != 0); > + BUG_ON(thread__tid(thread) != 0); > > if (itr->last_thread == NULL) > goto out; > @@ -2719,7 +2726,7 @@ static void print_thread_runtime(struct thread *t, > float stddev; > > printf("%*s %5d %9" PRIu64 " ", > - comm_width, timehist_get_commstr(t), t->ppid, > + comm_width, timehist_get_commstr(t), thread__ppid(t), > (u64) r->run_stats.n); > > print_sched_time(r->total_run_time, 8); > @@ -2739,7 +2746,7 @@ static void print_thread_waittime(struct thread *t, > struct thread_runtime *r) > { > printf("%*s %5d %9" PRIu64 " ", > - comm_width, timehist_get_commstr(t), t->ppid, > + comm_width, timehist_get_commstr(t), thread__ppid(t), > (u64) r->run_stats.n); > > print_sched_time(r->total_run_time, 8); > diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c > index b02ad386a55b..e756290de2ac 100644 > --- a/tools/perf/builtin-script.c > +++ b/tools/perf/builtin-script.c > @@ -1142,7 +1142,7 @@ static int print_srccode(struct thread *thread, u8 cpumode, uint64_t addr) > if (!al.map) > return 0; > ret = map__fprintf_srccode(al.map, al.addr, stdout, > - &thread->srccode_state); > + thread__srccode_state(thread)); > if (ret) > ret += printf("\n"); > return ret; > @@ -1439,7 +1439,7 @@ static int perf_sample__fprintf_callindent(struct perf_sample *sample, > * The 'return' has already been popped off the stack so the depth has > * to be adjusted to match the 'call'. > */ > - if (thread->ts && sample->flags & PERF_IP_FLAG_RETURN) > + if (thread__ts(thread) && sample->flags & PERF_IP_FLAG_RETURN) > depth += 1; > > name = resolve_branch_sym(sample, evsel, thread, al, addr_al, &ip); > @@ -1577,7 +1577,7 @@ static int perf_sample__fprintf_bts(struct perf_sample *sample, > printed += fprintf(fp, "\n"); > if (PRINT_FIELD(SRCCODE)) { > int ret = map__fprintf_srccode(al->map, al->addr, stdout, > - &thread->srccode_state); > + thread__srccode_state(thread)); > if (ret) { > printed += ret; > printed += printf("\n"); > @@ -2086,9 +2086,9 @@ static bool show_event(struct perf_sample *sample, > if (!symbol_conf.graph_function) > return true; > > - if (thread->filter) { > - if (depth <= thread->filter_entry_depth) { > - thread->filter = false; > + if (thread__filter(thread)) { > + if (depth <= thread__filter_entry_depth(thread)) { > + thread__set_filter(thread, false); > return false; > } > return true; > @@ -2105,8 +2105,8 @@ static bool show_event(struct perf_sample *sample, > while (*s) { > unsigned len = strcspn(s, ","); > if (nlen == len && !strncmp(name, s, len)) { > - thread->filter = true; > - thread->filter_entry_depth = depth; > + thread__set_filter(thread, true); > + thread__set_filter_entry_depth(thread, depth); > return true; > } > s += len; > @@ -2186,7 +2186,7 @@ static void process_event(struct perf_script *script, > struct callchain_cursor *cursor = NULL; > > if (script->stitch_lbr) > - al->thread->lbr_stitch_enable = true; > + thread__set_lbr_stitch_enable(al->thread, true); > > if (symbol_conf.use_callchain && sample->callchain && > thread__resolve_callchain(al->thread, &callchain_cursor, evsel, > @@ -2241,7 +2241,7 @@ static void process_event(struct perf_script *script, > > if (PRINT_FIELD(SRCCODE)) { > if (map__fprintf_srccode(al->map, al->addr, stdout, > - &thread->srccode_state)) > + thread__srccode_state(thread))) > printf("\n"); > } > > diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c > index 27a7f068207d..9d3cbebb9b79 100644 > --- a/tools/perf/builtin-top.c > +++ b/tools/perf/builtin-top.c > @@ -777,7 +777,7 @@ static void perf_event__process_sample(struct perf_tool *tool, > return; > > if (top->stitch_lbr) > - al.thread->lbr_stitch_enable = true; > + thread__set_lbr_stitch_enable(al.thread, true); > > if (!machine->kptr_restrict_warned && > symbol_conf.kptr_restrict && > diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c > index b0dd202d14eb..4c9bec39423b 100644 > --- a/tools/perf/builtin-trace.c > +++ b/tools/perf/builtin-trace.c > @@ -1386,12 +1386,13 @@ static int thread__read_fd_path(struct thread *thread, int fd) > struct stat st; > int ret; > > - if (thread->pid_ == thread->tid) { > + if (thread__pid(thread) == thread__tid(thread)) { > scnprintf(linkname, sizeof(linkname), > - "/proc/%d/fd/%d", thread->pid_, fd); > + "/proc/%d/fd/%d", thread__pid(thread), fd); > } else { > scnprintf(linkname, sizeof(linkname), > - "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd); > + "/proc/%d/task/%d/fd/%d", > + thread__pid(thread), thread__tid(thread), fd); > } > > if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname)) > @@ -1559,7 +1560,7 @@ static size_t trace__fprintf_comm_tid(struct trace *trace, struct thread *thread > if (trace->multiple_threads) { > if (trace->show_comm) > printed += fprintf(fp, "%.14s/", thread__comm_str(thread)); > - printed += fprintf(fp, "%d ", thread->tid); > + printed += fprintf(fp, "%d ", thread__tid(thread)); > } > > return printed; > @@ -2205,7 +2206,8 @@ static void thread__update_stats(struct thread *thread, struct thread_trace *ttr > memset(new_errnos + stats->max_errno, 0, (err - stats->max_errno) * sizeof(u32)); > } else { > pr_debug("Not enough memory for errno stats for thread \"%s\"(%d/%d), results will be incomplete\n", > - thread__comm_str(thread), thread->pid_, thread->tid); > + thread__comm_str(thread), thread__pid(thread), > + thread__tid(thread)); > return; > } > > @@ -2550,7 +2552,7 @@ errno_print: { > > if (child != NULL) { > fprintf(trace->output, "%ld", ret); > - if (child->comm_set) > + if (thread__comm_set(child)) > fprintf(trace->output, " (%s)", thread__comm_str(child)); > thread__put(child); > } > @@ -3616,14 +3618,16 @@ static int trace__set_filter_loop_pids(struct trace *trace) > struct thread *thread = machine__find_thread(trace->host, pids[0], pids[0]); > > while (thread && nr < ARRAY_SIZE(pids)) { > - struct thread *parent = machine__find_thread(trace->host, thread->ppid, thread->ppid); > + struct thread *parent = machine__find_thread(trace->host, > + thread__ppid(thread), > + thread__ppid(thread)); > > if (parent == NULL) > break; > > if (!strcmp(thread__comm_str(parent), "sshd") || > strstarts(thread__comm_str(parent), "gnome-terminal")) { > - pids[nr++] = parent->tid; > + pids[nr++] = thread__tid(parent); > break; > } > thread = parent; > @@ -4322,7 +4326,7 @@ static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trac > > ratio = (double)ttrace->nr_events / trace->nr_events * 100.0; > > - printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid); > + printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread__tid(thread)); > printed += fprintf(fp, "%lu events, ", ttrace->nr_events); > printed += fprintf(fp, "%.1f%%", ratio); > if (ttrace->pfmaj) > @@ -4344,7 +4348,9 @@ static unsigned long thread__nr_events(struct thread_trace *ttrace) > return ttrace ? ttrace->nr_events : 0; > } > > -DEFINE_RESORT_RB(threads, (thread__nr_events(a->thread->priv) < thread__nr_events(b->thread->priv)), > +DEFINE_RESORT_RB(threads, > + (thread__nr_events(thread__priv(a->thread)) < > + thread__nr_events(thread__priv(b->thread))), > struct thread *thread; > ) > { > diff --git a/tools/perf/scripts/python/Perf-Trace-Util/Context.c b/tools/perf/scripts/python/Perf-Trace-Util/Context.c > index 53b1587db403..3954bd1587ce 100644 > --- a/tools/perf/scripts/python/Perf-Trace-Util/Context.c > +++ b/tools/perf/scripts/python/Perf-Trace-Util/Context.c > @@ -100,8 +100,8 @@ static PyObject *perf_sample_insn(PyObject *obj, PyObject *args) > if (!c) > return NULL; > > - if (c->sample->ip && !c->sample->insn_len && c->al->thread->maps) { > - struct machine *machine = maps__machine(c->al->thread->maps); > + if (c->sample->ip && !c->sample->insn_len && thread__maps(c->al->thread)) { > + struct machine *machine = maps__machine(thread__maps(c->al->thread)); > > script_fetch_insn(c->sample, c->al->thread, machine); > } > diff --git a/tools/perf/tests/code-reading.c b/tools/perf/tests/code-reading.c > index efe026a35010..9d8eefbebd48 100644 > --- a/tools/perf/tests/code-reading.c > +++ b/tools/perf/tests/code-reading.c > @@ -269,7 +269,7 @@ static int read_object_code(u64 addr, size_t len, u8 cpumode, > len = map__end(al.map) - addr; > > /* Read the object code using perf */ > - ret_len = dso__data_read_offset(dso, maps__machine(thread->maps), > + ret_len = dso__data_read_offset(dso, maps__machine(thread__maps(thread)), > al.addr, buf1, len); > if (ret_len != len) { > pr_debug("dso__data_read_offset failed\n"); > diff --git a/tools/perf/tests/hists_common.c b/tools/perf/tests/hists_common.c > index 745ab18d17db..d08add0f4da6 100644 > --- a/tools/perf/tests/hists_common.c > +++ b/tools/perf/tests/hists_common.c > @@ -211,7 +211,7 @@ void print_hists_out(struct hists *hists) > struct dso *dso = map__dso(he->ms.map); > > pr_info("%2d: entry: %8s:%5d [%-8s] %20s: period = %"PRIu64"/%"PRIu64"\n", > - i, thread__comm_str(he->thread), he->thread->tid, > + i, thread__comm_str(he->thread), thread__tid(he->thread), > dso->short_name, > he->ms.sym->name, he->stat.period, > he->stat_acc ? he->stat_acc->period : 0); > diff --git a/tools/perf/tests/hists_cumulate.c b/tools/perf/tests/hists_cumulate.c > index 8c0e3f334747..62b9c6461ea6 100644 > --- a/tools/perf/tests/hists_cumulate.c > +++ b/tools/perf/tests/hists_cumulate.c > @@ -162,7 +162,6 @@ typedef int (*test_fn_t)(struct evsel *, struct machine *); > #define DSO(he) (map__dso(he->ms.map)->short_name) > #define SYM(he) (he->ms.sym->name) > #define CPU(he) (he->cpu) > -#define PID(he) (he->thread->tid) > #define DEPTH(he) (he->callchain->max_depth) > #define CDSO(cl) (map__dso(cl->ms.map)->short_name) > #define CSYM(cl) (cl->ms.sym->name) > diff --git a/tools/perf/tests/hists_output.c b/tools/perf/tests/hists_output.c > index cebd5226bb12..cd2094c13e1e 100644 > --- a/tools/perf/tests/hists_output.c > +++ b/tools/perf/tests/hists_output.c > @@ -128,7 +128,7 @@ typedef int (*test_fn_t)(struct evsel *, struct machine *); > #define DSO(he) (map__dso(he->ms.map)->short_name) > #define SYM(he) (he->ms.sym->name) > #define CPU(he) (he->cpu) > -#define PID(he) (he->thread->tid) > +#define PID(he) (thread__tid(he->thread)) > > /* default sort keys (no field) */ > static int test1(struct evsel *evsel, struct machine *machine) > diff --git a/tools/perf/tests/perf-targz-src-pkg b/tools/perf/tests/perf-targz-src-pkg > index fae26b1cf08f..b3075c168cb2 100755 > --- a/tools/perf/tests/perf-targz-src-pkg > +++ b/tools/perf/tests/perf-targz-src-pkg > @@ -7,16 +7,17 @@ > # be in such tarball, which sometimes gets broken when we move files around, > # like when we made some files that were in tools/perf/ available to other tools/ > # codebases by moving it to tools/include/, etc. > +set -e > > PERF=$1 > cd ${PERF}/../.. > -make perf-targz-src-pkg > /dev/null > +make perf-targz-src-pkg > TARBALL=$(ls -rt perf-*.tar.gz) > TMP_DEST=$(mktemp -d) > tar xf ${TARBALL} -C $TMP_DEST > rm -f ${TARBALL} > cd - > /dev/null > -make -C $TMP_DEST/perf*/tools/perf > /dev/null > +make -C $TMP_DEST/perf*/tools/perf > RC=$? > rm -rf ${TMP_DEST} > exit $RC > diff --git a/tools/perf/tests/thread-maps-share.c b/tools/perf/tests/thread-maps-share.c > index 858e725318a9..faf980b26252 100644 > --- a/tools/perf/tests/thread-maps-share.c > +++ b/tools/perf/tests/thread-maps-share.c > @@ -42,13 +42,13 @@ static int test__thread_maps_share(struct test_suite *test __maybe_unused, int s > TEST_ASSERT_VAL("failed to create threads", > leader && t1 && t2 && t3 && other); > > - maps = leader->maps; > + maps = thread__maps(leader); > TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(maps__refcnt(maps)), 4); > > /* test the maps pointer is shared */ > - TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(maps) == RC_CHK_ACCESS(t1->maps)); > - TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(maps) == RC_CHK_ACCESS(t2->maps)); > - TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(maps) == RC_CHK_ACCESS(t3->maps)); > + TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(maps) == RC_CHK_ACCESS(thread__maps(t1))); > + TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(maps) == RC_CHK_ACCESS(thread__maps(t2))); > + TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(maps) == RC_CHK_ACCESS(thread__maps(t3))); > > /* > * Verify the other leader was created by previous call. > @@ -70,10 +70,11 @@ static int test__thread_maps_share(struct test_suite *test __maybe_unused, int s > machine__remove_thread(machine, other); > machine__remove_thread(machine, other_leader); > > - other_maps = other->maps; > + other_maps = thread__maps(other); > TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(maps__refcnt(other_maps)), 2); > > - TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(other_maps) == RC_CHK_ACCESS(other_leader->maps)); > + TEST_ASSERT_VAL("maps don't match", RC_CHK_ACCESS(other_maps) == > + RC_CHK_ACCESS(thread__maps(other_leader))); > > /* release thread group */ > thread__put(t3); > diff --git a/tools/perf/trace/beauty/pid.c b/tools/perf/trace/beauty/pid.c > index 1a6acc46807b..8f9c9950f8ba 100644 > --- a/tools/perf/trace/beauty/pid.c > +++ b/tools/perf/trace/beauty/pid.c > @@ -8,10 +8,10 @@ size_t syscall_arg__scnprintf_pid(char *bf, size_t size, struct syscall_arg *arg > struct thread *thread = machine__findnew_thread(trace->host, pid, pid); > > if (thread != NULL) { > - if (!thread->comm_set) > + if (!thread__comm_set(thread)) > thread__set_comm_from_proc(thread); > > - if (thread->comm_set) > + if (thread__comm_set(thread)) > printed += scnprintf(bf + printed, size - printed, > " (%s)", thread__comm_str(thread)); > thread__put(thread); > diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c > index 69c81759a64f..c7ad9e003080 100644 > --- a/tools/perf/ui/browsers/hists.c > +++ b/tools/perf/ui/browsers/hists.c > @@ -2533,13 +2533,15 @@ do_zoom_thread(struct hist_browser *browser, struct popup_action *act) > thread__zput(browser->hists->thread_filter); > ui_helpline__pop(); > } else { > + const char *comm_set_str = > + thread__comm_set(thread) ? thread__comm_str(thread) : ""; > + > if (hists__has(browser->hists, thread)) { > ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s(%d) thread\"", > - thread->comm_set ? thread__comm_str(thread) : "", > - thread->tid); > + comm_set_str, thread__tid(thread)); > } else { > ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s thread\"", > - thread->comm_set ? thread__comm_str(thread) : ""); > + comm_set_str); > } > > browser->hists->thread_filter = thread__get(thread); > @@ -2557,20 +2559,19 @@ add_thread_opt(struct hist_browser *browser, struct popup_action *act, > char **optstr, struct thread *thread) > { > int ret; > + const char *comm_set_str, *in_out; > > if ((!hists__has(browser->hists, thread) && > !hists__has(browser->hists, comm)) || thread == NULL) > return 0; > > + in_out = browser->hists->thread_filter ? "out of" : "into"; > + comm_set_str = thread__comm_set(thread) ? thread__comm_str(thread) : ""; > if (hists__has(browser->hists, thread)) { > ret = asprintf(optstr, "Zoom %s %s(%d) thread", > - browser->hists->thread_filter ? "out of" : "into", > - thread->comm_set ? thread__comm_str(thread) : "", > - thread->tid); > + in_out, comm_set_str, thread__tid(thread)); > } else { > - ret = asprintf(optstr, "Zoom %s %s thread", > - browser->hists->thread_filter ? "out of" : "into", > - thread->comm_set ? thread__comm_str(thread) : ""); > + ret = asprintf(optstr, "Zoom %s %s thread", in_out, comm_set_str); > } > if (ret < 0) > return 0; > diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c > index f36270485168..b849caace398 100644 > --- a/tools/perf/ui/stdio/hist.c > +++ b/tools/perf/ui/stdio/hist.c > @@ -885,7 +885,7 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows, > } > > if (h->ms.map == NULL && verbose > 1) { > - maps__fprintf(h->thread->maps, fp); > + maps__fprintf(thread__maps(h->thread), fp); > fprintf(fp, "%.10s end\n", graph_dotted_line); > } > } > diff --git a/tools/perf/util/arm-spe.c b/tools/perf/util/arm-spe.c > index 7b36ba6b4079..afbd5869f6bf 100644 > --- a/tools/perf/util/arm-spe.c > +++ b/tools/perf/util/arm-spe.c > @@ -254,9 +254,9 @@ static void arm_spe_set_pid_tid_cpu(struct arm_spe *spe, > } > > if (speq->thread) { > - speq->pid = speq->thread->pid_; > + speq->pid = thread__pid(speq->thread); > if (queue->cpu == -1) > - speq->cpu = speq->thread->cpu; > + speq->cpu = thread__cpu(speq->thread); > } > } > > diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c > index 0f5be4ad24ba..b550c7393155 100644 > --- a/tools/perf/util/cs-etm.c > +++ b/tools/perf/util/cs-etm.c > @@ -1311,7 +1311,7 @@ static void cs_etm__set_pid_tid_cpu(struct cs_etm_auxtrace *etm, > tidq->tid); > > if (tidq->thread) > - tidq->pid = tidq->thread->pid_; > + tidq->pid = thread__pid(tidq->thread); > } > > int cs_etm__etmq_set_tid(struct cs_etm_queue *etmq, > diff --git a/tools/perf/util/data-convert-json.c b/tools/perf/util/data-convert-json.c > index 653709ab867a..291591e303cd 100644 > --- a/tools/perf/util/data-convert-json.c > +++ b/tools/perf/util/data-convert-json.c > @@ -172,13 +172,13 @@ static int process_sample_event(struct perf_tool *tool, > output_json_format(out, false, 2, "{"); > > output_json_key_format(out, false, 3, "timestamp", "%" PRIi64, sample->time); > - output_json_key_format(out, true, 3, "pid", "%i", al.thread->pid_); > - output_json_key_format(out, true, 3, "tid", "%i", al.thread->tid); > + output_json_key_format(out, true, 3, "pid", "%i", thread__pid(al.thread)); > + output_json_key_format(out, true, 3, "tid", "%i", thread__tid(al.thread)); > > if ((sample_type & PERF_SAMPLE_CPU)) > output_json_key_format(out, true, 3, "cpu", "%i", sample->cpu); > - else if (al.thread->cpu >= 0) > - output_json_key_format(out, true, 3, "cpu", "%i", al.thread->cpu); > + else if (thread__cpu(al.thread) >= 0) > + output_json_key_format(out, true, 3, "cpu", "%i", thread__cpu(al.thread)); > > output_json_key_string(out, true, 3, "comm", thread__comm_str(al.thread)); > > diff --git a/tools/perf/util/db-export.c b/tools/perf/util/db-export.c > index 84c970c11794..751fd53bfd93 100644 > --- a/tools/perf/util/db-export.c > +++ b/tools/perf/util/db-export.c > @@ -64,13 +64,13 @@ int db_export__thread(struct db_export *dbe, struct thread *thread, > { > u64 main_thread_db_id = 0; > > - if (thread->db_id) > + if (thread__db_id(thread)) > return 0; > > - thread->db_id = ++dbe->thread_last_db_id; > + thread__set_db_id(thread, ++dbe->thread_last_db_id); > > if (main_thread) > - main_thread_db_id = main_thread->db_id; > + main_thread_db_id = thread__db_id(main_thread); > > if (dbe->export_thread) > return dbe->export_thread(dbe, thread, main_thread_db_id, > @@ -251,7 +251,7 @@ static struct call_path *call_path_from_sample(struct db_export *dbe, > */ > al.sym = node->ms.sym; > al.map = node->ms.map; > - al.maps = thread->maps; > + al.maps = thread__maps(thread); > al.addr = node->ip; > > if (al.map && !al.sym) > @@ -321,7 +321,7 @@ static int db_export__threads(struct db_export *dbe, struct thread *thread, > * For a non-main thread, db_export__comm_thread() must be > * called only if thread has not previously been exported. > */ > - bool export_comm_thread = comm && !thread->db_id; > + bool export_comm_thread = comm && !thread__db_id(thread); > > err = db_export__thread(dbe, thread, machine, main_thread); > if (err) > @@ -529,16 +529,16 @@ static int db_export__pid_tid(struct db_export *dbe, struct machine *machine, > struct thread *main_thread; > int err = 0; > > - if (!thread || !thread->comm_set) > + if (!thread || !thread__comm_set(thread)) > goto out_put; > > - *is_idle = !thread->pid_ && !thread->tid; > + *is_idle = !thread__pid(thread) && !thread__tid(thread); > > main_thread = thread__main_thread(machine, thread); > > err = db_export__threads(dbe, thread, main_thread, machine, comm_ptr); > > - *db_id = thread->db_id; > + *db_id = thread__db_id(thread); > > thread__put(main_thread); > out_put: > diff --git a/tools/perf/util/dlfilter.c b/tools/perf/util/dlfilter.c > index 16238f823a5e..8016f21dc0b8 100644 > --- a/tools/perf/util/dlfilter.c > +++ b/tools/perf/util/dlfilter.c > @@ -197,8 +197,8 @@ static const __u8 *dlfilter__insn(void *ctx, __u32 *len) > if (!al->thread && machine__resolve(d->machine, al, d->sample) < 0) > return NULL; > > - if (al->thread->maps) { > - struct machine *machine = maps__machine(al->thread->maps); > + if (thread__maps(al->thread)) { > + struct machine *machine = maps__machine(thread__maps(al->thread)); > > if (machine) > script_fetch_insn(d->sample, al->thread, machine); > diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c > index e8b0666d913c..e1ce7cb5e421 100644 > --- a/tools/perf/util/event.c > +++ b/tools/perf/util/event.c > @@ -573,7 +573,7 @@ int perf_event__process(struct perf_tool *tool __maybe_unused, > struct map *thread__find_map(struct thread *thread, u8 cpumode, u64 addr, > struct addr_location *al) > { > - struct maps *maps = thread->maps; > + struct maps *maps = thread__maps(thread); > struct machine *machine = maps__machine(maps); > bool load_map = false; > > @@ -639,7 +639,7 @@ struct map *thread__find_map_fb(struct thread *thread, u8 cpumode, u64 addr, > struct addr_location *al) > { > struct map *map = thread__find_map(thread, cpumode, addr, al); > - struct machine *machine = maps__machine(thread->maps); > + struct machine *machine = maps__machine(thread__maps(thread)); > u8 addr_cpumode = machine__addr_cpumode(machine, cpumode, addr); > > if (map || addr_cpumode == cpumode) > @@ -696,7 +696,7 @@ int machine__resolve(struct machine *machine, struct addr_location *al, > if (thread == NULL) > return -1; > > - dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread->tid); > + dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread__tid(thread)); > thread__find_map(thread, sample->cpumode, sample->ip, al); > dso = al->map ? map__dso(al->map) : NULL; > dump_printf(" ...... dso: %s\n", > diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c > index 3c9301a26dfc..4bc3affbe891 100644 > --- a/tools/perf/util/hist.c > +++ b/tools/perf/util/hist.c > @@ -2778,12 +2778,12 @@ int __hists__scnprintf_title(struct hists *hists, char *bf, size_t size, bool sh > if (hists__has(hists, thread)) { > printed += scnprintf(bf + printed, size - printed, > ", Thread: %s(%d)", > - (thread->comm_set ? thread__comm_str(thread) : ""), > - thread->tid); > + (thread__comm_set(thread) ? thread__comm_str(thread) : ""), > + thread__tid(thread)); > } else { > printed += scnprintf(bf + printed, size - printed, > ", Thread: %s", > - (thread->comm_set ? thread__comm_str(thread) : "")); > + (thread__comm_set(thread) ? thread__comm_str(thread) : "")); > } > } > if (dso) > diff --git a/tools/perf/util/intel-bts.c b/tools/perf/util/intel-bts.c > index 2c8147a62203..ec1b3bd9f530 100644 > --- a/tools/perf/util/intel-bts.c > +++ b/tools/perf/util/intel-bts.c > @@ -456,7 +456,7 @@ static int intel_bts_process_queue(struct intel_bts_queue *btsq, u64 *timestamp) > thread = machine__find_thread(btsq->bts->machine, -1, > btsq->tid); > if (thread) > - btsq->pid = thread->pid_; > + btsq->pid = thread__pid(thread); > } else { > thread = machine__findnew_thread(btsq->bts->machine, btsq->pid, > btsq->tid); > diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c > index dde2ca77a005..45c7e7722916 100644 > --- a/tools/perf/util/intel-pt.c > +++ b/tools/perf/util/intel-pt.c > @@ -1428,13 +1428,13 @@ static int intel_pt_get_guest_from_sideband(struct intel_pt_queue *ptq) > ptq->guest_machine = machine; > } > > - vcpu = ptq->thread ? ptq->thread->guest_cpu : -1; > + vcpu = ptq->thread ? thread__guest_cpu(ptq->thread) : -1; > if (vcpu < 0) > return -1; > > tid = machine__get_current_tid(machine, vcpu); > > - if (ptq->guest_thread && ptq->guest_thread->tid != tid) > + if (ptq->guest_thread && thread__tid(ptq->guest_thread) != tid) > thread__zput(ptq->guest_thread); > > if (!ptq->guest_thread) { > @@ -1444,7 +1444,7 @@ static int intel_pt_get_guest_from_sideband(struct intel_pt_queue *ptq) > } > > ptq->guest_machine_pid = machine_pid; > - ptq->guest_pid = ptq->guest_thread->pid_; > + ptq->guest_pid = thread__pid(ptq->guest_thread); > ptq->guest_tid = tid; > ptq->vcpu = vcpu; > > @@ -1467,9 +1467,9 @@ static void intel_pt_set_pid_tid_cpu(struct intel_pt *pt, > ptq->thread = machine__find_thread(pt->machine, -1, ptq->tid); > > if (ptq->thread) { > - ptq->pid = ptq->thread->pid_; > + ptq->pid = thread__pid(ptq->thread); > if (queue->cpu == -1) > - ptq->cpu = ptq->thread->cpu; > + ptq->cpu = thread__cpu(ptq->thread); > } > > if (pt->have_guest_sideband && intel_pt_get_guest_from_sideband(ptq)) { > @@ -3074,7 +3074,7 @@ static void intel_pt_sample_set_pid_tid_cpu(struct intel_pt_queue *ptq, > if (ptq->pid == -1) { > ptq->thread = machine__find_thread(m, -1, ptq->tid); > if (ptq->thread) > - ptq->pid = ptq->thread->pid_; > + ptq->pid = thread__pid(ptq->thread); > return; > } > > diff --git a/tools/perf/util/jitdump.c b/tools/perf/util/jitdump.c > index 28e49502db5e..2380b41a4caa 100644 > --- a/tools/perf/util/jitdump.c > +++ b/tools/perf/util/jitdump.c > @@ -799,17 +799,19 @@ static void jit_add_pid(struct machine *machine, pid_t pid) > return; > } > > - thread->priv = (void *)1; > + thread__set_priv(thread, (void *)true); > } > > static bool jit_has_pid(struct machine *machine, pid_t pid) > { > struct thread *thread = machine__find_thread(machine, pid, pid); > + void *priv; > > if (!thread) > - return 0; > + return false; > > - return (bool)thread->priv; > + priv = thread__priv(thread); > + return (bool)priv; > } > > int > @@ -833,7 +835,7 @@ jit_process(struct perf_session *session, > return 0; > } > > - nsi = nsinfo__get(thread->nsinfo); > + nsi = nsinfo__get(thread__nsinfo(thread)); > thread__put(thread); > > /* > diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c > index cbf092e32ee9..5d34d60a0045 100644 > --- a/tools/perf/util/machine.c > +++ b/tools/perf/util/machine.c > @@ -77,13 +77,14 @@ static int thread_rb_node__cmp_tid(const void *key, const struct rb_node *nd) > { > int to_find = (int) *((pid_t *)key); > > - return to_find - (int)rb_entry(nd, struct thread_rb_node, rb_node)->thread->tid; > + return to_find - (int)thread__tid(rb_entry(nd, struct thread_rb_node, rb_node)->thread); > } > > static struct thread_rb_node *thread_rb_node__find(const struct thread *th, > struct rb_root *tree) > { > - struct rb_node *nd = rb_find(&th->tid, tree, thread_rb_node__cmp_tid); > + pid_t to_find = thread__tid(th); > + struct rb_node *nd = rb_find(&to_find, tree, thread_rb_node__cmp_tid); > > return rb_entry(nd, struct thread_rb_node, rb_node); > } > @@ -440,7 +441,7 @@ static struct thread *findnew_guest_code(struct machine *machine, > return NULL; > > /* Assume maps are set up if there are any */ > - if (maps__nr_maps(thread->maps)) > + if (maps__nr_maps(thread__maps(thread))) > return thread; > > host_thread = machine__find_thread(host_machine, -1, pid); > @@ -453,7 +454,7 @@ static struct thread *findnew_guest_code(struct machine *machine, > * Guest code can be found in hypervisor process at the same address > * so copy host maps. > */ > - err = maps__clone(thread, host_thread->maps); > + err = maps__clone(thread, thread__maps(host_thread)); > thread__put(host_thread); > if (err) > goto out_err; > @@ -518,45 +519,45 @@ static void machine__update_thread_pid(struct machine *machine, > { > struct thread *leader; > > - if (pid == th->pid_ || pid == -1 || th->pid_ != -1) > + if (pid == thread__pid(th) || pid == -1 || thread__pid(th) != -1) > return; > > - th->pid_ = pid; > + thread__set_pid(th, pid); > > - if (th->pid_ == th->tid) > + if (thread__pid(th) == thread__tid(th)) > return; > > - leader = __machine__findnew_thread(machine, th->pid_, th->pid_); > + leader = __machine__findnew_thread(machine, thread__pid(th), thread__pid(th)); > if (!leader) > goto out_err; > > - if (!leader->maps) > - leader->maps = maps__new(machine); > + if (!thread__maps(leader)) > + thread__set_maps(leader, maps__new(machine)); > > - if (!leader->maps) > + if (!thread__maps(leader)) > goto out_err; > > - if (th->maps == leader->maps) > + if (thread__maps(th) == thread__maps(leader)) > return; > > - if (th->maps) { > + if (thread__maps(th)) { > /* > * Maps are created from MMAP events which provide the pid and > * tid. Consequently there never should be any maps on a thread > * with an unknown pid. Just print an error if there are. > */ > - if (!maps__empty(th->maps)) > + if (!maps__empty(thread__maps(th))) > pr_err("Discarding thread maps for %d:%d\n", > - th->pid_, th->tid); > - maps__put(th->maps); > + thread__pid(th), thread__tid(th)); > + maps__put(thread__maps(th)); > } > > - th->maps = maps__get(leader->maps); > + thread__set_maps(th, maps__get(thread__maps(leader))); > out_put: > thread__put(leader); > return; > out_err: > - pr_err("Failed to join map groups for %d:%d\n", th->pid_, th->tid); > + pr_err("Failed to join map groups for %d:%d\n", thread__pid(th), thread__tid(th)); > goto out_put; > } > > @@ -573,7 +574,7 @@ __threads__get_last_match(struct threads *threads, struct machine *machine, > > th = threads->last_match; > if (th != NULL) { > - if (th->tid == tid) { > + if (thread__tid(th) == tid) { > machine__update_thread_pid(machine, th, pid); > return thread__get(th); > } > @@ -632,13 +633,13 @@ static struct thread *____machine__findnew_thread(struct machine *machine, > parent = *p; > th = rb_entry(parent, struct thread_rb_node, rb_node)->thread; > > - if (th->tid == tid) { > + if (thread__tid(th) == tid) { > threads__set_last_match(threads, th); > machine__update_thread_pid(machine, th, pid); > return thread__get(th); > } > > - if (tid < th->tid) > + if (tid < thread__tid(th)) > p = &(*p)->rb_left; > else { > p = &(*p)->rb_right; > @@ -2049,7 +2050,7 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event > static void __machine__remove_thread(struct machine *machine, struct thread_rb_node *nd, > struct thread *th, bool lock) > { > - struct threads *threads = machine__threads(machine, th->tid); > + struct threads *threads = machine__threads(machine, thread__tid(th)); > > if (!nd) > nd = thread_rb_node__find(th, &threads->entries.rb_root); > @@ -2060,7 +2061,7 @@ static void __machine__remove_thread(struct machine *machine, struct thread_rb_n > if (lock) > down_write(&threads->lock); > > - BUG_ON(refcount_read(&th->refcnt) == 0); > + BUG_ON(refcount_read(thread__refcnt(th)) == 0); > > thread__put(nd->thread); > rb_erase_cached(&nd->rb_node, &threads->entries); > @@ -2099,9 +2100,9 @@ int machine__process_fork_event(struct machine *machine, union perf_event *event > * (fork) event that would have removed the thread was lost. Assume the > * latter case and continue on as best we can. > */ > - if (parent->pid_ != (pid_t)event->fork.ppid) { > + if (thread__pid(parent) != (pid_t)event->fork.ppid) { > dump_printf("removing erroneous parent thread %d/%d\n", > - parent->pid_, parent->tid); > + thread__pid(parent), thread__tid(parent)); > machine__remove_thread(machine, parent); > thread__put(parent); > parent = machine__findnew_thread(machine, event->fork.ppid, > @@ -2511,7 +2512,7 @@ static void save_lbr_cursor_node(struct thread *thread, > struct callchain_cursor *cursor, > int idx) > { > - struct lbr_stitch *lbr_stitch = thread->lbr_stitch; > + struct lbr_stitch *lbr_stitch = thread__lbr_stitch(thread); > > if (!lbr_stitch) > return; > @@ -2553,7 +2554,7 @@ static int lbr_callchain_add_lbr_ip(struct thread *thread, > * in callchain_cursor_commit() when the writing session is closed. > * Using curr and pos to track the current cursor node. > */ > - if (thread->lbr_stitch) { > + if (thread__lbr_stitch(thread)) { > cursor->curr = NULL; > cursor->pos = cursor->nr; > if (cursor->nr) { > @@ -2581,7 +2582,7 @@ static int lbr_callchain_add_lbr_ip(struct thread *thread, > * But does not need to save current cursor node for entry 0. > * It's impossible to stitch the whole LBRs of previous sample. > */ > - if (thread->lbr_stitch && (cursor->pos != cursor->nr)) { > + if (thread__lbr_stitch(thread) && (cursor->pos != cursor->nr)) { > if (!cursor->curr) > cursor->curr = cursor->first; > else > @@ -2634,7 +2635,7 @@ static int lbr_callchain_add_lbr_ip(struct thread *thread, > static int lbr_callchain_add_stitched_lbr_ip(struct thread *thread, > struct callchain_cursor *cursor) > { > - struct lbr_stitch *lbr_stitch = thread->lbr_stitch; > + struct lbr_stitch *lbr_stitch = thread__lbr_stitch(thread); > struct callchain_cursor_node *cnode; > struct stitch_list *stitch_node; > int err; > @@ -2658,7 +2659,7 @@ static int lbr_callchain_add_stitched_lbr_ip(struct thread *thread, > > static struct stitch_list *get_stitch_node(struct thread *thread) > { > - struct lbr_stitch *lbr_stitch = thread->lbr_stitch; > + struct lbr_stitch *lbr_stitch = thread__lbr_stitch(thread); > struct stitch_list *stitch_node; > > if (!list_empty(&lbr_stitch->free_lists)) { > @@ -2682,7 +2683,7 @@ static bool has_stitched_lbr(struct thread *thread, > struct branch_entry *cur_entries = perf_sample__branch_entries(cur); > struct branch_stack *prev_stack = prev->branch_stack; > struct branch_entry *prev_entries = perf_sample__branch_entries(prev); > - struct lbr_stitch *lbr_stitch = thread->lbr_stitch; > + struct lbr_stitch *lbr_stitch = thread__lbr_stitch(thread); > int i, j, nr_identical_branches = 0; > struct stitch_list *stitch_node; > u64 cur_base, distance; > @@ -2746,27 +2747,29 @@ static bool has_stitched_lbr(struct thread *thread, > > static bool alloc_lbr_stitch(struct thread *thread, unsigned int max_lbr) > { > - if (thread->lbr_stitch) > + if (thread__lbr_stitch(thread)) > return true; > > - thread->lbr_stitch = zalloc(sizeof(*thread->lbr_stitch)); > - if (!thread->lbr_stitch) > + thread__set_lbr_stitch(thread, zalloc(sizeof(struct lbr_stitch))); > + if (!thread__lbr_stitch(thread)) > goto err; > > - thread->lbr_stitch->prev_lbr_cursor = calloc(max_lbr + 1, sizeof(struct callchain_cursor_node)); > - if (!thread->lbr_stitch->prev_lbr_cursor) > + thread__lbr_stitch(thread)->prev_lbr_cursor = > + calloc(max_lbr + 1, sizeof(struct callchain_cursor_node)); > + if (!thread__lbr_stitch(thread)->prev_lbr_cursor) > goto free_lbr_stitch; > > - INIT_LIST_HEAD(&thread->lbr_stitch->lists); > - INIT_LIST_HEAD(&thread->lbr_stitch->free_lists); > + INIT_LIST_HEAD(&thread__lbr_stitch(thread)->lists); > + INIT_LIST_HEAD(&thread__lbr_stitch(thread)->free_lists); > > return true; > > free_lbr_stitch: > - zfree(&thread->lbr_stitch); > + free(thread__lbr_stitch(thread)); > + thread__set_lbr_stitch(thread, NULL); > err: > pr_warning("Failed to allocate space for stitched LBRs. Disable LBR stitch\n"); > - thread->lbr_stitch_enable = false; > + thread__set_lbr_stitch_enable(thread, false); > return false; > } > > @@ -2802,9 +2805,9 @@ static int resolve_lbr_callchain_sample(struct thread *thread, > if (i == chain_nr) > return 0; > > - if (thread->lbr_stitch_enable && !sample->no_hw_idx && > + if (thread__lbr_stitch_enable(thread) && !sample->no_hw_idx && > (max_lbr > 0) && alloc_lbr_stitch(thread, max_lbr)) { > - lbr_stitch = thread->lbr_stitch; > + lbr_stitch = thread__lbr_stitch(thread); > > stitched_lbr = has_stitched_lbr(thread, sample, > &lbr_stitch->prev_sample, > @@ -2884,7 +2887,7 @@ static int find_prev_cpumode(struct ip_callchain *chain, struct thread *thread, > static u64 get_leaf_frame_caller(struct perf_sample *sample, > struct thread *thread, int usr_idx) > { > - if (machine__normalized_is(maps__machine(thread->maps), "arm64")) > + if (machine__normalized_is(maps__machine(thread__maps(thread)), "arm64")) > return get_leaf_frame_caller_aarch64(sample, thread, usr_idx); > else > return 0; > @@ -3265,7 +3268,7 @@ int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid, > if (!thread) > return -ENOMEM; > > - thread->cpu = cpu; > + thread__set_cpu(thread, cpu); > thread__put(thread); > > return 0; > diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c > index 4d9944bbf5e4..ae1d54d4880a 100644 > --- a/tools/perf/util/map.c > +++ b/tools/perf/util/map.c > @@ -137,7 +137,7 @@ struct map *map__new(struct machine *machine, u64 start, u64 len, > no_dso = is_no_dso_memory(filename); > map->prot = prot; > map->flags = flags; > - nsi = nsinfo__get(thread->nsinfo); > + nsi = nsinfo__get(thread__nsinfo(thread)); > > if ((anon || no_dso) && nsi && (prot & PROT_EXEC)) { > snprintf(newfilename, sizeof(newfilename), > diff --git a/tools/perf/util/maps.c b/tools/perf/util/maps.c > index 1aeb1db58fe5..5ae6379a1b42 100644 > --- a/tools/perf/util/maps.c > +++ b/tools/perf/util/maps.c > @@ -384,7 +384,7 @@ int maps__fixup_overlappings(struct maps *maps, struct map *map, FILE *fp) > */ > int maps__clone(struct thread *thread, struct maps *parent) > { > - struct maps *maps = thread->maps; > + struct maps *maps = thread__maps(thread); > int err; > struct map_rb_node *rb_node; > > diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c > index 40964078f92f..f3d262e871ac 100644 > --- a/tools/perf/util/scripting-engines/trace-event-python.c > +++ b/tools/perf/util/scripting-engines/trace-event-python.c > @@ -1163,11 +1163,11 @@ static int python_export_thread(struct db_export *dbe, struct thread *thread, > > t = tuple_new(5); > > - tuple_set_d64(t, 0, thread->db_id); > + tuple_set_d64(t, 0, thread__db_id(thread)); > tuple_set_d64(t, 1, machine->db_id); > tuple_set_d64(t, 2, main_thread_db_id); > - tuple_set_s32(t, 3, thread->pid_); > - tuple_set_s32(t, 4, thread->tid); > + tuple_set_s32(t, 3, thread__pid(thread)); > + tuple_set_s32(t, 4, thread__tid(thread)); > > call_object(tables->thread_handler, t, "thread_table"); > > @@ -1186,7 +1186,7 @@ static int python_export_comm(struct db_export *dbe, struct comm *comm, > > tuple_set_d64(t, 0, comm->db_id); > tuple_set_string(t, 1, comm__str(comm)); > - tuple_set_d64(t, 2, thread->db_id); > + tuple_set_d64(t, 2, thread__db_id(thread)); > tuple_set_d64(t, 3, comm->start); > tuple_set_s32(t, 4, comm->exec); > > @@ -1207,7 +1207,7 @@ static int python_export_comm_thread(struct db_export *dbe, u64 db_id, > > tuple_set_d64(t, 0, db_id); > tuple_set_d64(t, 1, comm->db_id); > - tuple_set_d64(t, 2, thread->db_id); > + tuple_set_d64(t, 2, thread__db_id(thread)); > > call_object(tables->comm_thread_handler, t, "comm_thread_table"); > > @@ -1292,7 +1292,7 @@ static void python_export_sample_table(struct db_export *dbe, > tuple_set_d64(t, 0, es->db_id); > tuple_set_d64(t, 1, es->evsel->db_id); > tuple_set_d64(t, 2, maps__machine(es->al->maps)->db_id); > - tuple_set_d64(t, 3, es->al->thread->db_id); > + tuple_set_d64(t, 3, thread__db_id(es->al->thread)); > tuple_set_d64(t, 4, es->comm_db_id); > tuple_set_d64(t, 5, es->dso_db_id); > tuple_set_d64(t, 6, es->sym_db_id); > @@ -1382,7 +1382,7 @@ static int python_export_call_return(struct db_export *dbe, > t = tuple_new(14); > > tuple_set_d64(t, 0, cr->db_id); > - tuple_set_d64(t, 1, cr->thread->db_id); > + tuple_set_d64(t, 1, thread__db_id(cr->thread)); > tuple_set_d64(t, 2, comm_db_id); > tuple_set_d64(t, 3, cr->cp->db_id); > tuple_set_d64(t, 4, cr->call_time); > diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c > index e2806791c76a..65ac9f7fdf7e 100644 > --- a/tools/perf/util/session.c > +++ b/tools/perf/util/session.c > @@ -2807,7 +2807,7 @@ static int perf_session__set_guest_cpu(struct perf_session *session, pid_t pid, > > if (!thread) > return -ENOMEM; > - thread->guest_cpu = guest_cpu; > + thread__set_guest_cpu(thread, guest_cpu); > thread__put(thread); > > return 0; > diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c > index 650cd8df4041..5e45c770f91d 100644 > --- a/tools/perf/util/sort.c > +++ b/tools/perf/util/sort.c > @@ -108,7 +108,7 @@ static int64_t cmp_null(const void *l, const void *r) > static int64_t > sort__thread_cmp(struct hist_entry *left, struct hist_entry *right) > { > - return right->thread->tid - left->thread->tid; > + return thread__tid(right->thread) - thread__tid(left->thread); > } > > static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf, > @@ -117,7 +117,7 @@ static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf, > const char *comm = thread__comm_str(he->thread); > > width = max(7U, width) - 8; > - return repsep_snprintf(bf, size, "%7d:%-*.*s", he->thread->tid, > + return repsep_snprintf(bf, size, "%7d:%-*.*s", thread__tid(he->thread), > width, width, comm ?: ""); > } > > @@ -1543,8 +1543,10 @@ sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right) > !l_dso->id.ino && !l_dso->id.ino_generation) { > /* userspace anonymous */ > > - if (left->thread->pid_ > right->thread->pid_) return -1; > - if (left->thread->pid_ < right->thread->pid_) return 1; > + if (thread__pid(left->thread) > thread__pid(right->thread)) > + return -1; > + if (thread__pid(left->thread) < thread__pid(right->thread)) > + return 1; > } > > addr: > diff --git a/tools/perf/util/thread-stack.c b/tools/perf/util/thread-stack.c > index 4b85c1728012..374d142e7390 100644 > --- a/tools/perf/util/thread-stack.c > +++ b/tools/perf/util/thread-stack.c > @@ -112,7 +112,7 @@ struct thread_stack { > */ > static inline bool thread_stack__per_cpu(struct thread *thread) > { > - return !(thread->tid || thread->pid_); > + return !(thread__tid(thread) || thread__pid(thread)); > } > > static int thread_stack__grow(struct thread_stack *ts) > @@ -155,8 +155,8 @@ static int thread_stack__init(struct thread_stack *ts, struct thread *thread, > ts->br_stack_sz = br_stack_sz; > } > > - if (thread->maps && maps__machine(thread->maps)) { > - struct machine *machine = maps__machine(thread->maps); > + if (thread__maps(thread) && maps__machine(thread__maps(thread))) { > + struct machine *machine = maps__machine(thread__maps(thread)); > const char *arch = perf_env__arch(machine->env); > > ts->kernel_start = machine__kernel_start(machine); > @@ -175,7 +175,7 @@ static struct thread_stack *thread_stack__new(struct thread *thread, int cpu, > bool callstack, > unsigned int br_stack_sz) > { > - struct thread_stack *ts = thread->ts, *new_ts; > + struct thread_stack *ts = thread__ts(thread), *new_ts; > unsigned int old_sz = ts ? ts->arr_sz : 0; > unsigned int new_sz = 1; > > @@ -189,8 +189,8 @@ static struct thread_stack *thread_stack__new(struct thread *thread, int cpu, > if (ts) > memcpy(new_ts, ts, old_sz * sizeof(*ts)); > new_ts->arr_sz = new_sz; > - zfree(&thread->ts); > - thread->ts = new_ts; > + free(thread__ts(thread)); > + thread__set_ts(thread, new_ts); > ts = new_ts; > } > > @@ -207,7 +207,7 @@ static struct thread_stack *thread_stack__new(struct thread *thread, int cpu, > > static struct thread_stack *thread__cpu_stack(struct thread *thread, int cpu) > { > - struct thread_stack *ts = thread->ts; > + struct thread_stack *ts = thread__ts(thread); > > if (cpu < 0) > cpu = 0; > @@ -232,7 +232,7 @@ static inline struct thread_stack *thread__stack(struct thread *thread, > if (thread_stack__per_cpu(thread)) > return thread__cpu_stack(thread, cpu); > > - return thread->ts; > + return thread__ts(thread); > } > > static int thread_stack__push(struct thread_stack *ts, u64 ret_addr, > @@ -363,7 +363,7 @@ static int __thread_stack__flush(struct thread *thread, struct thread_stack *ts) > > int thread_stack__flush(struct thread *thread) > { > - struct thread_stack *ts = thread->ts; > + struct thread_stack *ts = thread__ts(thread); > unsigned int pos; > int err = 0; > > @@ -502,13 +502,14 @@ static void thread_stack__reset(struct thread *thread, struct thread_stack *ts) > > void thread_stack__free(struct thread *thread) > { > - struct thread_stack *ts = thread->ts; > + struct thread_stack *ts = thread__ts(thread); > unsigned int pos; > > if (ts) { > for (pos = 0; pos < ts->arr_sz; pos++) > __thread_stack__free(thread, ts + pos); > - zfree(&thread->ts); > + free(thread__ts(thread)); > + thread__set_ts(thread, NULL); > } > } > > @@ -1127,7 +1128,7 @@ int thread_stack__process(struct thread *thread, struct comm *comm, > ts->rstate = X86_RETPOLINE_POSSIBLE; > > /* Flush stack on exec */ > - if (ts->comm != comm && thread->pid_ == thread->tid) { > + if (ts->comm != comm && thread__pid(thread) == thread__tid(thread)) { > err = __thread_stack__flush(thread, ts); > if (err) > return err; > diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c > index 38d300e3e4d3..9a1db3be6436 100644 > --- a/tools/perf/util/thread.c > +++ b/tools/perf/util/thread.c > @@ -21,19 +21,20 @@ > > int thread__init_maps(struct thread *thread, struct machine *machine) > { > - pid_t pid = thread->pid_; > + pid_t pid = thread__pid(thread); > > - if (pid == thread->tid || pid == -1) { > - thread->maps = maps__new(machine); > + if (pid == thread__tid(thread) || pid == -1) { > + thread__set_maps(thread, maps__new(machine)); > } else { > struct thread *leader = __machine__findnew_thread(machine, pid, pid); > + > if (leader) { > - thread->maps = maps__get(leader->maps); > + thread__set_maps(thread, maps__get(thread__maps(leader))); > thread__put(leader); > } > } > > - return thread->maps ? 0 : -1; > + return thread__maps(thread) ? 0 : -1; > } > > struct thread *thread__new(pid_t pid, pid_t tid) > @@ -43,16 +44,16 @@ struct thread *thread__new(pid_t pid, pid_t tid) > struct thread *thread = zalloc(sizeof(*thread)); > > if (thread != NULL) { > - thread->pid_ = pid; > - thread->tid = tid; > - thread->ppid = -1; > - thread->cpu = -1; > - thread->guest_cpu = -1; > - thread->lbr_stitch_enable = false; > - INIT_LIST_HEAD(&thread->namespaces_list); > - INIT_LIST_HEAD(&thread->comm_list); > - init_rwsem(&thread->namespaces_lock); > - init_rwsem(&thread->comm_lock); > + thread__set_pid(thread, pid); > + thread__set_tid(thread, tid); > + thread__set_ppid(thread, -1); > + thread__set_cpu(thread, -1); > + thread__set_guest_cpu(thread, -1); > + thread__set_lbr_stitch_enable(thread, false); > + INIT_LIST_HEAD(thread__namespaces_list(thread)); > + INIT_LIST_HEAD(thread__comm_list(thread)); > + init_rwsem(thread__namespaces_lock(thread)); > + init_rwsem(thread__comm_lock(thread)); > > comm_str = malloc(32); > if (!comm_str) > @@ -64,11 +65,11 @@ struct thread *thread__new(pid_t pid, pid_t tid) > if (!comm) > goto err_thread; > > - list_add(&comm->list, &thread->comm_list); > - refcount_set(&thread->refcnt, 1); > + list_add(&comm->list, thread__comm_list(thread)); > + refcount_set(thread__refcnt(thread), 1); > /* Thread holds first ref to nsdata. */ > thread->nsinfo = nsinfo__new(pid); > - srccode_state_init(&thread->srccode_state); > + srccode_state_init(thread__srccode_state(thread)); > } > > return thread; > @@ -85,30 +86,30 @@ void thread__delete(struct thread *thread) > > thread_stack__free(thread); > > - if (thread->maps) { > - maps__put(thread->maps); > - thread->maps = NULL; > + if (thread__maps(thread)) { > + maps__put(thread__maps(thread)); > + thread__set_maps(thread, NULL); > } > - down_write(&thread->namespaces_lock); > + down_write(thread__namespaces_lock(thread)); > list_for_each_entry_safe(namespaces, tmp_namespaces, > - &thread->namespaces_list, list) { > + thread__namespaces_list(thread), list) { > list_del_init(&namespaces->list); > namespaces__free(namespaces); > } > - up_write(&thread->namespaces_lock); > + up_write(thread__namespaces_lock(thread)); > > - down_write(&thread->comm_lock); > - list_for_each_entry_safe(comm, tmp_comm, &thread->comm_list, list) { > + down_write(thread__comm_lock(thread)); > + list_for_each_entry_safe(comm, tmp_comm, thread__comm_list(thread), list) { > list_del_init(&comm->list); > comm__free(comm); > } > - up_write(&thread->comm_lock); > + up_write(thread__comm_lock(thread)); > > nsinfo__zput(thread->nsinfo); This one is not being wrapped... I think, with refcount check in mind, that we should just do: nsinfo__put(thread__nsinfo(thread)); thread__set_nsinfo(thread, NULL); Right? - Arnaldo > - srccode_state_free(&thread->srccode_state); > + srccode_state_free(thread__srccode_state(thread)); > > - exit_rwsem(&thread->namespaces_lock); > - exit_rwsem(&thread->comm_lock); > + exit_rwsem(thread__namespaces_lock(thread)); > + exit_rwsem(thread__comm_lock(thread)); > thread__free_stitch_list(thread); > free(thread); > } > @@ -116,31 +117,31 @@ void thread__delete(struct thread *thread) > struct thread *thread__get(struct thread *thread) > { > if (thread) > - refcount_inc(&thread->refcnt); > + refcount_inc(thread__refcnt(thread)); > return thread; > } > > void thread__put(struct thread *thread) > { > - if (thread && refcount_dec_and_test(&thread->refcnt)) > + if (thread && refcount_dec_and_test(thread__refcnt(thread))) > thread__delete(thread); > } > > -static struct namespaces *__thread__namespaces(const struct thread *thread) > +static struct namespaces *__thread__namespaces(struct thread *thread) > { > - if (list_empty(&thread->namespaces_list)) > + if (list_empty(thread__namespaces_list(thread))) > return NULL; > > - return list_first_entry(&thread->namespaces_list, struct namespaces, list); > + return list_first_entry(thread__namespaces_list(thread), struct namespaces, list); > } > > struct namespaces *thread__namespaces(struct thread *thread) > { > struct namespaces *ns; > > - down_read(&thread->namespaces_lock); > + down_read(thread__namespaces_lock(thread)); > ns = __thread__namespaces(thread); > - up_read(&thread->namespaces_lock); > + up_read(thread__namespaces_lock(thread)); > > return ns; > } > @@ -154,7 +155,7 @@ static int __thread__set_namespaces(struct thread *thread, u64 timestamp, > if (!new) > return -ENOMEM; > > - list_add(&new->list, &thread->namespaces_list); > + list_add(&new->list, thread__namespaces_list(thread)); > > if (timestamp && curr) { > /* > @@ -174,25 +175,25 @@ int thread__set_namespaces(struct thread *thread, u64 timestamp, > { > int ret; > > - down_write(&thread->namespaces_lock); > + down_write(thread__namespaces_lock(thread)); > ret = __thread__set_namespaces(thread, timestamp, event); > - up_write(&thread->namespaces_lock); > + up_write(thread__namespaces_lock(thread)); > return ret; > } > > -struct comm *thread__comm(const struct thread *thread) > +struct comm *thread__comm(struct thread *thread) > { > - if (list_empty(&thread->comm_list)) > + if (list_empty(thread__comm_list(thread))) > return NULL; > > - return list_first_entry(&thread->comm_list, struct comm, list); > + return list_first_entry(thread__comm_list(thread), struct comm, list); > } > > -struct comm *thread__exec_comm(const struct thread *thread) > +struct comm *thread__exec_comm(struct thread *thread) > { > struct comm *comm, *last = NULL, *second_last = NULL; > > - list_for_each_entry(comm, &thread->comm_list, list) { > + list_for_each_entry(comm, thread__comm_list(thread), list) { > if (comm->exec) > return comm; > second_last = last; > @@ -205,7 +206,7 @@ struct comm *thread__exec_comm(const struct thread *thread) > * thread, that is very probably wrong. Prefer a later comm to avoid > * that case. > */ > - if (second_last && !last->start && thread->pid_ == thread->tid) > + if (second_last && !last->start && thread__pid(thread) == thread__tid(thread)) > return second_last; > > return last; > @@ -217,7 +218,7 @@ static int ____thread__set_comm(struct thread *thread, const char *str, > struct comm *new, *curr = thread__comm(thread); > > /* Override the default :tid entry */ > - if (!thread->comm_set) { > + if (!thread__comm_set(thread)) { > int err = comm__override(curr, str, timestamp, exec); > if (err) > return err; > @@ -225,13 +226,13 @@ static int ____thread__set_comm(struct thread *thread, const char *str, > new = comm__new(str, timestamp, exec); > if (!new) > return -ENOMEM; > - list_add(&new->list, &thread->comm_list); > + list_add(&new->list, thread__comm_list(thread)); > > if (exec) > - unwind__flush_access(thread->maps); > + unwind__flush_access(thread__maps(thread)); > } > > - thread->comm_set = true; > + thread__set_comm_set(thread, true); > > return 0; > } > @@ -241,9 +242,9 @@ int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp, > { > int ret; > > - down_write(&thread->comm_lock); > + down_write(thread__comm_lock(thread)); > ret = ____thread__set_comm(thread, str, timestamp, exec); > - up_write(&thread->comm_lock); > + up_write(thread__comm_lock(thread)); > return ret; > } > > @@ -255,7 +256,7 @@ int thread__set_comm_from_proc(struct thread *thread) > int err = -1; > > if (!(snprintf(path, sizeof(path), "%d/task/%d/comm", > - thread->pid_, thread->tid) >= (int)sizeof(path)) && > + thread__pid(thread), thread__tid(thread)) >= (int)sizeof(path)) && > procfs__read_str(path, &comm, &sz) == 0) { > comm[sz - 1] = '\0'; > err = thread__set_comm(thread, comm, 0); > @@ -264,7 +265,7 @@ int thread__set_comm_from_proc(struct thread *thread) > return err; > } > > -static const char *__thread__comm_str(const struct thread *thread) > +static const char *__thread__comm_str(struct thread *thread) > { > const struct comm *comm = thread__comm(thread); > > @@ -278,9 +279,9 @@ const char *thread__comm_str(struct thread *thread) > { > const char *str; > > - down_read(&thread->comm_lock); > + down_read(thread__comm_lock(thread)); > str = __thread__comm_str(thread); > - up_read(&thread->comm_lock); > + up_read(thread__comm_lock(thread)); > > return str; > } > @@ -289,23 +290,23 @@ static int __thread__comm_len(struct thread *thread, const char *comm) > { > if (!comm) > return 0; > - thread->comm_len = strlen(comm); > + thread__set_comm_len(thread, strlen(comm)); > > - return thread->comm_len; > + return thread__var_comm_len(thread); > } > > /* CHECKME: it should probably better return the max comm len from its comm list */ > int thread__comm_len(struct thread *thread) > { > - int comm_len = thread->comm_len; > + int comm_len = thread__var_comm_len(thread); > > if (!comm_len) { > const char *comm; > > - down_read(&thread->comm_lock); > + down_read(thread__comm_lock(thread)); > comm = __thread__comm_str(thread); > comm_len = __thread__comm_len(thread, comm); > - up_read(&thread->comm_lock); > + up_read(thread__comm_lock(thread)); > } > > return comm_len; > @@ -313,33 +314,33 @@ int thread__comm_len(struct thread *thread) > > size_t thread__fprintf(struct thread *thread, FILE *fp) > { > - return fprintf(fp, "Thread %d %s\n", thread->tid, thread__comm_str(thread)) + > - maps__fprintf(thread->maps, fp); > + return fprintf(fp, "Thread %d %s\n", thread__tid(thread), thread__comm_str(thread)) + > + maps__fprintf(thread__maps(thread), fp); > } > > int thread__insert_map(struct thread *thread, struct map *map) > { > int ret; > > - ret = unwind__prepare_access(thread->maps, map, NULL); > + ret = unwind__prepare_access(thread__maps(thread), map, NULL); > if (ret) > return ret; > > - maps__fixup_overlappings(thread->maps, map, stderr); > - return maps__insert(thread->maps, map); > + maps__fixup_overlappings(thread__maps(thread), map, stderr); > + return maps__insert(thread__maps(thread), map); > } > > static int __thread__prepare_access(struct thread *thread) > { > bool initialized = false; > int err = 0; > - struct maps *maps = thread->maps; > + struct maps *maps = thread__maps(thread); > struct map_rb_node *rb_node; > > down_read(maps__lock(maps)); > > maps__for_each_entry(maps, rb_node) { > - err = unwind__prepare_access(thread->maps, rb_node->map, &initialized); > + err = unwind__prepare_access(thread__maps(thread), rb_node->map, &initialized); > if (err || initialized) > break; > } > @@ -362,21 +363,22 @@ static int thread__prepare_access(struct thread *thread) > static int thread__clone_maps(struct thread *thread, struct thread *parent, bool do_maps_clone) > { > /* This is new thread, we share map groups for process. */ > - if (thread->pid_ == parent->pid_) > + if (thread__pid(thread) == thread__pid(parent)) > return thread__prepare_access(thread); > > - if (thread->maps == parent->maps) { > + if (thread__maps(thread) == thread__maps(parent)) { > pr_debug("broken map groups on thread %d/%d parent %d/%d\n", > - thread->pid_, thread->tid, parent->pid_, parent->tid); > + thread__pid(thread), thread__tid(thread), > + thread__pid(parent), thread__tid(parent)); > return 0; > } > /* But this one is new process, copy maps. */ > - return do_maps_clone ? maps__clone(thread, parent->maps) : 0; > + return do_maps_clone ? maps__clone(thread, thread__maps(parent)) : 0; > } > > int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bool do_maps_clone) > { > - if (parent->comm_set) { > + if (thread__comm_set(parent)) { > const char *comm = thread__comm_str(parent); > int err; > if (!comm) > @@ -386,7 +388,7 @@ int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bo > return err; > } > > - thread->ppid = parent->tid; > + thread__set_ppid(thread, thread__tid(parent)); > return thread__clone_maps(thread, parent, do_maps_clone); > } > > @@ -410,13 +412,13 @@ void thread__find_cpumode_addr_location(struct thread *thread, u64 addr, > > struct thread *thread__main_thread(struct machine *machine, struct thread *thread) > { > - if (thread->pid_ == thread->tid) > + if (thread__pid(thread) == thread__tid(thread)) > return thread__get(thread); > > - if (thread->pid_ == -1) > + if (thread__pid(thread) == -1) > return NULL; > > - return machine__find_thread(machine, thread->pid_, thread->pid_); > + return machine__find_thread(machine, thread__pid(thread), thread__pid(thread)); > } > > int thread__memcpy(struct thread *thread, struct machine *machine, > @@ -447,7 +449,7 @@ int thread__memcpy(struct thread *thread, struct machine *machine, > > void thread__free_stitch_list(struct thread *thread) > { > - struct lbr_stitch *lbr_stitch = thread->lbr_stitch; > + struct lbr_stitch *lbr_stitch = thread__lbr_stitch(thread); > struct stitch_list *pos, *tmp; > > if (!lbr_stitch) > @@ -464,5 +466,6 @@ void thread__free_stitch_list(struct thread *thread) > } > > zfree(&lbr_stitch->prev_lbr_cursor); > - zfree(&thread->lbr_stitch); > + free(thread__lbr_stitch(thread)); > + thread__set_lbr_stitch(thread, NULL); > } > diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h > index 3b3f9fb5a916..b103992c3831 100644 > --- a/tools/perf/util/thread.h > +++ b/tools/perf/util/thread.h > @@ -96,8 +96,8 @@ static inline int thread__set_comm(struct thread *thread, const char *comm, > 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); > +struct comm *thread__comm(struct thread *thread); > +struct comm *thread__exec_comm(struct thread *thread); > const char *thread__comm_str(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); > @@ -121,6 +121,126 @@ void thread__find_cpumode_addr_location(struct thread *thread, u64 addr, > int thread__memcpy(struct thread *thread, struct machine *machine, > void *buf, u64 ip, int len, bool *is64bit); > > +static inline struct maps *thread__maps(struct thread *thread) > +{ > + return thread->maps; > +} > + > +static inline void thread__set_maps(struct thread *thread, struct maps *maps) > +{ > + thread->maps = maps; > +} > + > +static inline pid_t thread__pid(const struct thread *thread) > +{ > + return thread->pid_; > +} > + > +static inline void thread__set_pid(struct thread *thread, pid_t pid_) > +{ > + thread->pid_ = pid_; > +} > + > +static inline pid_t thread__tid(const struct thread *thread) > +{ > + return thread->tid; > +} > + > +static inline void thread__set_tid(struct thread *thread, pid_t tid) > +{ > + thread->tid = tid; > +} > + > +static inline pid_t thread__ppid(const struct thread *thread) > +{ > + return thread->ppid; > +} > + > +static inline void thread__set_ppid(struct thread *thread, pid_t ppid) > +{ > + thread->ppid = ppid; > +} > + > +static inline int thread__cpu(const struct thread *thread) > +{ > + return thread->cpu; > +} > + > +static inline void thread__set_cpu(struct thread *thread, int cpu) > +{ > + thread->cpu = cpu; > +} > + > +static inline int thread__guest_cpu(const struct thread *thread) > +{ > + return thread->guest_cpu; > +} > + > +static inline void thread__set_guest_cpu(struct thread *thread, int guest_cpu) > +{ > + thread->guest_cpu = guest_cpu; > +} > + > +static inline refcount_t *thread__refcnt(struct thread *thread) > +{ > + return &thread->refcnt; > +} > + > +static inline bool thread__comm_set(const struct thread *thread) > +{ > + return thread->comm_set; > +} > + > +static inline void thread__set_comm_set(struct thread *thread, bool set) > +{ > + thread->comm_set = set; > +} > + > +static inline int thread__var_comm_len(const struct thread *thread) > +{ > + return thread->comm_len; > +} > + > +static inline void thread__set_comm_len(struct thread *thread, int len) > +{ > + thread->comm_len = len; > +} > + > +static inline struct list_head *thread__namespaces_list(struct thread *thread) > +{ > + return &thread->namespaces_list; > +} > + > +static inline int thread__namespaces_list_empty(const struct thread *thread) > +{ > + return list_empty(&thread->namespaces_list); > +} > + > +static inline struct rw_semaphore *thread__namespaces_lock(struct thread *thread) > +{ > + return &thread->namespaces_lock; > +} > + > +static inline struct list_head *thread__comm_list(struct thread *thread) > +{ > + return &thread->comm_list; > +} > + > +static inline struct rw_semaphore *thread__comm_lock(struct thread *thread) > +{ > + return &thread->comm_lock; > +} > + > +static inline u64 thread__db_id(const struct thread *thread) > +{ > + return thread->db_id; > +} > + > +static inline void thread__set_db_id(struct thread *thread, u64 db_id) > +{ > + thread->db_id = db_id; > +} > + > static inline void *thread__priv(struct thread *thread) > { > return thread->priv; > @@ -131,6 +251,66 @@ static inline void thread__set_priv(struct thread *thread, void *p) > thread->priv = p; > } > > +static inline struct thread_stack *thread__ts(struct thread *thread) > +{ > + return thread->ts; > +} > + > +static inline void thread__set_ts(struct thread *thread, struct thread_stack *ts) > +{ > + thread->ts = ts; > +} > + > +static inline struct nsinfo *thread__nsinfo(struct thread *thread) > +{ > + return thread->nsinfo; > +} > + > +static inline struct srccode_state *thread__srccode_state(struct thread *thread) > +{ > + return &thread->srccode_state; > +} > + > +static inline bool thread__filter(const struct thread *thread) > +{ > + return thread->filter; > +} > + > +static inline void thread__set_filter(struct thread *thread, bool filter) > +{ > + thread->filter = filter; > +} > + > +static inline int thread__filter_entry_depth(const struct thread *thread) > +{ > + return thread->filter_entry_depth; > +} > + > +static inline void thread__set_filter_entry_depth(struct thread *thread, int depth) > +{ > + thread->filter_entry_depth = depth; > +} > + > +static inline bool thread__lbr_stitch_enable(const struct thread *thread) > +{ > + return thread->lbr_stitch_enable; > +} > + > +static inline void thread__set_lbr_stitch_enable(struct thread *thread, bool en) > +{ > + thread->lbr_stitch_enable = en; > +} > + > +static inline struct lbr_stitch *thread__lbr_stitch(struct thread *thread) > +{ > + return thread->lbr_stitch; > +} > + > +static inline void thread__set_lbr_stitch(struct thread *thread, struct lbr_stitch *lbrs) > +{ > + thread->lbr_stitch = lbrs; > +} > + > static inline bool thread__is_filtered(struct thread *thread) > { > if (symbol_conf.comm_list && > @@ -139,12 +319,12 @@ static inline bool thread__is_filtered(struct thread *thread) > } > > if (symbol_conf.pid_list && > - !intlist__has_entry(symbol_conf.pid_list, thread->pid_)) { > + !intlist__has_entry(symbol_conf.pid_list, thread__pid(thread))) { > return true; > } > > if (symbol_conf.tid_list && > - !intlist__has_entry(symbol_conf.tid_list, thread->tid)) { > + !intlist__has_entry(symbol_conf.tid_list, thread__tid(thread))) { > return true; > } > > diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c > index bdccfc511b7e..3723b5e31b2a 100644 > --- a/tools/perf/util/unwind-libdw.c > +++ b/tools/perf/util/unwind-libdw.c > @@ -230,7 +230,7 @@ int unwind__get_entries(unwind_entry_cb_t cb, void *arg, > struct unwind_info *ui, ui_buf = { > .sample = data, > .thread = thread, > - .machine = RC_CHK_ACCESS(thread->maps)->machine, > + .machine = RC_CHK_ACCESS(thread__maps(thread))->machine, > .cb = cb, > .arg = arg, > .max_stack = max_stack, > @@ -260,11 +260,11 @@ int unwind__get_entries(unwind_entry_cb_t cb, void *arg, > if (err) > goto out; > > - err = !dwfl_attach_state(ui->dwfl, EM_NONE, thread->tid, &callbacks, ui); > + err = !dwfl_attach_state(ui->dwfl, EM_NONE, thread__tid(thread), &callbacks, ui); > if (err) > goto out; > > - err = dwfl_getthread_frames(ui->dwfl, thread->tid, frame_callback, ui); > + err = dwfl_getthread_frames(ui->dwfl, thread__tid(thread), frame_callback, ui); > > if (err && ui->max_stack != max_stack) > err = 0; > diff --git a/tools/perf/util/unwind-libunwind-local.c b/tools/perf/util/unwind-libunwind-local.c > index 83dd79dcd597..11f3fc95aa11 100644 > --- a/tools/perf/util/unwind-libunwind-local.c > +++ b/tools/perf/util/unwind-libunwind-local.c > @@ -325,7 +325,7 @@ static int read_unwind_spec_eh_frame(struct dso *dso, struct unwind_info *ui, > return -EINVAL; > } > > - maps__for_each_entry(ui->thread->maps, map_node) { > + maps__for_each_entry(thread__maps(ui->thread), map_node) { > struct map *map = map_node->map; > u64 start = map__start(map); > > @@ -719,7 +719,7 @@ static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb, > */ > if (max_stack - 1 > 0) { > WARN_ONCE(!ui->thread, "WARNING: ui->thread is NULL"); > - addr_space = maps__addr_space(ui->thread->maps); > + addr_space = maps__addr_space(thread__maps(ui->thread)); > > if (addr_space == NULL) > return -1; > @@ -769,7 +769,7 @@ static int _unwind__get_entries(unwind_entry_cb_t cb, void *arg, > struct unwind_info ui = { > .sample = data, > .thread = thread, > - .machine = maps__machine(thread->maps), > + .machine = maps__machine(thread__maps(thread)), > .best_effort = best_effort > }; > > diff --git a/tools/perf/util/unwind-libunwind.c b/tools/perf/util/unwind-libunwind.c > index 375d23d9a590..76cd63de80a8 100644 > --- a/tools/perf/util/unwind-libunwind.c > +++ b/tools/perf/util/unwind-libunwind.c > @@ -89,7 +89,7 @@ int unwind__get_entries(unwind_entry_cb_t cb, void *arg, > struct perf_sample *data, int max_stack, > bool best_effort) > { > - const struct unwind_libunwind_ops *ops = maps__unwind_libunwind_ops(thread->maps); > + const struct unwind_libunwind_ops *ops = maps__unwind_libunwind_ops(thread__maps(thread)); > > if (ops) > return ops->get_entries(cb, arg, thread, data, max_stack, best_effort); > diff --git a/tools/perf/util/vdso.c b/tools/perf/util/vdso.c > index ec777ee11493..ae3eee69b659 100644 > --- a/tools/perf/util/vdso.c > +++ b/tools/perf/util/vdso.c > @@ -146,7 +146,7 @@ static enum dso_type machine__thread_dso_type(struct machine *machine, > enum dso_type dso_type = DSO__TYPE_UNKNOWN; > struct map_rb_node *rb_node; > > - maps__for_each_entry(thread->maps, rb_node) { > + maps__for_each_entry(thread__maps(thread), rb_node) { > struct dso *dso = map__dso(rb_node->map); > > if (!dso || dso->long_name[0] != '/') > -- > 2.41.0.162.gfafddb0af9-goog > -- - Arnaldo