Quelle  test_udelay.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * udelay() test kernel module
 *
 * Test is executed by writing and reading to /sys/kernel/debug/udelay_test
 * Tests are configured by writing: USECS ITERATIONS
 * Tests are executed by reading from the same file.
 * Specifying usecs of 0 or negative values will run multiples tests.
 *
 * Copyright (C) 2014 Google, Inc.
 */

#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/ktime.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define DEFAULT_ITERATIONS 100

#define DEBUGFS_FILENAME "udelay_test"

static DEFINE_MUTEX(udelay_test_lock);
static int udelay_test_usecs;
static int udelay_test_iterations = DEFAULT_ITERATIONS;

static int udelay_test_single(struct seq_file *s, int usecs, uint32_t iters)
{
 int min = 0, max = 0, fail_count = 0;
 uint64_t sum = 0;
 uint64_t avg;
 int i;
 /* Allow udelay to be up to 0.5% fast */
 int allowed_error_ns = usecs * 5;

 for (i = 0; i < iters; ++i) {
  s64 kt1, kt2;
  int time_passed;

  kt1 = ktime_get_ns();
  udelay(usecs);
  kt2 = ktime_get_ns();
  time_passed = kt2 - kt1;

  if (i == 0 || time_passed < min)
   min = time_passed;
  if (i == 0 || time_passed > max)
   max = time_passed;
  if ((time_passed + allowed_error_ns) / 1000 < usecs)
   ++fail_count;
  WARN_ON(time_passed < 0);
  sum += time_passed;
 }

 avg = sum;
 do_div(avg, iters);
 seq_printf(s, "%d usecs x %d: exp=%d allowed=%d min=%d avg=%lld max=%d",
   usecs, iters, usecs * 1000,
   (usecs * 1000) - allowed_error_ns, min, avg, max);
 if (fail_count)
  seq_printf(s, " FAIL=%d", fail_count);
 seq_puts(s, "\n");

 return 0;
}

static int udelay_test_show(struct seq_file *s, void *v)
{
 int usecs;
 int iters;
 int ret = 0;

 mutex_lock(&udelay_test_lock);
 usecs = udelay_test_usecs;
 iters = udelay_test_iterations;
 mutex_unlock(&udelay_test_lock);

 if (usecs > 0 && iters > 0) {
  return udelay_test_single(s, usecs, iters);
 } else if (usecs == 0) {
  struct timespec64 ts;

  ktime_get_ts64(&ts);
  seq_printf(s, "udelay() test (lpj=%ld kt=%lld.%09ld)\n",
    loops_per_jiffy, (s64)ts.tv_sec, ts.tv_nsec);
  seq_puts(s, "usage:\n");
  seq_puts(s, "echo USECS [ITERS] > " DEBUGFS_FILENAME "\n");
  seq_puts(s, "cat " DEBUGFS_FILENAME "\n");
 }

 return ret;
}

static int udelay_test_open(struct inode *inode, struct file *file)
{
 return single_open(file, udelay_test_show, inode->i_private);
}

static ssize_t udelay_test_write(struct file *file, const char __user *buf,
  size_t count, loff_t *pos)
{
 char lbuf[32];
 int ret;
 int usecs;
 int iters;

 if (count >= sizeof(lbuf))
  return -EINVAL;

 if (copy_from_user(lbuf, buf, count))
  return -EFAULT;
 lbuf[count] = '\0';

 ret = sscanf(lbuf, "%d %d", &usecs, &iters);
 if (ret < 1)
  return -EINVAL;
 else if (ret < 2)
  iters = DEFAULT_ITERATIONS;

 mutex_lock(&udelay_test_lock);
 udelay_test_usecs = usecs;
 udelay_test_iterations = iters;
 mutex_unlock(&udelay_test_lock);

 return count;
}

static const struct file_operations udelay_test_debugfs_ops = {
 .owner = THIS_MODULE,
 .open = udelay_test_open,
 .read = seq_read,
 .write = udelay_test_write,
 .llseek = seq_lseek,
 .release = single_release,
};

static int __init udelay_test_init(void)
{
 mutex_lock(&udelay_test_lock);
 debugfs_create_file(DEBUGFS_FILENAME, S_IRUSR, NULL, NULL,
       &udelay_test_debugfs_ops);
 mutex_unlock(&udelay_test_lock);

 return 0;
}

module_init(udelay_test_init);

static void __exit udelay_test_exit(void)
{
 mutex_lock(&udelay_test_lock);
 debugfs_lookup_and_remove(DEBUGFS_FILENAME, NULL);
 mutex_unlock(&udelay_test_lock);
}

module_exit(udelay_test_exit);

MODULE_DESCRIPTION("udelay test module");
MODULE_AUTHOR("David Riley ");
MODULE_LICENSE("GPL");