#include "drm_pmu.h"
#include "counts.h"
#include "cpumap.h"
#include "debug.h"
#include "evsel.h"
#include "pmu.h"
#include <perf/threadmap.h>
#include <api/fs/fs.h>
#include <api/io.h>
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/unistd.h>
#include <linux/kcmp.h>
#include <linux/zalloc.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
enum drm_pmu_unit {
DRM_PMU_UNIT_BYTES,
DRM_PMU_UNIT_CAPACITY,
DRM_PMU_UNIT_CYCLES,
DRM_PMU_UNIT_HZ,
DRM_PMU_UNIT_NS,
DRM_PMU_UNIT_MAX,
};
struct drm_pmu_event {
const char *name;
const char *desc;
enum drm_pmu_unit unit;
};
struct drm_pmu {
struct perf_pmu pmu;
struct drm_pmu_event *events;
int num_events;
};
static const char * const drm_pmu_unit_strs[DRM_PMU_UNIT_MAX] = {
"bytes",
"capacity",
"cycles",
"hz",
"ns",
};
static const char * const drm_pmu_scale_unit_strs[DRM_PMU_UNIT_MAX] = {
"1bytes",
"1capacity",
"1cycles",
"1hz",
"1ns",
};
bool perf_pmu__is_drm(const struct perf_pmu *pmu)
{
return pmu && pmu->type >= PERF_PMU_TYPE_DRM_START &&
pmu->type <= PERF_PMU_TYPE_DRM_END;
}
bool evsel__is_drm(const struct evsel *evsel)
{
return perf_pmu__is_drm(evsel->pmu);
}
static struct drm_pmu *add_drm_pmu(struct list_head *pmus, char *line, size_t line_len)
{
struct drm_pmu *drm;
struct perf_pmu *pmu;
const char *name;
__u32 max_drm_pmu_type = 0, type;
int i = 12;
if (line[line_len - 1] == '\n')
line[line_len - 1] = '\0';
while (isspace(line[i]))
i++;
line[--i] = '_';
line[--i] = 'm';
line[--i] = 'r';
line[--i] = 'd';
name = &line[i];
list_for_each_entry(pmu, pmus, list) {
if (!perf_pmu__is_drm(pmu))
continue;
if (pmu->type > max_drm_pmu_type)
max_drm_pmu_type = pmu->type;
if (!strcmp(pmu->name, name)) {
return NULL;
}
}
if (max_drm_pmu_type != 0)
type = max_drm_pmu_type + 1;
else
type = PERF_PMU_TYPE_DRM_START;
if (type > PERF_PMU_TYPE_DRM_END) {
zfree(&drm);
pr_err("Unable to encode DRM PMU type for %s\n", name);
return NULL;
}
drm = zalloc(sizeof(*drm));
if (!drm)
return NULL;
if (perf_pmu__init(&drm->pmu, type, name) != 0) {
perf_pmu__delete(&drm->pmu);
return NULL;
}
drm->pmu.cpus = perf_cpu_map__new_int(0);
if (!drm->pmu.cpus) {
perf_pmu__delete(&drm->pmu);
return NULL;
}
return drm;
}
static bool starts_with(const char *str, const char *prefix)
{
return !strncmp(prefix, str, strlen(prefix));
}
static int add_event(struct drm_pmu_event **events, int *num_events,
const char *line, enum drm_pmu_unit unit, const char *desc)
{
const char *colon = strchr(line, ':');
struct drm_pmu_event *tmp;
if (!colon)
return -EINVAL;
tmp = reallocarray(*events, *num_events + 1, sizeof(struct drm_pmu_event));
if (!tmp)
return -ENOMEM;
tmp[*num_events].unit = unit;
tmp[*num_events].desc = desc;
tmp[*num_events].name = strndup(line, colon - line);
if (!tmp[*num_events].name)
return -ENOMEM;
(*num_events)++;
*events = tmp;
return 0;
}
static int read_drm_pmus_cb(void *args, int fdinfo_dir_fd, const char *fd_name)
{
struct list_head *pmus = args;
char buf[640];
struct io io;
char *line = NULL;
size_t line_len;
struct drm_pmu *drm = NULL;
struct drm_pmu_event *events = NULL;
int num_events = 0;
io__init(&io, openat(fdinfo_dir_fd, fd_name, O_RDONLY), buf, sizeof(buf));
if (io.fd == -1) {
return 0;
}
while (io__getline(&io, &line, &line_len) > 0) {
if (starts_with(line, "drm-driver:")) {
drm = add_drm_pmu(pmus, line, line_len);
if (!drm)
break;
continue;
}
if (starts_with(line, "drm-active-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_BYTES,
"Total memory active in one or more engines");
continue;
}
if (starts_with(line, "drm-cycles-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_CYCLES,
"Busy cycles");
continue;
}
if (starts_with(line, "drm-engine-capacity-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_CAPACITY,
"Engine capacity");
continue;
}
if (starts_with(line, "drm-engine-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_NS,
"Utilization in ns");
continue;
}
if (starts_with(line, "drm-maxfreq-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_HZ,
"Maximum frequency");
continue;
}
if (starts_with(line, "drm-purgeable-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_BYTES,
"Size of resident and purgeable memory buffers");
continue;
}
if (starts_with(line, "drm-resident-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_BYTES,
"Size of resident memory buffers");
continue;
}
if (starts_with(line, "drm-shared-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_BYTES,
"Size of shared memory buffers");
continue;
}
if (starts_with(line, "drm-total-cycles-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_BYTES,
"Total busy cycles");
continue;
}
if (starts_with(line, "drm-total-")) {
add_event(&events, &num_events, line, DRM_PMU_UNIT_BYTES,
"Size of shared and private memory");
continue;
}
if (verbose > 1 && starts_with(line, "drm-") &&
!starts_with(line, "drm-client-id:") &&
!starts_with(line, "drm-pdev:"))
pr_debug("Unhandled DRM PMU fdinfo line match '%s'\n", line);
}
if (drm) {
drm->events = events;
drm->num_events = num_events;
list_add_tail(&drm->pmu.list, pmus);
}
free(line);
if (io.fd != -1)
close(io.fd);
return 0;
}
void drm_pmu__exit(struct perf_pmu *pmu)
{
struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);
free(drm->events);
}
bool drm_pmu__have_event(const struct perf_pmu *pmu, const char *name)
{
struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);
if (!starts_with(name, "drm-"))
return false;
for (int i = 0; i < drm->num_events; i++) {
if (!strcasecmp(drm->events[i].name, name))
return true;
}
return false;
}
int drm_pmu__for_each_event(const struct perf_pmu *pmu, void *state, pmu_event_callback cb)
{
struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);
for (int i = 0; i < drm->num_events; i++) {
char encoding_buf[128];
struct pmu_event_info info = {
.pmu = pmu,
.name = drm->events[i].name,
.alias = NULL,
.scale_unit = drm_pmu_scale_unit_strs[drm->events[i].unit],
.desc = drm->events[i].desc,
.long_desc = NULL,
.encoding_desc = encoding_buf,
.topic = "drm",
.pmu_name = pmu->name,
.event_type_desc = "DRM event",
};
int ret;
snprintf(encoding_buf, sizeof(encoding_buf), "%s/config=0x%x/", pmu->name, i);
ret = cb(state, &info);
if (ret)
return ret;
}
return 0;
}
size_t drm_pmu__num_events(const struct perf_pmu *pmu)
{
const struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);
return drm->num_events;
}
static int drm_pmu__index_for_event(const struct drm_pmu *drm, const char *name)
{
for (int i = 0; i < drm->num_events; i++) {
if (!strcmp(drm->events[i].name, name))
return i;
}
return -1;
}
static int drm_pmu__config_term(const struct drm_pmu *drm,
struct perf_event_attr *attr,
struct parse_events_term *term,
struct parse_events_error *err)
{
if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
int i = drm_pmu__index_for_event(drm, term->config);
if (i >= 0) {
attr->config = i;
return 0;
}
}
if (err) {
char *err_str;
parse_events_error__handle(err, term->err_val,
asprintf(&err_str,
"unexpected drm event term (%s) %s",
parse_events__term_type_str(term->type_term),
term->config) < 0
? strdup("unexpected drm event term")
: err_str,
NULL);
}
return -EINVAL;
}
int drm_pmu__config_terms(const struct perf_pmu *pmu,
struct perf_event_attr *attr,
struct parse_events_terms *terms,
struct parse_events_error *err)
{
struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);
struct parse_events_term *term;
list_for_each_entry(term, &terms->terms, list) {
if (drm_pmu__config_term(drm, attr, term, err))
return -EINVAL;
}
return 0;
}
int drm_pmu__check_alias(const struct perf_pmu *pmu, struct parse_events_terms *terms,
struct perf_pmu_info *info, struct parse_events_error *err)
{
struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);
struct parse_events_term *term =
list_first_entry(&terms->terms, struct parse_events_term, list);
if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
int i = drm_pmu__index_for_event(drm, term->config);
if (i >= 0) {
info->unit = drm_pmu_unit_strs[drm->events[i].unit];
info->scale = 1;
return 0;
}
}
if (err) {
char *err_str;
parse_events_error__handle(err, term->err_val,
asprintf(&err_str,
"unexpected drm event term (%s) %s",
parse_events__term_type_str(term->type_term),
term->config) < 0
? strdup("unexpected drm event term")
: err_str,
NULL);
}
return -EINVAL;
}
struct minor_info {
unsigned int *minors;
int minors_num, minors_len;
};
static int for_each_drm_fdinfo_in_dir(int (*cb)(void *args, int fdinfo_dir_fd, const char *fd_name),
void *args, int proc_dir, const char *pid_name,
struct minor_info *minors)
{
char buf[256];
DIR *fd_dir;
struct dirent *fd_entry;
int fd_dir_fd, fdinfo_dir_fd = -1;
scnprintf(buf, sizeof(buf), "%s/fd", pid_name);
fd_dir_fd = openat(proc_dir, buf, O_DIRECTORY);
if (fd_dir_fd == -1)
return 0;
fd_dir = fdopendir(fd_dir_fd);
if (!fd_dir) {
close(fd_dir_fd);
return -ENOMEM;
}
while ((fd_entry = readdir(fd_dir)) != NULL) {
struct stat stat;
unsigned int minor;
bool is_dup = false;
int ret;
if (fd_entry->d_type != DT_LNK)
continue;
if (fstatat(fd_dir_fd, fd_entry->d_name, &stat, 0) != 0)
continue;
if ((stat.st_mode & S_IFMT) != S_IFCHR || major(stat.st_rdev) != 226)
continue;
minor = minor(stat.st_rdev);
for (int i = 0; i < minors->minors_num; i++) {
if (minor(stat.st_rdev) == minors->minors[i]) {
is_dup = true;
break;
}
}
if (is_dup)
continue;
if (minors->minors_num == minors->minors_len) {
unsigned int *tmp = reallocarray(minors->minors, minors->minors_len + 4,
sizeof(unsigned int));
if (tmp) {
minors->minors = tmp;
minors->minors_len += 4;
}
}
minors->minors[minors->minors_num++] = minor;
if (fdinfo_dir_fd == -1) {
scnprintf(buf, sizeof(buf), "%s/fdinfo", pid_name);
fdinfo_dir_fd = openat(proc_dir, buf, O_DIRECTORY);
if (fdinfo_dir_fd == -1)
continue;
}
ret = cb(args, fdinfo_dir_fd, fd_entry->d_name);
if (ret)
goto close_fdinfo;
}
close_fdinfo:
if (fdinfo_dir_fd != -1)
close(fdinfo_dir_fd);
closedir(fd_dir);
return 0;
}
static int for_each_drm_fdinfo(bool skip_all_duplicates,
int (*cb)(void *args, int fdinfo_dir_fd, const char *fd_name),
void *args)
{
DIR *proc_dir;
struct dirent *proc_entry;
int ret;
struct minor_info minors = {
.minors = NULL,
.minors_num = 0,
.minors_len = 0,
};
proc_dir = opendir(procfs__mountpoint());
if (!proc_dir)
return 0;
while ((proc_entry = readdir(proc_dir)) != NULL) {
if (proc_entry->d_type != DT_DIR ||
!isdigit(proc_entry->d_name[0]))
continue;
if (!skip_all_duplicates) {
minors.minors_num = 0;
}
ret = for_each_drm_fdinfo_in_dir(cb, args,
dirfd(proc_dir), proc_entry->d_name,
&minors);
if (ret)
break;
}
free(minors.minors);
closedir(proc_dir);
return ret;
}
int perf_pmus__read_drm_pmus(struct list_head *pmus)
{
return for_each_drm_fdinfo(true, read_drm_pmus_cb, pmus);
}
int evsel__drm_pmu_open(struct evsel *evsel,
struct perf_thread_map *threads,
int start_cpu_map_idx, int end_cpu_map_idx)
{
(void)evsel;
(void)threads;
(void)start_cpu_map_idx;
(void)end_cpu_map_idx;
return 0;
}
static uint64_t read_count_and_apply_unit(const char *count_and_unit, enum drm_pmu_unit unit)
{
char *unit_ptr = NULL;
uint64_t count = strtoul(count_and_unit, &unit_ptr, 10);
if (!unit_ptr)
return 0;
while (isblank(*unit_ptr))
unit_ptr++;
switch (unit) {
case DRM_PMU_UNIT_BYTES:
if (*unit_ptr == '\0')
assert(count == 0);
else if (!strcmp(unit_ptr, "KiB"))
count *= 1024;
else if (!strcmp(unit_ptr, "MiB"))
count *= 1024 * 1024;
else
pr_err("Unexpected bytes unit '%s'\n", unit_ptr);
break;
case DRM_PMU_UNIT_CAPACITY:
break;
case DRM_PMU_UNIT_CYCLES:
break;
case DRM_PMU_UNIT_HZ:
if (!strcmp(unit_ptr, "Hz"))
count *= 1;
else if (!strcmp(unit_ptr, "KHz"))
count *= 1000;
else if (!strcmp(unit_ptr, "MHz"))
count *= 1000000;
else
pr_err("Unexpected hz unit '%s'\n", unit_ptr);
break;
case DRM_PMU_UNIT_NS:
break;
case DRM_PMU_UNIT_MAX:
default:
break;
}
return count;
}
static uint64_t read_drm_event(int fdinfo_dir_fd, const char *fd_name,
const char *match, enum drm_pmu_unit unit)
{
char buf[640];
struct io io;
char *line = NULL;
size_t line_len;
uint64_t count = 0;
io__init(&io, openat(fdinfo_dir_fd, fd_name, O_RDONLY), buf, sizeof(buf));
if (io.fd == -1) {
return 0;
}
while (io__getline(&io, &line, &line_len) > 0) {
size_t i = strlen(match);
if (strncmp(line, match, i))
continue;
if (line[i] != ':')
continue;
while (isblank(line[++i]))
;
if (line[line_len - 1] == '\n')
line[line_len - 1] = '\0';
count = read_count_and_apply_unit(&line[i], unit);
break;
}
free(line);
close(io.fd);
return count;
}
struct read_drm_event_cb_args {
const char *match;
uint64_t count;
enum drm_pmu_unit unit;
};
static int read_drm_event_cb(void *vargs, int fdinfo_dir_fd, const char *fd_name)
{
struct read_drm_event_cb_args *args = vargs;
args->count += read_drm_event(fdinfo_dir_fd, fd_name, args->match, args->unit);
return 0;
}
static uint64_t drm_pmu__read_system_wide(struct drm_pmu *drm, struct evsel *evsel)
{
struct read_drm_event_cb_args args = {
.count = 0,
.match = drm->events[evsel->core.attr.config].name,
.unit = drm->events[evsel->core.attr.config].unit,
};
for_each_drm_fdinfo(false, read_drm_event_cb, &args);
return args.count;
}
static uint64_t drm_pmu__read_for_pid(struct drm_pmu *drm, struct evsel *evsel, int pid)
{
struct read_drm_event_cb_args args = {
.count = 0,
.match = drm->events[evsel->core.attr.config].name,
.unit = drm->events[evsel->core.attr.config].unit,
};
struct minor_info minors = {
.minors = NULL,
.minors_num = 0,
.minors_len = 0,
};
int proc_dir = open(procfs__mountpoint(), O_DIRECTORY);
char pid_name[12];
int ret;
if (proc_dir < 0)
return 0;
snprintf(pid_name, sizeof(pid_name), "%d", pid);
ret = for_each_drm_fdinfo_in_dir(read_drm_event_cb, &args, proc_dir, pid_name, &minors);
free(minors.minors);
close(proc_dir);
return ret == 0 ? args.count : 0;
}
int evsel__drm_pmu_read(struct evsel *evsel, int cpu_map_idx, int thread)
{
struct drm_pmu *drm = container_of(evsel->pmu, struct drm_pmu, pmu);
struct perf_counts_values *count, *old_count = NULL;
int pid = perf_thread_map__pid(evsel->core.threads, thread);
uint64_t counter;
if (pid != -1)
counter = drm_pmu__read_for_pid(drm, evsel, pid);
else
counter = drm_pmu__read_system_wide(drm, evsel);
if (evsel->prev_raw_counts)
old_count = perf_counts(evsel->prev_raw_counts, cpu_map_idx, thread);
count = perf_counts(evsel->counts, cpu_map_idx, thread);
if (old_count) {
count->val = old_count->val + counter;
count->run = old_count->run + 1;
count->ena = old_count->ena + 1;
} else {
count->val = counter;
count->run++;
count->ena++;
}
return 0;
}
