]>
Commit | Line | Data |
---|---|---|
716154c5 BB |
1 | /*****************************************************************************\ |
2 | * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC. | |
3 | * Copyright (C) 2007 The Regents of the University of California. | |
4 | * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). | |
5 | * Written by Brian Behlendorf <behlendorf1@llnl.gov>. | |
715f6251 | 6 | * UCRL-CODE-235197 |
7 | * | |
716154c5 | 8 | * This file is part of the SPL, Solaris Porting Layer. |
3d6af2dd | 9 | * For details, see <http://zfsonlinux.org/>. |
716154c5 BB |
10 | * |
11 | * The SPL is free software; you can redistribute it and/or modify it | |
12 | * under the terms of the GNU General Public License as published by the | |
13 | * Free Software Foundation; either version 2 of the License, or (at your | |
14 | * option) any later version. | |
715f6251 | 15 | * |
716154c5 | 16 | * The SPL is distributed in the hope that it will be useful, but WITHOUT |
715f6251 | 17 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
18 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
19 | * for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU General Public License along | |
716154c5 BB |
22 | * with the SPL. If not, see <http://www.gnu.org/licenses/>. |
23 | ***************************************************************************** | |
24 | * Solaris Porting LAyer Tests (SPLAT) Atomic Tests. | |
25 | \*****************************************************************************/ | |
715f6251 | 26 | |
df870a69 BB |
27 | #include <sys/atomic.h> |
28 | #include <sys/thread.h> | |
0cb3dafc | 29 | #include <sys/mutex.h> |
52479ecf | 30 | #include <linux/mm_compat.h> |
79a7ab25 | 31 | #include <linux/slab.h> |
9f4c835a | 32 | #include "splat-internal.h" |
33 | ||
9f4c835a | 34 | #define SPLAT_ATOMIC_NAME "atomic" |
35 | #define SPLAT_ATOMIC_DESC "Kernel Atomic Tests" | |
36 | ||
37 | #define SPLAT_ATOMIC_TEST1_ID 0x0b01 | |
38 | #define SPLAT_ATOMIC_TEST1_NAME "64-bit" | |
39 | #define SPLAT_ATOMIC_TEST1_DESC "Validate 64-bit atomic ops" | |
40 | ||
41 | #define SPLAT_ATOMIC_TEST_MAGIC 0x43435454UL | |
42 | #define SPLAT_ATOMIC_INIT_VALUE 10000000UL | |
43 | ||
44 | typedef enum { | |
45 | SPLAT_ATOMIC_INC_64 = 0, | |
46 | SPLAT_ATOMIC_DEC_64 = 1, | |
47 | SPLAT_ATOMIC_ADD_64 = 2, | |
48 | SPLAT_ATOMIC_SUB_64 = 3, | |
49 | SPLAT_ATOMIC_ADD_64_NV = 4, | |
50 | SPLAT_ATOMIC_SUB_64_NV = 5, | |
51 | SPLAT_ATOMIC_COUNT_64 = 6 | |
52 | } atomic_op_t; | |
53 | ||
54 | typedef struct atomic_priv { | |
55 | unsigned long ap_magic; | |
56 | struct file *ap_file; | |
0cb3dafc | 57 | kmutex_t ap_lock; |
9f4c835a | 58 | wait_queue_head_t ap_waitq; |
59 | volatile uint64_t ap_atomic; | |
60 | volatile uint64_t ap_atomic_exited; | |
61 | atomic_op_t ap_op; | |
62 | ||
63 | } atomic_priv_t; | |
64 | ||
65 | static void | |
66 | splat_atomic_work(void *priv) | |
67 | { | |
68 | atomic_priv_t *ap; | |
69 | atomic_op_t op; | |
70 | int i; | |
71 | ||
72 | ap = (atomic_priv_t *)priv; | |
73 | ASSERT(ap->ap_magic == SPLAT_ATOMIC_TEST_MAGIC); | |
74 | ||
0cb3dafc | 75 | mutex_enter(&ap->ap_lock); |
9f4c835a | 76 | op = ap->ap_op; |
77 | wake_up(&ap->ap_waitq); | |
0cb3dafc | 78 | mutex_exit(&ap->ap_lock); |
9f4c835a | 79 | |
80 | splat_vprint(ap->ap_file, SPLAT_ATOMIC_TEST1_NAME, | |
81 | "Thread %d successfully started: %lu/%lu\n", op, | |
82 | (long unsigned)ap->ap_atomic, | |
83 | (long unsigned)ap->ap_atomic_exited); | |
84 | ||
85 | for (i = 0; i < SPLAT_ATOMIC_INIT_VALUE / 10; i++) { | |
86 | ||
87 | /* Periodically sleep to mix up the ordering */ | |
88 | if ((i % (SPLAT_ATOMIC_INIT_VALUE / 100)) == 0) { | |
89 | splat_vprint(ap->ap_file, SPLAT_ATOMIC_TEST1_NAME, | |
90 | "Thread %d sleeping: %lu/%lu\n", op, | |
91 | (long unsigned)ap->ap_atomic, | |
92 | (long unsigned)ap->ap_atomic_exited); | |
93 | set_current_state(TASK_INTERRUPTIBLE); | |
94 | schedule_timeout(HZ / 100); | |
95 | } | |
96 | ||
97 | switch (op) { | |
98 | case SPLAT_ATOMIC_INC_64: | |
99 | atomic_inc_64(&ap->ap_atomic); | |
100 | break; | |
101 | case SPLAT_ATOMIC_DEC_64: | |
102 | atomic_dec_64(&ap->ap_atomic); | |
103 | break; | |
104 | case SPLAT_ATOMIC_ADD_64: | |
105 | atomic_add_64(&ap->ap_atomic, 3); | |
106 | break; | |
107 | case SPLAT_ATOMIC_SUB_64: | |
108 | atomic_sub_64(&ap->ap_atomic, 3); | |
109 | break; | |
110 | case SPLAT_ATOMIC_ADD_64_NV: | |
111 | atomic_add_64_nv(&ap->ap_atomic, 5); | |
112 | break; | |
113 | case SPLAT_ATOMIC_SUB_64_NV: | |
114 | atomic_sub_64_nv(&ap->ap_atomic, 5); | |
115 | break; | |
116 | default: | |
55abb092 | 117 | PANIC("Undefined op %d\n", op); |
9f4c835a | 118 | } |
119 | } | |
120 | ||
121 | atomic_inc_64(&ap->ap_atomic_exited); | |
122 | ||
123 | splat_vprint(ap->ap_file, SPLAT_ATOMIC_TEST1_NAME, | |
124 | "Thread %d successfully exited: %lu/%lu\n", op, | |
125 | (long unsigned)ap->ap_atomic, | |
126 | (long unsigned)ap->ap_atomic_exited); | |
127 | ||
9f4c835a | 128 | wake_up(&ap->ap_waitq); |
728b9dd8 | 129 | thread_exit(); |
9f4c835a | 130 | } |
131 | ||
132 | static int | |
55c59e61 | 133 | splat_atomic_test1_cond(atomic_priv_t *ap, int started) |
9f4c835a | 134 | { |
55c59e61 | 135 | return (ap->ap_atomic_exited == started); |
9f4c835a | 136 | } |
137 | ||
138 | static int | |
139 | splat_atomic_test1(struct file *file, void *arg) | |
140 | { | |
141 | atomic_priv_t ap; | |
142 | DEFINE_WAIT(wait); | |
143 | kthread_t *thr; | |
55c59e61 | 144 | int i, rc = 0; |
9f4c835a | 145 | |
146 | ap.ap_magic = SPLAT_ATOMIC_TEST_MAGIC; | |
147 | ap.ap_file = file; | |
d0d5dd71 | 148 | mutex_init(&ap.ap_lock, SPLAT_ATOMIC_TEST1_NAME, MUTEX_DEFAULT, NULL); |
9f4c835a | 149 | init_waitqueue_head(&ap.ap_waitq); |
150 | ap.ap_atomic = SPLAT_ATOMIC_INIT_VALUE; | |
151 | ap.ap_atomic_exited = 0; | |
152 | ||
153 | for (i = 0; i < SPLAT_ATOMIC_COUNT_64; i++) { | |
0cb3dafc | 154 | mutex_enter(&ap.ap_lock); |
9f4c835a | 155 | ap.ap_op = i; |
156 | ||
157 | thr = (kthread_t *)thread_create(NULL, 0, splat_atomic_work, | |
158 | &ap, 0, &p0, TS_RUN, | |
62aa81a5 | 159 | defclsyspri); |
55c59e61 | 160 | if (thr == NULL) { |
161 | rc = -ESRCH; | |
0cb3dafc | 162 | mutex_exit(&ap.ap_lock); |
55c59e61 | 163 | break; |
164 | } | |
9f4c835a | 165 | |
166 | /* Prepare to wait, the new thread will wake us once it | |
167 | * has made a copy of the unique private passed data */ | |
168 | prepare_to_wait(&ap.ap_waitq, &wait, TASK_UNINTERRUPTIBLE); | |
0cb3dafc | 169 | mutex_exit(&ap.ap_lock); |
9f4c835a | 170 | schedule(); |
171 | } | |
172 | ||
8f813bb1 | 173 | wait_event(ap.ap_waitq, splat_atomic_test1_cond(&ap, i)); |
55c59e61 | 174 | |
175 | if (rc) { | |
176 | splat_vprint(file, SPLAT_ATOMIC_TEST1_NAME, "Only started " | |
177 | "%d/%d test threads\n", i, SPLAT_ATOMIC_COUNT_64); | |
178 | return rc; | |
179 | } | |
9f4c835a | 180 | |
181 | if (ap.ap_atomic != SPLAT_ATOMIC_INIT_VALUE) { | |
182 | splat_vprint(file, SPLAT_ATOMIC_TEST1_NAME, | |
183 | "Final value %lu does not match initial value %lu\n", | |
184 | (long unsigned)ap.ap_atomic, SPLAT_ATOMIC_INIT_VALUE); | |
185 | return -EINVAL; | |
186 | } | |
187 | ||
188 | splat_vprint(file, SPLAT_ATOMIC_TEST1_NAME, | |
189 | "Success initial and final values match, %lu == %lu\n", | |
190 | (long unsigned)ap.ap_atomic, SPLAT_ATOMIC_INIT_VALUE); | |
191 | ||
0cb3dafc BB |
192 | mutex_destroy(&ap.ap_lock); |
193 | ||
9f4c835a | 194 | return 0; |
195 | } | |
196 | ||
197 | splat_subsystem_t * | |
198 | splat_atomic_init(void) | |
199 | { | |
200 | splat_subsystem_t *sub; | |
201 | ||
202 | sub = kmalloc(sizeof(*sub), GFP_KERNEL); | |
203 | if (sub == NULL) | |
204 | return NULL; | |
205 | ||
206 | memset(sub, 0, sizeof(*sub)); | |
207 | strncpy(sub->desc.name, SPLAT_ATOMIC_NAME, SPLAT_NAME_SIZE); | |
208 | strncpy(sub->desc.desc, SPLAT_ATOMIC_DESC, SPLAT_DESC_SIZE); | |
209 | INIT_LIST_HEAD(&sub->subsystem_list); | |
210 | INIT_LIST_HEAD(&sub->test_list); | |
211 | spin_lock_init(&sub->test_lock); | |
212 | sub->desc.id = SPLAT_SUBSYSTEM_ATOMIC; | |
213 | ||
9c9ad845 | 214 | splat_test_init(sub, SPLAT_ATOMIC_TEST1_NAME, SPLAT_ATOMIC_TEST1_DESC, |
9f4c835a | 215 | SPLAT_ATOMIC_TEST1_ID, splat_atomic_test1); |
216 | ||
217 | return sub; | |
218 | } | |
219 | ||
220 | void | |
221 | splat_atomic_fini(splat_subsystem_t *sub) | |
222 | { | |
223 | ASSERT(sub); | |
9c9ad845 | 224 | splat_test_fini(sub, SPLAT_ATOMIC_TEST1_ID); |
9f4c835a | 225 | |
226 | kfree(sub); | |
227 | } | |
228 | ||
229 | int | |
230 | splat_atomic_id(void) { | |
231 | return SPLAT_SUBSYSTEM_ATOMIC; | |
232 | } |