GNU Linux-libre 4.19.286-gnu1
[releases.git] / arch / mips / kernel / spinlock_test.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/init.h>
3 #include <linux/kthread.h>
4 #include <linux/hrtimer.h>
5 #include <linux/fs.h>
6 #include <linux/debugfs.h>
7 #include <linux/export.h>
8 #include <linux/spinlock.h>
9 #include <asm/debug.h>
10
11 static int ss_get(void *data, u64 *val)
12 {
13         ktime_t start, finish;
14         int loops;
15         int cont;
16         DEFINE_RAW_SPINLOCK(ss_spin);
17
18         loops = 1000000;
19         cont = 1;
20
21         start = ktime_get();
22
23         while (cont) {
24                 raw_spin_lock(&ss_spin);
25                 loops--;
26                 if (loops == 0)
27                         cont = 0;
28                 raw_spin_unlock(&ss_spin);
29         }
30
31         finish = ktime_get();
32
33         *val = ktime_us_delta(finish, start);
34
35         return 0;
36 }
37
38 DEFINE_SIMPLE_ATTRIBUTE(fops_ss, ss_get, NULL, "%llu\n");
39
40
41
42 struct spin_multi_state {
43         raw_spinlock_t lock;
44         atomic_t start_wait;
45         atomic_t enter_wait;
46         atomic_t exit_wait;
47         int loops;
48 };
49
50 struct spin_multi_per_thread {
51         struct spin_multi_state *state;
52         ktime_t start;
53 };
54
55 static int multi_other(void *data)
56 {
57         int loops;
58         int cont;
59         struct spin_multi_per_thread *pt = data;
60         struct spin_multi_state *s = pt->state;
61
62         loops = s->loops;
63         cont = 1;
64
65         atomic_dec(&s->enter_wait);
66
67         while (atomic_read(&s->enter_wait))
68                 ; /* spin */
69
70         pt->start = ktime_get();
71
72         atomic_dec(&s->start_wait);
73
74         while (atomic_read(&s->start_wait))
75                 ; /* spin */
76
77         while (cont) {
78                 raw_spin_lock(&s->lock);
79                 loops--;
80                 if (loops == 0)
81                         cont = 0;
82                 raw_spin_unlock(&s->lock);
83         }
84
85         atomic_dec(&s->exit_wait);
86         while (atomic_read(&s->exit_wait))
87                 ; /* spin */
88         return 0;
89 }
90
91 static int multi_get(void *data, u64 *val)
92 {
93         ktime_t finish;
94         struct spin_multi_state ms;
95         struct spin_multi_per_thread t1, t2;
96
97         ms.lock = __RAW_SPIN_LOCK_UNLOCKED("multi_get");
98         ms.loops = 1000000;
99
100         atomic_set(&ms.start_wait, 2);
101         atomic_set(&ms.enter_wait, 2);
102         atomic_set(&ms.exit_wait, 2);
103         t1.state = &ms;
104         t2.state = &ms;
105
106         kthread_run(multi_other, &t2, "multi_get");
107
108         multi_other(&t1);
109
110         finish = ktime_get();
111
112         *val = ktime_us_delta(finish, t1.start);
113
114         return 0;
115 }
116
117 DEFINE_SIMPLE_ATTRIBUTE(fops_multi, multi_get, NULL, "%llu\n");
118
119 static int __init spinlock_test(void)
120 {
121         struct dentry *d;
122
123         if (!mips_debugfs_dir)
124                 return -ENODEV;
125
126         d = debugfs_create_file("spin_single", S_IRUGO,
127                                 mips_debugfs_dir, NULL,
128                                 &fops_ss);
129         if (!d)
130                 return -ENOMEM;
131
132         d = debugfs_create_file("spin_multi", S_IRUGO,
133                                 mips_debugfs_dir, NULL,
134                                 &fops_multi);
135         if (!d)
136                 return -ENOMEM;
137
138         return 0;
139 }
140 device_initcall(spinlock_test);