perf tools: Use dedicated non-atomic clear/set bit helpers

sean-jc · bonzini · commit 75d7ba32f982 · 2022-12-02T13:22:33.000-05:00
Use the dedicated non-atomic helpers for {clear,set}_bit() and their
test variants, i.e. the double-underscore versions.  Depsite being
defined in atomic.h, and despite the kernel versions being atomic in the
kernel, tools' {clear,set}_bit() helpers aren't actually atomic.  Move
to the double-underscore versions so that the versions that are expected
to be atomic (for kernel developers) can be made atomic without affecting
users that don't want atomic operations.

No functional change intended.

Signed-off-by: Sean Christopherson &lt;seanjc@google.com&gt;
Acked-by: Namhyung Kim &lt;namhyung@kernel.org&gt;
Message-Id: &lt;20221119013450.2643007-6-seanjc@google.com&gt;
Signed-off-by: Paolo Bonzini &lt;pbonzini@redhat.com&gt;
diff --git a/tools/perf/bench/find-bit-bench.c b/tools/perf/bench/find-bit-bench.c
@@ -70,7 +70,7 @@ static int do_for_each_set_bit(unsigned int num_bits)
 		bitmap_zero(to_test, num_bits);
 		skip = num_bits / set_bits;
 		for (i = 0; i < num_bits; i += skip)
-			set_bit(i, to_test);
+			__set_bit(i, to_test);
 
 		for (i = 0; i < outer_iterations; i++) {
 			old = accumulator;
diff --git a/tools/perf/builtin-c2c.c b/tools/perf/builtin-c2c.c
@@ -230,7 +230,7 @@ static void c2c_he__set_cpu(struct c2c_hist_entry *c2c_he,
 		      "WARNING: no sample cpu value"))
 		return;
 
