refactor: The target real name resolution is now done when needed by the perf module

Author: gfieni

src/perf.c

@@ -148,14 +148,15 @@ perf_group_context_destroy(struct perf_group_context **ctx)
 }
 
 static struct perf_context *
-perf_context_create(struct perf_config *config, zsock_t *pipe)
+perf_context_create(struct perf_config *config, zsock_t *pipe, const char *target_name)
 {
     struct perf_context *ctx = malloc(sizeof(struct perf_context));
 
     if (!ctx)
         return NULL;
 
     ctx->config = config;
+    ctx->target_name = target_name;
     ctx->terminated = false;
     ctx->pipe = pipe;
     ctx->ticker = zsock_new_sub("inproc://ticker", "CLOCK_TICK");
@@ -174,7 +175,6 @@ perf_context_destroy(struct perf_context *ctx)
     if (!ctx)
         return;
 
-    perf_config_destroy(ctx->config);
     zpoller_destroy(&ctx->poller);
     zsock_destroy(&ctx->ticker);
     zsock_destroy(&ctx->reporting);
@@ -195,19 +195,19 @@ perf_events_group_setup_cpu(struct perf_context *ctx, struct perf_group_cpu_cont
     errno = 0;
     cpu = strtol(cpu_id, &cpu_id_endp, 0);
     if (*cpu_id == '\0' || *cpu_id_endp != '\0' || errno) {
-        zsys_error("perf<%s>: failed convert cpu id for group=%s cpu=%s", ctx->config->target->name, group->name, cpu_id);
+        zsys_error("perf<%s>: failed convert cpu id for group=%s cpu=%s", ctx->target_name, group->name, cpu_id);
         return -1;
     }
     if (cpu > INT_MAX || cpu < INT_MIN) {
-        zsys_error("perf<%s>: cpu id is out of range for group=%s cpu=%s", ctx->config->target->name, group->name, cpu_id);
+        zsys_error("perf<%s>: cpu id is out of range for group=%s cpu=%s", ctx->target_name, group->name, cpu_id);
         return -1;
     }
 
     for (event = zlistx_first(group->events); event; event = zlistx_next(group->events)) {
         errno = 0;
         perf_fd = perf_event_open(&event->attr, ctx->cgroup_fd, (int) cpu, group_fd, perf_flags);
         if (perf_fd < 1) {
-            zsys_error("perf<%s>: failed opening perf event for group=%s cpu=%d event=%s errno=%d", ctx->config->target->name, group->name, (int) cpu, event->name, errno);
+            zsys_error("perf<%s>: failed opening perf event for group=%s cpu=%d event=%s errno=%d", ctx->target_name, group->name, (int) cpu, event->name, errno);
             return -1;
         }
 
@@ -239,7 +239,7 @@ perf_events_groups_initialize(struct perf_context *ctx)
         errno = 0;
         ctx->cgroup_fd = open(ctx->config->target->cgroup_path, O_RDONLY); 
         if (ctx->cgroup_fd < 1) {
-            zsys_error("perf<%s>: cannot open cgroup dir path=%s errno=%d", ctx->config->target->name, ctx->config->target->cgroup_path, errno);
+            zsys_error("perf<%s>: cannot open cgroup dir path=%s errno=%d", ctx->target_name, ctx->config->target->cgroup_path, errno);
             goto error;
         }
     }
@@ -250,7 +250,7 @@ perf_events_groups_initialize(struct perf_context *ctx)
         /* create group context */
         group_ctx = perf_group_context_create(events_group);
         if (!group_ctx) {
-            zsys_error("perf<%s>: failed to create context for group=%s", ctx->config->target->name, events_group_name);
+            zsys_error("perf<%s>: failed to create context for group=%s", ctx->target_name, events_group_name);
             goto error;
         }
 
@@ -260,21 +260,21 @@ perf_events_groups_initialize(struct perf_context *ctx)
             /* create package context */
             pkg_ctx = perf_group_pkg_context_create();
             if (!pkg_ctx) {
-                zsys_error("perf<%s>: failed to create pkg context for group=%s pkg=%s", ctx->config->target->name, events_group_name, pkg_id);
+                zsys_error("perf<%s>: failed to create pkg context for group=%s pkg=%s", ctx->target_name, events_group_name, pkg_id);
                 goto error;
             }
 
             for (cpu_id = zlistx_first(pkg->cpus_id); cpu_id; cpu_id = zlistx_next(pkg->cpus_id)) {
                 /* create cpu context */
                 cpu_ctx = perf_group_cpu_context_create();
                 if (!cpu_ctx) {
-                    zsys_error("perf<%s>: failed to create cpu context for group=%s pkg=%s cpu=%s", ctx->config->target->name, events_group_name, pkg_id, cpu_id);
+                    zsys_error("perf<%s>: failed to create cpu context for group=%s pkg=%s cpu=%s", ctx->target_name, events_group_name, pkg_id, cpu_id);
                     goto error;
                 }
 
                 /* open events of the group for the cpu */
                 if (perf_events_group_setup_cpu(ctx, cpu_ctx, events_group, perf_flags, cpu_id)) {
-                    zsys_error("perf<%s>: failed to setup perf for group=%s pkg=%s cpu=%s", ctx->config->target->name, events_group_name, pkg_id, cpu_id);
+                    zsys_error("perf<%s>: failed to setup perf for group=%s pkg=%s cpu=%s", ctx->target_name, events_group_name, pkg_id, cpu_id);
                     goto error;
                 }
 
@@ -324,17 +324,17 @@ perf_events_groups_enable(struct perf_context *ctx)
                 cpu_id = zhashx_cursor(pkg_ctx->cpus_ctx);
                 group_leader_fd = zlistx_first(cpu_ctx->perf_fds);
                 if (!group_leader_fd) {
-                    zsys_error("perf<%s>: no group leader fd for group=%s pkg=%s cpu=%s", ctx->config->target->name, group_name, pkg_id, cpu_id);
+                    zsys_error("perf<%s>: no group leader fd for group=%s pkg=%s cpu=%s", ctx->target_name, group_name, pkg_id, cpu_id);
                     continue;
                 }
 
                 errno = 0;
                 if (ioctl(*group_leader_fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP))
-                    zsys_error("perf<%s>: cannot reset events for group=%s pkg=%s cpu=%s errno=%d", ctx->config->target->name, group_name, pkg_id, cpu_id, errno);
+                    zsys_error("perf<%s>: cannot reset events for group=%s pkg=%s cpu=%s errno=%d", ctx->target_name, group_name, pkg_id, cpu_id, errno);
 
                 errno = 0;
                 if (ioctl(*group_leader_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP))
-                    zsys_error("perf<%s>: cannot enable events for group=%s pkg=%s cpu=%s errno=%d", ctx->config->target->name, group_name, pkg_id, cpu_id, errno);
+                    zsys_error("perf<%s>: cannot enable events for group=%s pkg=%s cpu=%s errno=%d", ctx->target_name, group_name, pkg_id, cpu_id, errno);
             }
         }
     }
