linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * ring buffer tester and benchmark

 *

 * Copyright (C) 2009 Steven Rostedt <srostedt@redhat.com>

 */

#include <linux/ring_buffer.h>

#include <linux/completion.h>

#include <linux/kthread.h>

#include <uapi/linux/sched/types.h>

#include <linux/module.h>

#include <linux/ktime.h>

#include <asm/local.h>

​

struct rb_page {

    u64     ts;

    local_t     commit;

    char        data[4080];

};

​

/* run time and sleep time in seconds */

#define RUN_TIME    10ULL

#define SLEEP_TIME  10

​

/* number of events for writer to wake up the reader */

static int wakeup_interval = 100;

​

static int reader_finish;

static DECLARE_COMPLETION(read_start);

static DECLARE_COMPLETION(read_done);

​

static struct ring_buffer *buffer;

static struct task_struct *producer;

static struct task_struct *consumer;

static unsigned long read;

​

static unsigned int disable_reader;

module_param(disable_reader, uint, 0644);

MODULE_PARM_DESC(disable_reader, "only run producer");

​

static unsigned int write_iteration = 50;

module_param(write_iteration, uint, 0644);

MODULE_PARM_DESC(write_iteration, "# of writes between timestamp readings");

​

static int producer_nice = MAX_NICE;

static int consumer_nice = MAX_NICE;

​

static int producer_fifo = -1;

static int consumer_fifo = -1;

​

module_param(producer_nice, int, 0644);

MODULE_PARM_DESC(producer_nice, "nice prio for producer");

​

module_param(consumer_nice, int, 0644);

MODULE_PARM_DESC(consumer_nice, "nice prio for consumer");

​

module_param(producer_fifo, int, 0644);

MODULE_PARM_DESC(producer_fifo, "fifo prio for producer");

​

module_param(consumer_fifo, int, 0644);

MODULE_PARM_DESC(consumer_fifo, "fifo prio for consumer");

​

static int read_events;

​

static int test_error;

​

#define TEST_ERROR()                \

    do {                    \

        if (!test_error) {      \

            test_error = 1;     \

            WARN_ON(1);     \

        }               \

    } while (0)

​

enum event_status {

    EVENT_FOUND,

    EVENT_DROPPED,

};

​

static bool break_test(void)

{

    return test_error || kthread_should_stop();

}

​

static enum event_status read_event(int cpu)

{

    struct ring_buffer_event *event;

    int *entry;

    u64 ts;

​

    event = ring_buffer_consume(buffer, cpu, &ts, NULL);

    if (!event)