-	set_bit(sample->cpu, c2c_he->cpuset);
+	__set_bit(sample->cpu, c2c_he->cpuset);
 }
 
 static void c2c_he__set_node(struct c2c_hist_entry *c2c_he,
@@ -247,7 +247,7 @@ static void c2c_he__set_node(struct c2c_hist_entry *c2c_he,
 	if (WARN_ONCE(node < 0, "WARNING: failed to find node\n"))
 		return;
 
-	set_bit(node, c2c_he->nodeset);
+	__set_bit(node, c2c_he->nodeset);
 
 	if (c2c_he->paddr != sample->phys_addr) {
 		c2c_he->paddr_cnt++;
@@ -2318,7 +2318,7 @@ static int setup_nodes(struct perf_session *session)
 			continue;
 
 		perf_cpu_map__for_each_cpu(cpu, idx, map) {
-			set_bit(cpu.cpu, set);
+			__set_bit(cpu.cpu, set);
 
 			if (WARN_ONCE(cpu2node[cpu.cpu] != -1, "node/cpu topology bug"))
 				return -EINVAL;
diff --git a/tools/perf/builtin-kwork.c b/tools/perf/builtin-kwork.c
@@ -216,7 +216,7 @@ static struct kwork_atom *atom_new(struct perf_kwork *kwork,
 	list_add_tail(&page->list, &kwork->atom_page_list);
 
 found_atom:
-	set_bit(i, page->bitmap);
+	__set_bit(i, page->bitmap);
 	atom->time = sample->time;
 	atom->prev = NULL;
 	atom->page_addr = page;
@@ -229,8 +229,8 @@ static void atom_free(struct kwork_atom *atom)
 	if (atom->prev != NULL)
 		atom_free(atom->prev);
 
-	clear_bit(atom->bit_inpage,
-		  ((struct kwork_atom_page *)atom->page_addr)->bitmap);
+	__clear_bit(atom->bit_inpage,
+		    ((struct kwork_atom_page *)atom->page_addr)->bitmap);
 }
 
 static void atom_del(struct kwork_atom *atom)
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
@@ -3555,7 +3555,7 @@ static int record__mmap_cpu_mask_init(struct mmap_cpu_mask *mask, struct perf_cp
 		/* Return ENODEV is input cpu is greater than max cpu */
 		if ((unsigned long)cpu.cpu > mask->nbits)
 			return -ENODEV;
-		set_bit(cpu.cpu, mask->bits);
+		__set_bit(cpu.cpu, mask->bits);
 	}
 
 	return 0;
@@ -3627,8 +3627,8 @@ static int record__init_thread_cpu_masks(struct record *rec, struct perf_cpu_map
 	pr_debug("nr_threads: %d\n", rec->nr_threads);
 
 	for (t = 0; t < rec->nr_threads; t++) {
-		set_bit(perf_cpu_map__cpu(cpus, t).cpu, rec->thread_masks[t].maps.bits);
-		set_bit(perf_cpu_map__cpu(cpus, t).cpu, rec->thread_masks[t].affinity.bits);
+		__set_bit(perf_cpu_map__cpu(cpus, t).cpu, rec->thread_masks[t].maps.bits);
+		__set_bit(perf_cpu_map__cpu(cpus, t).cpu, rec->thread_masks[t].affinity.bits);
 		if (verbose) {
 			pr_debug("thread_masks[%d]: ", t);
 			mmap_cpu_mask__scnprintf(&rec->thread_masks[t].maps, "maps");
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
@@ -1573,7 +1573,7 @@ static int map_switch_event(struct perf_sched *sched, struct evsel *evsel,
 
 	if (sched->map.comp) {
 		cpus_nr = bitmap_weight(sched->map.comp_cpus_mask, MAX_CPUS);
-		if (!test_and_set_bit(this_cpu.cpu, sched->map.comp_cpus_mask)) {
+		if (!__test_and_set_bit(this_cpu.cpu, sched->map.comp_cpus_mask)) {
 			sched->map.comp_cpus[cpus_nr++] = this_cpu;
 			new_cpu = true;
 		}
diff --git a/tools/perf/tests/bitmap.c b/tools/perf/tests/bitmap.c
@@ -18,7 +18,7 @@ static unsigned long *get_bitmap(const char *str, int nbits)
 
 	if (map && bm) {
 		for (i = 0; i < perf_cpu_map__nr(map); i++)
-			set_bit(perf_cpu_map__cpu(map, i).cpu, bm);
+			__set_bit(perf_cpu_map__cpu(map, i).cpu, bm);
 	}
 
 	if (map)
diff --git a/tools/perf/tests/mem2node.c b/tools/perf/tests/mem2node.c
@@ -33,7 +33,7 @@ static unsigned long *get_bitmap(const char *str, int nbits)
 		int i;
 
 		perf_cpu_map__for_each_cpu(cpu, i, map)
-			set_bit(cpu.cpu, bm);
+			__set_bit(cpu.cpu, bm);
 	}
 
 	if (map)
diff --git a/tools/perf/util/affinity.c b/tools/perf/util/affinity.c
@@ -58,14 +58,14 @@ void affinity__set(struct affinity *a, int cpu)
 		return;
 
 	a->changed = true;
-	set_bit(cpu, a->sched_cpus);
+	__set_bit(cpu, a->sched_cpus);
 	/*
 	 * We ignore errors because affinity is just an optimization.
 	 * This could happen for example with isolated CPUs or cpusets.
 	 * In this case the IPIs inside the kernel's perf API still work.
 	 */
 	sched_setaffinity(0, cpu_set_size, (cpu_set_t *)a->sched_cpus);
-	clear_bit(cpu, a->sched_cpus);
+	__clear_bit(cpu, a->sched_cpus);
 }
 
 static void __affinity__cleanup(struct affinity *a)
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
@@ -79,12 +79,12 @@ struct perf_file_attr {
 
 void perf_header__set_feat(struct perf_header *header, int feat)
 {
-	set_bit(feat, header->adds_features);
+	__set_bit(feat, header->adds_features);
 }
 
 void perf_header__clear_feat(struct perf_header *header, int feat)
 {
-	clear_bit(feat, header->adds_features);
+	__clear_bit(feat, header->adds_features);
 }
 
 bool perf_header__has_feat(const struct perf_header *header, int feat)
@@ -1358,7 +1358,7 @@ static int memory_node__read(struct memory_node *n, unsigned long idx)
 	rewinddir(dir);
 
 	for_each_memory(phys, dir) {
-		set_bit(phys, n->set);
+		__set_bit(phys, n->set);
 	}
 
 	closedir(dir);
@@ -3952,7 +3952,7 @@ int perf_file_header__read(struct perf_file_header *header,
 
 		if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
 			bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
-			set_bit(HEADER_BUILD_ID, header->adds_features);
+			__set_bit(HEADER_BUILD_ID, header->adds_features);
 		}
 	}
 
diff --git a/tools/perf/util/mmap.c b/tools/perf/util/mmap.c
@@ -111,7 +111,7 @@ static int perf_mmap__aio_bind(struct mmap *map, int idx, struct perf_cpu cpu, i
 			pr_err("Failed to allocate node mask for mbind: error %m\n");
 			return -1;
 		}
-		set_bit(node_index, node_mask);
+		__set_bit(node_index, node_mask);
 		if (mbind(data, mmap_len, MPOL_BIND, node_mask, node_index + 1 + 1, 0)) {
 			pr_err("Failed to bind [%p-%p] AIO buffer to node %lu: error %m\n",
 				data, data + mmap_len, node_index);
@@ -256,7 +256,7 @@ static void build_node_mask(int node, struct mmap_cpu_mask *mask)
 	for (idx = 0; idx < nr_cpus; idx++) {
 		cpu = perf_cpu_map__cpu(cpu_map, idx); /* map c index to online cpu index */
 		if (cpu__get_node(cpu) == node)
-			set_bit(cpu.cpu, mask->bits);
+			__set_bit(cpu.cpu, mask->bits);
 	}
 }
 
@@ -270,7 +270,7 @@ static int perf_mmap__setup_affinity_mask(struct mmap *map, struct mmap_params *
 	if (mp->affinity == PERF_AFFINITY_NODE && cpu__max_node() > 1)
 		build_node_mask(cpu__get_node(map->core.cpu), &map->affinity_mask);
 	else if (mp->affinity == PERF_AFFINITY_CPU)
-		set_bit(map->core.cpu.cpu, map->affinity_mask.bits);
+		__set_bit(map->core.cpu.cpu, map->affinity_mask.bits);
 
 	return 0;
 }
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
@@ -1513,7 +1513,7 @@ void perf_pmu__set_format(unsigned long *bits, long from, long to)
 
 	memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
 	for (b = from; b <= to; b++)
-		set_bit(b, bits);
+		__set_bit(b, bits);
 }
 
 void perf_pmu__del_formats(struct list_head *formats)
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -365,7 +365,7 @@ static void perl_process_tracepoint(struct perf_sample *sample,
 
 	sprintf(handler, "%s::%s", event->system, event->name);
 
-	if (!test_and_set_bit(event->id, events_defined))
+	if (!__test_and_set_bit(event->id, events_defined))
 		define_event_symbols(event, handler, event->print_fmt.args);
 
 	s = nsecs / NSEC_PER_SEC;
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -933,7 +933,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
 
 	sprintf(handler_name, "%s__%s", event->system, event->name);
 
-	if (!test_and_set_bit(event->id, events_defined))
+	if (!__test_and_set_bit(event->id, events_defined))
 		define_event_symbols(event, handler_name, event->print_fmt.args);
 
 	handler = get_handler(handler_name);
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
@@ -2748,7 +2748,7 @@ int perf_session__cpu_bitmap(struct perf_session *session,
 			goto out_delete_map;
 		}
 
-		set_bit(cpu.cpu, cpu_bitmap);
+		__set_bit(cpu.cpu, cpu_bitmap);
 	}
 
 	err = 0;
diff --git a/tools/perf/util/svghelper.c b/tools/perf/util/svghelper.c
@@ -741,7 +741,7 @@ static int str_to_bitmap(char *s, cpumask_t *b, int nr_cpus)
 			break;
 		}
 
-		set_bit(c.cpu, cpumask_bits(b));
+		__set_bit(c.cpu, cpumask_bits(b));
 	}
 
 	perf_cpu_map__put(m);

Original file line number	Diff line number	Diff line change
`@@ -1573,7 +1573,7 @@ static int map_switch_event(struct perf_sched sched, struct evsel evsel,`
`1573`	`1573`
`1574`	`1574`	`if (sched->map.comp) {`
`1575`	`1575`	`cpus_nr = bitmap_weight(sched->map.comp_cpus_mask, MAX_CPUS);`
`1576`		`- if (!test_and_set_bit(this_cpu.cpu, sched->map.comp_cpus_mask)) {`
	`1576`	`+ if (!__test_and_set_bit(this_cpu.cpu, sched->map.comp_cpus_mask)) {`
`1577`	`1577`	`sched->map.comp_cpus[cpus_nr++] = this_cpu;`
`1578`	`1578`	`new_cpu = true;`
`1579`	`1579`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ static unsigned long get_bitmap(const char str, int nbits)`
`18`	`18`
`19`	`19`	`if (map && bm) {`
`20`	`20`	`for (i = 0; i < perf_cpu_map__nr(map); i++)`
`21`		`- set_bit(perf_cpu_map__cpu(map, i).cpu, bm);`
	`21`	`+ __set_bit(perf_cpu_map__cpu(map, i).cpu, bm);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`if (map)`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ static unsigned long get_bitmap(const char str, int nbits)`
`33`	`33`	`int i;`
`34`	`34`
`35`	`35`	`perf_cpu_map__for_each_cpu(cpu, i, map)`
`36`		`- set_bit(cpu.cpu, bm);`
	`36`	`+ __set_bit(cpu.cpu, bm);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`if (map)`
Original file line number	Diff line number	Diff line change
`@@ -79,12 +79,12 @@ struct perf_file_attr {`
`79`	`79`
`80`	`80`	`void perf_header__set_feat(struct perf_header *header, int feat)`
`81`	`81`	`{`
`82`		`- set_bit(feat, header->adds_features);`
	`82`	`+ __set_bit(feat, header->adds_features);`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`void perf_header__clear_feat(struct perf_header *header, int feat)`
`86`	`86`	`{`
`87`		`- clear_bit(feat, header->adds_features);`
	`87`	`+ __clear_bit(feat, header->adds_features);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`bool perf_header__has_feat(const struct perf_header *header, int feat)`
`@@ -1358,7 +1358,7 @@ static int memory_node__read(struct memory_node *n, unsigned long idx)`
`1358`	`1358`	`rewinddir(dir);`
`1359`	`1359`
`1360`	`1360`	`for_each_memory(phys, dir) {`
`1361`		`- set_bit(phys, n->set);`
	`1361`	`+ __set_bit(phys, n->set);`
`1362`	`1362`	`}`
`1363`	`1363`
`1364`	`1364`	`closedir(dir);`
`@@ -3952,7 +3952,7 @@ int perf_file_header__read(struct perf_file_header *header,`
`3952`	`3952`
`3953`	`3953`	`if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {`
`3954`	`3954`	`bitmap_zero(header->adds_features, HEADER_FEAT_BITS);`
`3955`		`- set_bit(HEADER_BUILD_ID, header->adds_features);`
	`3955`	`+ __set_bit(HEADER_BUILD_ID, header->adds_features);`
`3956`	`3956`	`}`
`3957`	`3957`	`}`
`3958`	`3958`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ static int perf_mmap__aio_bind(struct mmap *map, int idx, struct perf_cpu cpu, i`
`111`	`111`	`pr_err("Failed to allocate node mask for mbind: error %m\n");`
`112`	`112`	`return -1;`
`113`	`113`	`}`
`114`		`- set_bit(node_index, node_mask);`
	`114`	`+ __set_bit(node_index, node_mask);`
`115`	`115`	`if (mbind(data, mmap_len, MPOL_BIND, node_mask, node_index + 1 + 1, 0)) {`
`116`	`116`	`pr_err("Failed to bind [%p-%p] AIO buffer to node %lu: error %m\n",`
`117`	`117`	`data, data + mmap_len, node_index);`
`@@ -256,7 +256,7 @@ static void build_node_mask(int node, struct mmap_cpu_mask *mask)`
`256`	`256`	`for (idx = 0; idx < nr_cpus; idx++) {`
`257`	`257`	`cpu = perf_cpu_map__cpu(cpu_map, idx); /* map c index to online cpu index */`
`258`	`258`	`if (cpu__get_node(cpu) == node)`
`259`		`- set_bit(cpu.cpu, mask->bits);`
	`259`	`+ __set_bit(cpu.cpu, mask->bits);`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
`@@ -270,7 +270,7 @@ static int perf_mmap__setup_affinity_mask(struct mmap map, struct mmap_params `
`270`	`270`	`if (mp->affinity == PERF_AFFINITY_NODE && cpu__max_node() > 1)`
`271`	`271`	`build_node_mask(cpu__get_node(map->core.cpu), &map->affinity_mask);`
`272`	`272`	`else if (mp->affinity == PERF_AFFINITY_CPU)`
`273`		`- set_bit(map->core.cpu.cpu, map->affinity_mask.bits);`
	`273`	`+ __set_bit(map->core.cpu.cpu, map->affinity_mask.bits);`
`274`	`274`
`275`	`275`	`return 0;`
`276`	`276`	`}`