@@ -366,10 +366,10 @@ handle_pipe(struct perf_context *ctx)
 
     if (streq(command, "$TERM")) {
         ctx->terminated = true;
-        zsys_info("perf<%s>: shutting down actor", ctx->config->target->name);
+        zsys_info("perf<%s>: shutting down actor", ctx->target_name);
     }
     else
-        zsys_error("perf<%s>: invalid pipe command: %s", ctx->config->target->name, command);
+        zsys_error("perf<%s>: invalid pipe command: %s", ctx->target_name, command);
 
     zstr_free(&command);
 }
@@ -402,44 +402,44 @@ populate_payload(struct perf_context *ctx, struct payload *payload)
         group_name = zhashx_cursor(ctx->groups_ctx);
         group_data = payload_group_data_create();
         if (!group_data) {
-            zsys_error("perf<%s>: failed to allocate group data for group=%s", ctx->config->target->name, group_name);
+            zsys_error("perf<%s>: failed to allocate group data for group=%s", ctx->target_name, group_name);
             goto error;
         }
 
         /* shared perf read buffer */
         perf_read_buffer_size = offsetof(struct perf_read_format, values) + sizeof(struct perf_counter_value[zlistx_size(group_ctx->config->events)]);
         perf_read_buffer = malloc(perf_read_buffer_size);
         if (!perf_read_buffer) {
-            zsys_error("perf<%s>: failed to allocate perf read buffer for group=%s", ctx->config->target->name, group_name);
+            zsys_error("perf<%s>: failed to allocate perf read buffer for group=%s", ctx->target_name, group_name);
             goto error;
         }
 
         for (pkg_ctx = zhashx_first(group_ctx->pkgs_ctx); pkg_ctx; pkg_ctx = zhashx_next(group_ctx->pkgs_ctx)) {
             pkg_id = zhashx_cursor(group_ctx->pkgs_ctx);
             pkg_data = payload_pkg_data_create();
             if (!pkg_data) {
-                zsys_error("perf<%s>: failed to allocate pkg data for group=%s pkg=%s", ctx->config->target->name, group_name, pkg_id);
+                zsys_error("perf<%s>: failed to allocate pkg data for group=%s pkg=%s", ctx->target_name, group_name, pkg_id);
                 goto error;
             }
 
             for (cpu_ctx = zhashx_first(pkg_ctx->cpus_ctx); cpu_ctx; cpu_ctx = zhashx_next(pkg_ctx->cpus_ctx)) {
                 cpu_id = zhashx_cursor(pkg_ctx->cpus_ctx);
                 cpu_data = payload_cpu_data_create();
                 if (!cpu_data) {
-                    zsys_error("perf<%s>: failed to allocate cpu data for group=%s pkg=%s cpu=%s", ctx->config->target->name, group_name, pkg_id, cpu_id);
+                    zsys_error("perf<%s>: failed to allocate cpu data for group=%s pkg=%s cpu=%s", ctx->target_name, group_name, pkg_id, cpu_id);
                     goto error;
                 }
 
                 /* read counters value for the cpu */
                 if (perf_events_group_read_cpu(cpu_ctx, perf_read_buffer, perf_read_buffer_size)) {
-                    zsys_error("perf<%s>: cannot read perf values for group=%s pkg=%s cpu=%s", ctx->config->target->name, group_name, pkg_id, cpu_id);
+                    zsys_error("perf<%s>: cannot read perf values for group=%s pkg=%s cpu=%s", ctx->target_name, group_name, pkg_id, cpu_id);
                     goto error;
                 }
 
                 /* warn if PMU multiplexing is happening */
                 perf_multiplexing_ratio = compute_perf_multiplexing_ratio(perf_read_buffer);
                 if (perf_multiplexing_ratio < 1.0) {
-                    zsys_warning("perf<%s>: perf multiplexing for group=%s pkg=%s cpu=%s ratio=%f", ctx->config->target->name, group_name, pkg_id, cpu_id, perf_multiplexing_ratio);
+                    zsys_warning("perf<%s>: perf multiplexing for group=%s pkg=%s cpu=%s ratio=%f", ctx->target_name, group_name, pkg_id, cpu_id, perf_multiplexing_ratio);
                 }
 
                 /* store events value */
@@ -479,14 +479,14 @@ handle_ticker(struct perf_context *ctx)
     /* get tick timestamp */
     zsock_recv(ctx->ticker, "s8", NULL, &timestamp);
 
-    payload = payload_create(timestamp, ctx->config->target->name);
+    payload = payload_create(timestamp, ctx->target_name);
     if (!payload) {
-        zsys_error("perf<%s>: failed to allocate payload for timestamp=%lu", ctx->config->target->name, timestamp);
+        zsys_error("perf<%s>: failed to allocate payload for timestamp=%lu", ctx->target_name, timestamp);
         return;
     }
 
     if (populate_payload(ctx, payload)) {
-        zsys_error("perf<%s>: failed to populate payload for timestamp=%lu", ctx->config->target->name, timestamp);
+        zsys_error("perf<%s>: failed to populate payload for timestamp=%lu", ctx->target_name, timestamp);
         payload_destroy(payload);
         return;
     }
@@ -498,39 +498,49 @@ handle_ticker(struct perf_context *ctx)
 void
 perf_monitoring_actor(zsock_t *pipe, void *args)
 {
-    struct perf_context *ctx = perf_context_create(args, pipe);
+    struct perf_config *config = args;
+    char *target_name = NULL;
+    struct perf_context *ctx = NULL;
     zsock_t *which = NULL;
 
-    if (!ctx) {
-        zsys_error("perf<%s>: cannot create perf context", ((struct perf_config *) args)->target->name);
-        perf_config_destroy(args);
-        return;
+    zsock_signal(pipe, 0);
+
+    target_name = target_resolve_real_name(config->target);
+    if (!target_name) {
+        zsys_error("perf: failed to resolve name of target for cgroup '%s'", config->target->cgroup_path);
+        goto cleanup;
     }
 
-    zsock_signal(pipe, 0);
+    ctx = perf_context_create(args, pipe, target_name);
+    if (!ctx) {
+        zsys_error("perf<%s>: cannot create perf context", target_name);
+        goto cleanup;
+    }
 
     if (perf_events_groups_initialize(ctx)) {
-        zsys_error("perf<%s>: cannot initialize perf monitoring", ctx->config->target->name);
-        perf_context_destroy(ctx);
-        return;
+        zsys_error("perf<%s>: cannot initialize perf monitoring", target_name);
+        goto cleanup;
     }
 
     perf_events_groups_enable(ctx);
 
-    zsys_info("perf<%s>: monitoring actor started", ctx->config->target->name);
+    zsys_info("perf<%s>: monitoring actor started", target_name);
 
     while (!ctx->terminated) {
         which = zpoller_wait(ctx->poller, -1);
 
         if (zpoller_terminated(ctx->poller))
             break;
-       
+
         if (which == ctx->pipe)
             handle_pipe(ctx);
         else if (which == ctx->ticker)
             handle_ticker(ctx);
     }
 
+cleanup:
+    free(target_name);
+    perf_config_destroy(config);
     perf_context_destroy(ctx);
 }
 

src/perf.h

@@ -63,6 +63,7 @@ struct perf_group_context
 struct perf_context
 {
     struct perf_config *config;
+    const char *target_name;
     bool terminated;
     zsock_t *pipe;
     zsock_t *ticker;