linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Generic dynamic event control interface

 *

 * Copyright (C) 2018 Masami Hiramatsu <mhiramat@kernel.org>

 */

​

#include <linux/debugfs.h>

#include <linux/kernel.h>

#include <linux/list.h>

#include <linux/mm.h>

#include <linux/mutex.h>

#include <linux/tracefs.h>

​

#include "trace.h"

#include "trace_dynevent.h"

​

static DEFINE_MUTEX(dyn_event_ops_mutex);

static LIST_HEAD(dyn_event_ops_list);

​

int dyn_event_register(struct dyn_event_operations *ops)

{

    if (!ops || !ops->create || !ops->show || !ops->is_busy ||

        !ops->free || !ops->match)

        return -EINVAL;

​

    INIT_LIST_HEAD(&ops->list);

    mutex_lock(&dyn_event_ops_mutex);

    list_add_tail(&ops->list, &dyn_event_ops_list);

    mutex_unlock(&dyn_event_ops_mutex);

    return 0;

}

​

int dyn_event_release(int argc, char **argv, struct dyn_event_operations *type)

{

    struct dyn_event *pos, *n;

    char *system = NULL, *event, *p;

    int ret = -ENOENT;

​

    if (argv[0][0] == '-') {

        if (argv[0][1] != ':')

            return -EINVAL;

        event = &argv[0][2];

    } else {

        event = strchr(argv[0], ':');

        if (!event)

            return -EINVAL;

        event++;

    }

​

    p = strchr(event, '/');

    if (p) {

        system = event;

        event = p + 1;

        *p = '\0';

    }

    if (event[0] == '\0')

        return -EINVAL;

​

    mutex_lock(&event_mutex);

    for_each_dyn_event_safe(pos, n) {

        if (type && type != pos->ops)

            continue;

        if (pos->ops->match(system, event, pos)) {

            ret = pos->ops->free(pos);

            break;

        }

    }

    mutex_unlock(&event_mutex);

​

    return ret;

}

​

static int create_dyn_event(int argc, char **argv)

{

    struct dyn_event_operations *ops;

    int ret = -ENODEV;

​

    if (argv[0][0] == '-' || argv[0][0] == '!')

        return dyn_event_release(argc, argv, NULL);

​

    mutex_lock(&dyn_event_ops_mutex);

    list_for_each_entry(ops, &dyn_event_ops_list, list) {

        ret = ops->create(argc, (const char **)argv);

        if (!ret || ret != -ECANCELED)

            break;

    }

    mutex_unlock(&dyn_event_ops_mutex);

    if (ret == -ECANCELED)

        ret = -EINVAL;

​

    return ret;