perf tools: Stop using 'self' in some more places

As suggested by tglx, 'self' should be replaced by something that is
more useful.

Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-fmblhc6tbb99tk1q8vowtsbj@git.kernel.orgSigned-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 4ac2f1c1
......@@ -118,11 +118,11 @@ static int hist_entry__tty_annotate(struct hist_entry *he,
ann->print_line, ann->full_paths, 0, 0);
}
static void hists__find_annotations(struct hists *self,
static void hists__find_annotations(struct hists *hists,
struct perf_evsel *evsel,
struct perf_annotate *ann)
{
struct rb_node *nd = rb_first(&self->entries), *next;
struct rb_node *nd = rb_first(&hists->entries), *next;
int key = K_RIGHT;
while (nd) {
......
......@@ -303,12 +303,11 @@ static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair,
return -1;
}
static int hists__add_entry(struct hists *self,
static int hists__add_entry(struct hists *hists,
struct addr_location *al, u64 period,
u64 weight, u64 transaction)
{
if (__hists__add_entry(self, al, NULL, period, weight, transaction)
!= NULL)
if (__hists__add_entry(hists, al, NULL, period, weight, transaction) != NULL)
return 0;
return -ENOMEM;
}
......
......@@ -162,38 +162,38 @@ static int perf_event__repipe_tracing_data(struct perf_tool *tool,
return err;
}
static int dso__read_build_id(struct dso *self)
static int dso__read_build_id(struct dso *dso)
{
if (self->has_build_id)
if (dso->has_build_id)
return 0;
if (filename__read_build_id(self->long_name, self->build_id,
sizeof(self->build_id)) > 0) {
self->has_build_id = true;
if (filename__read_build_id(dso->long_name, dso->build_id,
sizeof(dso->build_id)) > 0) {
dso->has_build_id = true;
return 0;
}
return -1;
}
static int dso__inject_build_id(struct dso *self, struct perf_tool *tool,
static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool,
struct machine *machine)
{
u16 misc = PERF_RECORD_MISC_USER;
int err;
if (dso__read_build_id(self) < 0) {
pr_debug("no build_id found for %s\n", self->long_name);
if (dso__read_build_id(dso) < 0) {
pr_debug("no build_id found for %s\n", dso->long_name);
return -1;
}
if (self->kernel)
if (dso->kernel)
misc = PERF_RECORD_MISC_KERNEL;
err = perf_event__synthesize_build_id(tool, self, misc, perf_event__repipe,
err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
machine);
if (err) {
pr_err("Can't synthesize build_id event for %s\n", self->long_name);
pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
return -1;
}
......
......@@ -373,9 +373,9 @@ static int process_read_event(struct perf_tool *tool,
/* For pipe mode, sample_type is not currently set */
static int perf_report__setup_sample_type(struct perf_report *rep)
{
struct perf_session *self = rep->session;
u64 sample_type = perf_evlist__combined_sample_type(self->evlist);
bool is_pipe = perf_data_file__is_pipe(self->file);
struct perf_session *session = rep->session;
u64 sample_type = perf_evlist__combined_sample_type(session->evlist);
bool is_pipe = perf_data_file__is_pipe(session->file);
if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
if (sort__has_parent) {
......@@ -417,14 +417,14 @@ static void sig_handler(int sig __maybe_unused)
}
static size_t hists__fprintf_nr_sample_events(struct perf_report *rep,
struct hists *self,
struct hists *hists,
const char *evname, FILE *fp)
{
size_t ret;
char unit;
unsigned long nr_samples = self->stats.nr_events[PERF_RECORD_SAMPLE];
u64 nr_events = self->stats.total_period;
struct perf_evsel *evsel = hists_to_evsel(self);
unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
u64 nr_events = hists->stats.total_period;
struct perf_evsel *evsel = hists_to_evsel(hists);
char buf[512];
size_t size = sizeof(buf);
......
......@@ -89,14 +89,14 @@ int build_id__sprintf(const u8 *build_id, int len, char *bf)
return raw - build_id;
}
char *dso__build_id_filename(struct dso *self, char *bf, size_t size)
char *dso__build_id_filename(struct dso *dso, char *bf, size_t size)
{
char build_id_hex[BUILD_ID_SIZE * 2 + 1];
if (!self->has_build_id)
if (!dso->has_build_id)
return NULL;
build_id__sprintf(self->build_id, sizeof(self->build_id), build_id_hex);
build_id__sprintf(dso->build_id, sizeof(dso->build_id), build_id_hex);
if (bf == NULL) {
if (asprintf(&bf, "%s/.build-id/%.2s/%s", buildid_dir,
build_id_hex, build_id_hex + 2) < 0)
......
......@@ -406,7 +406,7 @@ static struct hist_entry *add_hist_entry(struct hists *hists,
return he;
}
struct hist_entry *__hists__add_mem_entry(struct hists *self,
struct hist_entry *__hists__add_mem_entry(struct hists *hists,
struct addr_location *al,
struct symbol *sym_parent,
struct mem_info *mi,
......@@ -429,14 +429,14 @@ struct hist_entry *__hists__add_mem_entry(struct hists *self,
.level = al->level,
.parent = sym_parent,
.filtered = symbol__parent_filter(sym_parent),
.hists = self,
.hists = hists,
.mem_info = mi,
.branch_info = NULL,
};
return add_hist_entry(self, &entry, al, period, weight);
return add_hist_entry(hists, &entry, al, period, weight);
}
struct hist_entry *__hists__add_branch_entry(struct hists *self,
struct hist_entry *__hists__add_branch_entry(struct hists *hists,
struct addr_location *al,
struct symbol *sym_parent,
struct branch_info *bi,
......@@ -460,14 +460,14 @@ struct hist_entry *__hists__add_branch_entry(struct hists *self,
.parent = sym_parent,
.filtered = symbol__parent_filter(sym_parent),
.branch_info = bi,
.hists = self,
.hists = hists,
.mem_info = NULL,
};
return add_hist_entry(self, &entry, al, period, weight);
return add_hist_entry(hists, &entry, al, period, weight);
}
struct hist_entry *__hists__add_entry(struct hists *self,
struct hist_entry *__hists__add_entry(struct hists *hists,
struct addr_location *al,
struct symbol *sym_parent, u64 period,
u64 weight, u64 transaction)
......@@ -488,13 +488,13 @@ struct hist_entry *__hists__add_entry(struct hists *self,
},
.parent = sym_parent,
.filtered = symbol__parent_filter(sym_parent),
.hists = self,
.hists = hists,
.branch_info = NULL,
.mem_info = NULL,
.transaction = transaction,
};
return add_hist_entry(self, &entry, al, period, weight);
return add_hist_entry(hists, &entry, al, period, weight);
}
int64_t
......
This diff is collapsed.
......@@ -10,22 +10,22 @@ static const char *OP_not = "!"; /* Logical NOT */
#define is_operator(c) ((c) == '|' || (c) == '&' || (c) == '!')
#define is_separator(c) (is_operator(c) || (c) == '(' || (c) == ')')
static void strfilter_node__delete(struct strfilter_node *self)
static void strfilter_node__delete(struct strfilter_node *node)
{
if (self) {
if (self->p && !is_operator(*self->p))
free((char *)self->p);
strfilter_node__delete(self->l);
strfilter_node__delete(self->r);
free(self);
if (node) {
if (node->p && !is_operator(*node->p))
free((char *)node->p);
strfilter_node__delete(node->l);
strfilter_node__delete(node->r);
free(node);
}
}
void strfilter__delete(struct strfilter *self)
void strfilter__delete(struct strfilter *filter)
{
if (self) {
strfilter_node__delete(self->root);
free(self);
if (filter) {
strfilter_node__delete(filter->root);
free(filter);
}
}
......@@ -170,30 +170,30 @@ struct strfilter *strfilter__new(const char *rules, const char **err)
return ret;
}
static bool strfilter_node__compare(struct strfilter_node *self,
static bool strfilter_node__compare(struct strfilter_node *node,
const char *str)
{
if (!self || !self->p)
if (!node || !node->p)
return false;
switch (*self->p) {
switch (*node->p) {
case '|': /* OR */
return strfilter_node__compare(self->l, str) ||
strfilter_node__compare(self->r, str);
return strfilter_node__compare(node->l, str) ||
strfilter_node__compare(node->r, str);
case '&': /* AND */
return strfilter_node__compare(self->l, str) &&
strfilter_node__compare(self->r, str);
return strfilter_node__compare(node->l, str) &&
strfilter_node__compare(node->r, str);
case '!': /* NOT */
return !strfilter_node__compare(self->r, str);
return !strfilter_node__compare(node->r, str);
default:
return strglobmatch(str, self->p);
return strglobmatch(str, node->p);
}
}
/* Return true if STR matches the filter rules */
bool strfilter__compare(struct strfilter *self, const char *str)
bool strfilter__compare(struct strfilter *node, const char *str)
{
if (!self)
if (!node)
return false;
return strfilter_node__compare(self->root, str);
return strfilter_node__compare(node->root, str);
}
......@@ -9,51 +9,51 @@
struct thread *thread__new(pid_t pid, pid_t tid)
{
struct thread *self = zalloc(sizeof(*self));
struct thread *thread = zalloc(sizeof(*thread));
if (self != NULL) {
map_groups__init(&self->mg);
self->pid_ = pid;
self->tid = tid;
self->ppid = -1;
self->comm = malloc(32);
if (self->comm)
snprintf(self->comm, 32, ":%d", self->tid);
if (thread != NULL) {
map_groups__init(&thread->mg);
thread->pid_ = pid;
thread->tid = tid;
thread->ppid = -1;
thread->comm = malloc(32);
if (thread->comm)
snprintf(thread->comm, 32, ":%d", thread->tid);
}
return self;
return thread;
}
void thread__delete(struct thread *self)
void thread__delete(struct thread *thread)
{
map_groups__exit(&self->mg);
free(self->comm);
free(self);
map_groups__exit(&thread->mg);
free(thread->comm);
free(thread);
}
int thread__set_comm(struct thread *self, const char *comm)
int thread__set_comm(struct thread *thread, const char *comm)
{
int err;
if (self->comm)
free(self->comm);
self->comm = strdup(comm);
err = self->comm == NULL ? -ENOMEM : 0;
if (thread->comm)
free(thread->comm);
thread->comm = strdup(comm);
err = thread->comm == NULL ? -ENOMEM : 0;
if (!err) {
self->comm_set = true;
thread->comm_set = true;
}
return err;
}
int thread__comm_len(struct thread *self)
int thread__comm_len(struct thread *thread)
{
if (!self->comm_len) {
if (!self->comm)
if (!thread->comm_len) {
if (!thread->comm)
return 0;
self->comm_len = strlen(self->comm);
thread->comm_len = strlen(thread->comm);
}
return self->comm_len;
return thread->comm_len;
}
size_t thread__fprintf(struct thread *thread, FILE *fp)
......@@ -62,30 +62,30 @@ size_t thread__fprintf(struct thread *thread, FILE *fp)
map_groups__fprintf(&thread->mg, verbose, fp);
}
void thread__insert_map(struct thread *self, struct map *map)
void thread__insert_map(struct thread *thread, struct map *map)
{
map_groups__fixup_overlappings(&self->mg, map, verbose, stderr);
map_groups__insert(&self->mg, map);
map_groups__fixup_overlappings(&thread->mg, map, verbose, stderr);
map_groups__insert(&thread->mg, map);
}
int thread__fork(struct thread *self, struct thread *parent)
int thread__fork(struct thread *thread, struct thread *parent)
{
int i;
if (parent->comm_set) {
if (self->comm)
free(self->comm);
self->comm = strdup(parent->comm);
if (!self->comm)
if (thread->comm)
free(thread->comm);
thread->comm = strdup(parent->comm);
if (!thread->comm)
return -ENOMEM;
self->comm_set = true;
thread->comm_set = true;
}
for (i = 0; i < MAP__NR_TYPES; ++i)
if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
if (map_groups__clone(&thread->mg, &parent->mg, i) < 0)
return -ENOMEM;
self->ppid = parent->tid;
thread->ppid = parent->tid;
return 0;
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment