#include "common/align.h"
#include "common/bitmap.h"
-#include "smp.h"
+#include "common/smp.h"
+#include "common/populate.h"
#include "shm.h"
static size_t lttng_counter_get_dimension_nr_elements(struct lib_counter_dimension *dimension)
if (counter->is_daemon) {
/* Allocate and clear shared memory. */
shm_object = lttng_counter_shm_object_table_alloc(counter->object_table,
- shm_length, LTTNG_COUNTER_SHM_OBJECT_SHM, shm_fd, cpu);
+ shm_length, LTTNG_COUNTER_SHM_OBJECT_SHM, shm_fd, cpu,
+ lttng_ust_map_populate_cpu_is_enabled(cpu));
if (!shm_object)
return -ENOMEM;
} else {
/* Map pre-existing shared memory. */
shm_object = lttng_counter_shm_object_table_append_shm(counter->object_table,
- shm_fd, shm_length);
+ shm_fd, shm_length, lttng_ust_map_populate_cpu_is_enabled(cpu));
if (!shm_object)
return -ENOMEM;
}
struct lib_counter_config *config = &counter->config;
struct lib_counter_layout *layout;
- if (cpu < 0 || cpu >= lttng_counter_num_possible_cpus())
+ if (cpu < 0 || cpu >= get_possible_cpus_array_len())
return -EINVAL;
if (!(config->alloc & COUNTER_ALLOC_PER_CPU))
int nr_counter_cpu_fds,
const int *counter_cpu_fds)
{
- int nr_cpus = lttng_counter_num_possible_cpus();
+ int nr_cpus = get_possible_cpus_array_len();
if (CAA_BITS_PER_LONG != 64 && config->counter_size == COUNTER_SIZE_64_BIT) {
WARN_ON_ONCE(1);
size_t dimension, nr_elem = 1;
int cpu, ret;
int nr_handles = 0;
- int nr_cpus = lttng_counter_num_possible_cpus();
+ int nr_cpus = get_possible_cpus_array_len();
+ bool populate = lttng_ust_map_populate_is_enabled();
if (validate_args(config, nr_dimensions, max_nr_elem,
global_sum_step, global_counter_fd, nr_counter_cpu_fds,
counter_cpu_fds))
return NULL;
- counter = zmalloc(sizeof(struct lib_counter));
+ counter = zmalloc_populate(sizeof(struct lib_counter), populate);
if (!counter)
return NULL;
counter->global_counters.shm_fd = -1;
if (lttng_counter_set_global_sum_step(counter, global_sum_step))
goto error_sum_step;
counter->nr_dimensions = nr_dimensions;
- counter->dimensions = zmalloc(nr_dimensions * sizeof(*counter->dimensions));
+ counter->dimensions = zmalloc_populate(nr_dimensions * sizeof(*counter->dimensions), populate);
if (!counter->dimensions)
goto error_dimensions;
for (dimension = 0; dimension < nr_dimensions; dimension++)
counter->dimensions[dimension].max_nr_elem = max_nr_elem[dimension];
if (config->alloc & COUNTER_ALLOC_PER_CPU) {
- counter->percpu_counters = zmalloc(sizeof(struct lib_counter_layout) * nr_cpus);
+ counter->percpu_counters = zmalloc_populate(sizeof(struct lib_counter_layout) * nr_cpus, populate);
if (!counter->percpu_counters)
goto error_alloc_percpu;
- lttng_counter_for_each_possible_cpu(cpu)
+ for_each_possible_cpu(cpu)
counter->percpu_counters[cpu].shm_fd = -1;
}
if (config->alloc & COUNTER_ALLOC_PER_CPU)
nr_handles += nr_cpus;
/* Allocate table for global and per-cpu counters. */
- counter->object_table = lttng_counter_shm_object_table_create(nr_handles);
+ counter->object_table = lttng_counter_shm_object_table_create(nr_handles, populate);
if (!counter->object_table)
goto error_alloc_object_table;
goto layout_init_error;
}
if ((config->alloc & COUNTER_ALLOC_PER_CPU) && counter_cpu_fds) {
- lttng_counter_for_each_possible_cpu(cpu) {
+ for_each_possible_cpu(cpu) {
ret = lttng_counter_layout_init(counter, cpu, counter_cpu_fds[cpu]);
if (ret)
goto layout_init_error;
struct lib_counter_layout *layout;
int shm_fd;
- if (cpu >= lttng_counter_num_possible_cpus())
+ if (cpu >= get_possible_cpus_array_len())
return -1;
layout = &counter->percpu_counters[cpu];
shm_fd = layout->shm_fd;
switch (config->alloc) {
case COUNTER_ALLOC_PER_CPU:
- if (cpu < 0 || cpu >= lttng_counter_num_possible_cpus())
+ if (cpu < 0 || cpu >= get_possible_cpus_array_len())
return -EINVAL;
layout = &counter->percpu_counters[cpu];
break;
case COUNTER_ALLOC_PER_CPU | COUNTER_ALLOC_GLOBAL:
if (cpu >= 0) {
- if (cpu >= lttng_counter_num_possible_cpus())
+ if (cpu >= get_possible_cpus_array_len())
return -EINVAL;
layout = &counter->percpu_counters[cpu];
} else {
break;
case COUNTER_ALLOC_PER_CPU | COUNTER_ALLOC_GLOBAL: /* Fallthrough */
case COUNTER_ALLOC_PER_CPU:
- lttng_counter_for_each_possible_cpu(cpu) {
+ for_each_possible_cpu(cpu) {
int64_t old = sum;
ret = lttng_counter_read(config, counter, dimension_indexes,
switch (config->alloc) {
case COUNTER_ALLOC_PER_CPU:
- if (cpu < 0 || cpu >= lttng_counter_num_possible_cpus())
+ if (cpu < 0 || cpu >= get_possible_cpus_array_len())
return -EINVAL;
layout = &counter->percpu_counters[cpu];
break;
case COUNTER_ALLOC_PER_CPU | COUNTER_ALLOC_GLOBAL:
if (cpu >= 0) {
- if (cpu >= lttng_counter_num_possible_cpus())
+ if (cpu >= get_possible_cpus_array_len())
return -EINVAL;
layout = &counter->percpu_counters[cpu];
} else {
switch (config->alloc) {
case COUNTER_ALLOC_PER_CPU: /* Fallthrough */
case COUNTER_ALLOC_PER_CPU | COUNTER_ALLOC_GLOBAL:
- lttng_counter_for_each_possible_cpu(cpu) {
+ for_each_possible_cpu(cpu) {
ret = lttng_counter_clear_cpu(config, counter, dimension_indexes, cpu);
if (ret < 0)
return ret;