5 #include <linux/module.h>
6 #include <linux/proc_fs.h>
7 #include <linux/sched.h>
8 #include <linux/timex.h>
9 #include <linux/kthread.h>
10 #include <linux/delay.h>
11 #include <linux/hardirq.h>
12 #include <linux/module.h>
13 #include <linux/percpu.h>
14 #include <linux/spinlock.h>
15 #include <asm/ptrace.h>
16 #include <linux/wbias-rwlock.h>
18 /* Test with no contention duration, in seconds */
19 #define SINGLE_WRITER_TEST_DURATION 10
20 #define SINGLE_READER_TEST_DURATION 10
21 #define MULTIPLE_READERS_TEST_DURATION 10
23 /* Test duration, in seconds */
24 #define TEST_DURATION 60
28 #define NR_TRYLOCK_WRITERS 1
29 #define NR_NPREADERS 2
30 #define NR_TRYLOCK_READERS 1
33 * 1 : test standard rwlock
34 * 0 : test wbiasrwlock
36 #define TEST_STD_RWLOCK 0
39 * 1 : test with thread and interrupt readers.
40 * 0 : test only with thread readers.
42 #define TEST_INTERRUPTS 1
45 #define NR_INTERRUPT_READERS 1
46 #define NR_TRYLOCK_INTERRUPT_READERS 1
48 #define NR_INTERRUPT_READERS 0
49 #define NR_TRYLOCK_INTERRUPT_READERS 0
53 * 1 : test with thread preemption readers.
54 * 0 : test only with non-preemptable thread readers.
56 #define TEST_PREEMPT 1
66 * Writer iteration delay, in us. 0 for busy loop. Caution : writers can
69 #define WRITER_DELAY 100
70 #define TRYLOCK_WRITER_DELAY 1000
73 * Number of iterations after which a trylock writer fails.
74 * -1 for infinite loop.
76 #define TRYLOCK_WRITERS_FAIL_ITER 100
78 /* Thread and interrupt reader delay, in ms */
79 #define THREAD_READER_DELAY 0 /* busy loop */
80 #define INTERRUPT_READER_DELAY 100
82 static int var
[NR_VARS
];
83 static struct task_struct
*preader_threads
[NR_PREADERS
];
84 static struct task_struct
*npreader_threads
[NR_NPREADERS
];
85 static struct task_struct
*trylock_reader_threads
[NR_TRYLOCK_READERS
];
86 static struct task_struct
*writer_threads
[NR_WRITERS
];
87 static struct task_struct
*trylock_writer_threads
[NR_TRYLOCK_WRITERS
];
88 static struct task_struct
*interrupt_reader
[NR_INTERRUPT_READERS
];
89 static struct task_struct
*trylock_interrupt_reader
[NR_TRYLOCK_INTERRUPT_READERS
];
93 static DEFINE_RWLOCK(std_rw_lock
);
95 #define wrap_read_lock() read_lock(&std_rw_lock)
96 #define wrap_read_trylock() read_trylock(&std_rw_lock)
97 #define wrap_read_unlock() read_unlock(&std_rw_lock)
99 #define wrap_read_lock_inatomic() read_lock(&std_rw_lock)
100 #define wrap_read_trylock_inatomic() read_trylock(&std_rw_lock)
101 #define wrap_read_unlock_inatomic() read_unlock(&std_rw_lock)
103 #define wrap_read_lock_irq() read_lock(&std_rw_lock)
104 #define wrap_read_trylock_irq() read_trylock(&std_rw_lock)
105 #define wrap_read_unlock_irq() read_unlock(&std_rw_lock)
107 #if (TEST_INTERRUPTS)
108 #define wrap_write_lock() write_lock_irq(&std_rw_lock)
109 #define wrap_write_unlock() write_unlock_irq(&std_rw_lock)
111 #define wrap_write_lock() write_lock(&std_rw_lock)
112 #define wrap_write_unlock() write_unlock(&std_rw_lock)
117 static DEFINE_WBIAS_RWLOCK(wbiasrwlock
);
119 #define wrap_read_lock() wbias_read_lock(&wbiasrwlock)
120 #define wrap_read_trylock() wbias_read_trylock(&wbiasrwlock)
121 #define wrap_read_unlock() wbias_read_unlock(&wbiasrwlock)
123 #define wrap_read_lock_inatomic() wbias_read_lock_inatomic(&wbiasrwlock)
124 #define wrap_read_trylock_inatomic() \
125 wbias_read_trylock_inatomic(&wbiasrwlock)
126 #define wrap_read_unlock_inatomic() \
127 wbias_read_unlock_inatomic(&wbiasrwlock)
129 #define wrap_read_lock_irq() wbias_read_lock_irq(&wbiasrwlock)
130 #define wrap_read_trylock_irq() wbias_read_trylock_irq(&wbiasrwlock)
131 #define wrap_read_unlock_irq() wbias_read_unlock_irq(&wbiasrwlock)
133 #if (TEST_INTERRUPTS)
134 #define wrap_write_lock() wbias_write_lock_irq(&wbiasrwlock)
135 #define wrap_write_unlock() wbias_write_unlock_irq(&wbiasrwlock)
136 #define wrap_write_trylock_else_subscribe() \
137 wbias_write_trylock_irq_else_subscribe(&wbiasrwlock)
138 #define wrap_write_trylock_subscribed() \
139 wbias_write_trylock_irq_subscribed(&wbiasrwlock)
142 #define wrap_write_lock() wbias_write_lock(&wbiasrwlock)
143 #define wrap_write_unlock() wbias_write_unlock(&wbiasrwlock)
144 #define wrap_write_trylock_else_subscribe() \
145 wbias_write_trylock_else_subscribe(&wbiasrwlock)
146 #define wrap_write_trylock_subscribed() \
147 wbias_write_trylock_subscribed(&wbiasrwlock)
149 #define wrap_write_lock() wbias_write_lock_atomic(&wbiasrwlock)
150 #define wrap_write_unlock() wbias_write_unlock_atomic(&wbiasrwlock)
151 #define wrap_write_trylock_else_subscribe() \
152 wbias_write_trylock_atomic_else_subscribe(&wbiasrwlock)
153 #define wrap_write_trylock_subscribed() \
154 wbias_write_trylock_atomic_subscribed(&wbiasrwlock)
160 static cycles_t cycles_calibration_min
,
161 cycles_calibration_avg
,
162 cycles_calibration_max
;
164 static inline cycles_t
calibrate_cycles(cycles_t cycles
)
166 return cycles
- cycles_calibration_avg
;
169 struct proc_dir_entry
*pentry
= NULL
;
171 static int p_or_np_reader_thread(const char *typename
,
172 void *data
, int preemptable
)
176 unsigned long iter
= 0;
177 cycles_t time1
, time2
, delay
, delaymax
= 0, delaymin
= ULLONG_MAX
,
180 printk("%s/%lu runnning\n", typename
, (unsigned long)data
);
186 time1
= get_cycles();
190 wrap_read_lock_inatomic();
195 time2
= get_cycles();
197 delay
= time2
- time1
;
198 delaymax
= max(delaymax
, delay
);
199 delaymin
= min(delaymin
, delay
);
202 for (i
= 1; i
< NR_VARS
; i
++) {
206 "Unequal cur %d/prev %d at i %d, iter %lu "
207 "in thread\n", cur
, prev
, i
, iter
);
211 wrap_read_unlock_inatomic();
216 if (THREAD_READER_DELAY
)
217 msleep(THREAD_READER_DELAY
);
218 } while (!kthread_should_stop());
220 printk("%s/%lu iterations : %lu", typename
,
221 (unsigned long)data
, iter
);
224 printk("%s/%lu iterations : %lu, "
225 "lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
227 (unsigned long)data
, iter
,
228 calibrate_cycles(delaymin
),
229 calibrate_cycles(delayavg
),
230 calibrate_cycles(delaymax
));
235 static int preader_thread(void *data
)
237 return p_or_np_reader_thread("preader_thread", data
, 1);
240 static int npreader_thread(void *data
)
242 return p_or_np_reader_thread("npreader_thread", data
, 0);
245 static int trylock_reader_thread(void *data
)
249 unsigned long iter
= 0, success_iter
= 0;
251 printk("trylock_reader_thread/%lu runnning\n", (unsigned long)data
);
253 while (!wrap_read_trylock())
257 for (i
= 1; i
< NR_VARS
; i
++) {
261 "Unequal cur %d/prev %d at i %d, iter %lu "
262 "in thread\n", cur
, prev
, i
, iter
);
265 if (THREAD_READER_DELAY
)
266 msleep(THREAD_READER_DELAY
);
267 } while (!kthread_should_stop());
268 printk("trylock_reader_thread/%lu iterations : %lu, "
269 "successful iterations : %lu\n",
270 (unsigned long)data
, iter
, success_iter
);
274 DEFINE_PER_CPU(cycles_t
, int_delaymin
);
275 DEFINE_PER_CPU(cycles_t
, int_delayavg
);
276 DEFINE_PER_CPU(cycles_t
, int_delaymax
);
277 DEFINE_PER_CPU(cycles_t
, int_ipi_nr
);
279 static void interrupt_reader_ipi(void *data
)
283 cycles_t time1
, time2
;
284 cycles_t
*delaymax
, *delaymin
, *delayavg
, *ipi_nr
, delay
;
287 * Skip the ipi caller, not in irq context.
292 delaymax
= &per_cpu(int_delaymax
, smp_processor_id());
293 delaymin
= &per_cpu(int_delaymin
, smp_processor_id());
294 delayavg
= &per_cpu(int_delayavg
, smp_processor_id());
295 ipi_nr
= &per_cpu(int_ipi_nr
, smp_processor_id());
298 time1
= get_cycles();
301 wrap_read_lock_irq();
304 time2
= get_cycles();
306 delay
= time2
- time1
;
307 *delaymax
= max(*delaymax
, delay
);
308 *delaymin
= min(*delaymin
, delay
);
312 for (i
= 1; i
< NR_VARS
; i
++) {
316 "Unequal cur %d/prev %d at i %d in interrupt\n",
319 wrap_read_unlock_irq();
322 DEFINE_PER_CPU(unsigned long, trylock_int_iter
);
323 DEFINE_PER_CPU(unsigned long, trylock_int_success
);
325 static void trylock_interrupt_reader_ipi(void *data
)
331 * Skip the ipi caller, not in irq context.
336 per_cpu(trylock_int_iter
, smp_processor_id())++;
337 while (!wrap_read_trylock_irq())
338 per_cpu(trylock_int_iter
, smp_processor_id())++;
339 per_cpu(trylock_int_success
, smp_processor_id())++;
341 for (i
= 1; i
< NR_VARS
; i
++) {
345 "Unequal cur %d/prev %d at i %d in interrupt\n",
348 wrap_read_unlock_irq();
352 static int interrupt_reader_thread(void *data
)
354 unsigned long iter
= 0;
357 for_each_online_cpu(i
) {
358 per_cpu(int_delaymax
, i
) = 0;
359 per_cpu(int_delaymin
, i
) = ULLONG_MAX
;
360 per_cpu(int_delayavg
, i
) = 0;
361 per_cpu(int_ipi_nr
, i
) = 0;
365 on_each_cpu(interrupt_reader_ipi
, NULL
, 0);
366 if (INTERRUPT_READER_DELAY
)
367 msleep(INTERRUPT_READER_DELAY
);
368 } while (!kthread_should_stop());
369 printk("interrupt_reader_thread/%lu iterations : %lu\n",
370 (unsigned long)data
, iter
);
371 for_each_online_cpu(i
) {
372 if (!per_cpu(int_ipi_nr
, i
))
374 per_cpu(int_delayavg
, i
) /= per_cpu(int_ipi_nr
, i
);
375 printk("interrupt readers on CPU %i, "
376 "lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
378 calibrate_cycles(per_cpu(int_delaymin
, i
)),
379 calibrate_cycles(per_cpu(int_delayavg
, i
)),
380 calibrate_cycles(per_cpu(int_delaymax
, i
)));
385 static int trylock_interrupt_reader_thread(void *data
)
387 unsigned long iter
= 0;
392 on_each_cpu(trylock_interrupt_reader_ipi
, NULL
, 0);
393 if (INTERRUPT_READER_DELAY
)
394 msleep(INTERRUPT_READER_DELAY
);
395 } while (!kthread_should_stop());
396 printk("trylock_interrupt_reader_thread/%lu iterations : %lu\n",
397 (unsigned long)data
, iter
);
398 for_each_online_cpu(i
) {
399 printk("trylock interrupt readers on CPU %i, "
401 "successful iterations : %lu\n",
402 i
, per_cpu(trylock_int_iter
, i
),
403 per_cpu(trylock_int_success
, i
));
404 per_cpu(trylock_int_iter
, i
) = 0;
405 per_cpu(trylock_int_success
, i
) = 0;
410 static int writer_thread(void *data
)
414 unsigned long iter
= 0;
415 cycles_t time1
, time2
, delay
, delaymax
= 0, delaymin
= ULLONG_MAX
,
418 printk("writer_thread/%lu runnning\n", (unsigned long)data
);
421 //preempt_disable(); /* for get_cycles accuracy */
423 time1
= get_cycles();
429 time2
= get_cycles();
431 delay
= time2
- time1
;
432 delaymax
= max(delaymax
, delay
);
433 delaymin
= min(delaymin
, delay
);
435 new = (int)get_cycles();
436 for (i
= 0; i
< NR_VARS
; i
++) {
442 //preempt_enable(); /* for get_cycles accuracy */
443 if (WRITER_DELAY
> 0)
444 udelay(WRITER_DELAY
);
445 } while (!kthread_should_stop());
447 printk("writer_thread/%lu iterations : %lu, "
448 "lock delay [min,avg,max] %llu,%llu,%llu cycles\n",
449 (unsigned long)data
, iter
,
450 calibrate_cycles(delaymin
),
451 calibrate_cycles(delayavg
),
452 calibrate_cycles(delaymax
));
456 #if (TEST_STD_RWLOCK)
457 static int trylock_writer_thread(void *data
)
461 unsigned long iter
= 0, success
= 0, fail
= 0;
463 printk("trylock_writer_thread/%lu runnning\n", (unsigned long)data
);
465 #if (TEST_INTERRUPTS)
466 /* std write trylock cannot disable interrupts. */
470 #if (TRYLOCK_WRITERS_FAIL_ITER == -1)
473 if (write_trylock(&std_rw_lock
))
477 for (i
= 0; i
< TRYLOCK_WRITERS_FAIL_ITER
; i
++) {
479 if (write_trylock(&std_rw_lock
))
484 #if (TEST_INTERRUPTS)
490 new = (int)get_cycles();
491 for (i
= 0; i
< NR_VARS
; i
++) {
494 #if (TEST_INTERRUPTS)
495 write_unlock_irq(&std_rw_lock
);
497 write_unlock(&std_rw_lock
);
500 if (TRYLOCK_WRITER_DELAY
> 0)
501 udelay(TRYLOCK_WRITER_DELAY
);
502 } while (!kthread_should_stop());
503 printk("trylock_writer_thread/%lu iterations : "
504 "[try,success,fail after %d try], "
506 (unsigned long)data
, TRYLOCK_WRITERS_FAIL_ITER
,
507 iter
, success
, fail
);
511 #else /* !TEST_STD_RWLOCK */
513 static int trylock_writer_thread(void *data
)
517 unsigned long iter
= 0, success
= 0, fail
= 0;
519 printk("trylock_writer_thread/%lu runnning\n", (unsigned long)data
);
522 if (wrap_write_trylock_else_subscribe())
525 #if (TRYLOCK_WRITERS_FAIL_ITER == -1)
528 if (wrap_write_trylock_subscribed())
532 for (i
= 0; i
< TRYLOCK_WRITERS_FAIL_ITER
- 1; i
++) {
534 if (wrap_write_trylock_subscribed())
539 wbias_write_unsubscribe(&wbiasrwlock
);
543 new = (int)get_cycles();
544 for (i
= 0; i
< NR_VARS
; i
++) {
549 if (TRYLOCK_WRITER_DELAY
> 0)
550 udelay(TRYLOCK_WRITER_DELAY
);
551 } while (!kthread_should_stop());
552 printk("trylock_writer_thread/%lu iterations : "
553 "[try,success,fail after %d try], "
555 (unsigned long)data
, TRYLOCK_WRITERS_FAIL_ITER
,
556 iter
, success
, fail
);
560 #endif /* TEST_STD_RWLOCK */
562 static void wbias_rwlock_create(void)
566 for (i
= 0; i
< NR_PREADERS
; i
++) {
567 printk("starting preemptable reader thread %lu\n", i
);
568 preader_threads
[i
] = kthread_run(preader_thread
, (void *)i
,
569 "wbiasrwlock_preader");
570 BUG_ON(!preader_threads
[i
]);
573 for (i
= 0; i
< NR_NPREADERS
; i
++) {
574 printk("starting non-preemptable reader thread %lu\n", i
);
575 npreader_threads
[i
] = kthread_run(npreader_thread
, (void *)i
,
576 "wbiasrwlock_npreader");
577 BUG_ON(!npreader_threads
[i
]);
580 for (i
= 0; i
< NR_TRYLOCK_READERS
; i
++) {
581 printk("starting trylock reader thread %lu\n", i
);
582 trylock_reader_threads
[i
] = kthread_run(trylock_reader_thread
,
583 (void *)i
, "wbiasrwlock_trylock_reader");
584 BUG_ON(!trylock_reader_threads
[i
]);
586 for (i
= 0; i
< NR_INTERRUPT_READERS
; i
++) {
587 printk("starting interrupt reader %lu\n", i
);
588 interrupt_reader
[i
] = kthread_run(interrupt_reader_thread
,
590 "wbiasrwlock_interrupt_reader");
592 for (i
= 0; i
< NR_TRYLOCK_INTERRUPT_READERS
; i
++) {
593 printk("starting trylock interrupt reader %lu\n", i
);
594 trylock_interrupt_reader
[i
] =
595 kthread_run(trylock_interrupt_reader_thread
,
596 (void *)i
, "wbiasrwlock_trylock_interrupt_reader");
598 for (i
= 0; i
< NR_WRITERS
; i
++) {
599 printk("starting writer thread %lu\n", i
);
600 writer_threads
[i
] = kthread_run(writer_thread
, (void *)i
,
601 "wbiasrwlock_writer");
602 BUG_ON(!writer_threads
[i
]);
604 for (i
= 0; i
< NR_TRYLOCK_WRITERS
; i
++) {
605 printk("starting trylock writer thread %lu\n", i
);
606 trylock_writer_threads
[i
] = kthread_run(trylock_writer_thread
,
607 (void *)i
, "wbiasrwlock_trylock_writer");
608 BUG_ON(!trylock_writer_threads
[i
]);
612 static void wbias_rwlock_stop(void)
616 for (i
= 0; i
< NR_WRITERS
; i
++)
617 kthread_stop(writer_threads
[i
]);
618 for (i
= 0; i
< NR_TRYLOCK_WRITERS
; i
++)
619 kthread_stop(trylock_writer_threads
[i
]);
620 for (i
= 0; i
< NR_NPREADERS
; i
++)
621 kthread_stop(npreader_threads
[i
]);
622 for (i
= 0; i
< NR_PREADERS
; i
++)
623 kthread_stop(preader_threads
[i
]);
624 for (i
= 0; i
< NR_TRYLOCK_READERS
; i
++)
625 kthread_stop(trylock_reader_threads
[i
]);
626 for (i
= 0; i
< NR_INTERRUPT_READERS
; i
++)
627 kthread_stop(interrupt_reader
[i
]);
628 for (i
= 0; i
< NR_TRYLOCK_INTERRUPT_READERS
; i
++)
629 kthread_stop(trylock_interrupt_reader
[i
]);
633 static void perform_test(const char *name
, void (*callback
)(void))
635 printk("%s\n", name
);
639 static int my_open(struct inode
*inode
, struct file
*file
)
642 cycles_t time1
, time2
, delay
;
644 printk("** get_cycles calibration **\n");
645 cycles_calibration_min
= ULLONG_MAX
;
646 cycles_calibration_avg
= 0;
647 cycles_calibration_max
= 0;
650 for (i
= 0; i
< 10; i
++) {
652 time1
= get_cycles();
655 time2
= get_cycles();
657 delay
= time2
- time1
;
658 cycles_calibration_min
= min(cycles_calibration_min
, delay
);
659 cycles_calibration_avg
+= delay
;
660 cycles_calibration_max
= max(cycles_calibration_max
, delay
);
662 cycles_calibration_avg
/= 10;
665 printk("get_cycles takes [min,avg,max] %llu,%llu,%llu cycles, "
666 "results calibrated on avg\n",
667 cycles_calibration_min
,
668 cycles_calibration_avg
,
669 cycles_calibration_max
);
672 printk("** Single writer test, no contention **\n");
673 wbias_rwlock_profile_latency_reset();
674 writer_threads
[0] = kthread_run(writer_thread
, (void *)0,
675 "wbiasrwlock_writer");
676 BUG_ON(!writer_threads
[0]);
677 ssleep(SINGLE_WRITER_TEST_DURATION
);
678 kthread_stop(writer_threads
[0]);
681 wbias_rwlock_profile_latency_print();
683 printk("** Single trylock writer test, no contention **\n");
684 wbias_rwlock_profile_latency_reset();
685 trylock_writer_threads
[0] = kthread_run(trylock_writer_thread
,
687 "trylock_wbiasrwlock_writer");
688 BUG_ON(!trylock_writer_threads
[0]);
689 ssleep(SINGLE_WRITER_TEST_DURATION
);
690 kthread_stop(trylock_writer_threads
[0]);
693 wbias_rwlock_profile_latency_print();
695 printk("** Single preemptable reader test, no contention **\n");
696 wbias_rwlock_profile_latency_reset();
697 preader_threads
[0] = kthread_run(preader_thread
, (void *)0,
698 "wbiasrwlock_preader");
699 BUG_ON(!preader_threads
[0]);
700 ssleep(SINGLE_READER_TEST_DURATION
);
701 kthread_stop(preader_threads
[0]);
704 wbias_rwlock_profile_latency_print();
706 printk("** Single non-preemptable reader test, no contention **\n");
707 wbias_rwlock_profile_latency_reset();
708 npreader_threads
[0] = kthread_run(npreader_thread
, (void *)0,
709 "wbiasrwlock_npreader");
710 BUG_ON(!npreader_threads
[0]);
711 ssleep(SINGLE_READER_TEST_DURATION
);
712 kthread_stop(npreader_threads
[0]);
715 wbias_rwlock_profile_latency_print();
717 printk("** Multiple p/non-p readers test, no contention **\n");
718 wbias_rwlock_profile_latency_reset();
719 for (i
= 0; i
< NR_PREADERS
; i
++) {
720 printk("starting preader thread %lu\n", i
);
721 preader_threads
[i
] = kthread_run(preader_thread
, (void *)i
,
722 "wbiasrwlock_preader");
723 BUG_ON(!preader_threads
[i
]);
725 for (i
= 0; i
< NR_NPREADERS
; i
++) {
726 printk("starting npreader thread %lu\n", i
);
727 npreader_threads
[i
] = kthread_run(npreader_thread
, (void *)i
,
728 "wbiasrwlock_npreader");
729 BUG_ON(!npreader_threads
[i
]);
731 ssleep(SINGLE_READER_TEST_DURATION
);
732 for (i
= 0; i
< NR_NPREADERS
; i
++)
733 kthread_stop(npreader_threads
[i
]);
734 for (i
= 0; i
< NR_PREADERS
; i
++)
735 kthread_stop(preader_threads
[i
]);
738 wbias_rwlock_profile_latency_print();
740 printk("** High contention test **\n");
741 wbias_rwlock_profile_latency_reset();
742 perform_test("wbias-rwlock-create", wbias_rwlock_create
);
743 ssleep(TEST_DURATION
);
744 perform_test("wbias-rwlock-stop", wbias_rwlock_stop
);
746 wbias_rwlock_profile_latency_print();
752 static struct file_operations my_operations
= {
756 int init_module(void)
758 pentry
= create_proc_entry("testwbiasrwlock", 0444, NULL
);
760 pentry
->proc_fops
= &my_operations
;
762 printk("PTHREAD_ROFFSET : %016lX\n", PTHREAD_ROFFSET
);
763 printk("PTHREAD_RMASK : %016lX\n", PTHREAD_RMASK
);
764 printk("NPTHREAD_ROFFSET : %016lX\n", NPTHREAD_ROFFSET
);
765 printk("NPTHREAD_RMASK : %016lX\n", NPTHREAD_RMASK
);
766 printk("SOFTIRQ_ROFFSET : %016lX\n", SOFTIRQ_ROFFSET
);
767 printk("SOFTIRQ_RMASK : %016lX\n", SOFTIRQ_RMASK
);
768 printk("HARDIRQ_ROFFSET : %016lX\n", HARDIRQ_ROFFSET
);
769 printk("HARDIRQ_RMASK : %016lX\n", HARDIRQ_RMASK
);
770 printk("PTHREAD_WOFFSET : %016lX\n", PTHREAD_WOFFSET
);
771 printk("PTHREAD_WMASK : %016lX\n", PTHREAD_WMASK
);
772 printk("NPTHREAD_WOFFSET : %016lX\n", NPTHREAD_WOFFSET
);
773 printk("NPTHREAD_WMASK : %016lX\n", NPTHREAD_WMASK
);
774 printk("WRITER_MUTEX : %016lX\n", WRITER_MUTEX
);
775 printk("SOFTIRQ_WMASK : %016lX\n", SOFTIRQ_WMASK
);
776 printk("HARDIRQ_WMASK : %016lX\n", HARDIRQ_WMASK
);
781 void cleanup_module(void)
783 remove_proc_entry("testwbiasrwlock", NULL
);
786 MODULE_LICENSE("GPL");
787 MODULE_AUTHOR("Mathieu Desnoyers");
788 MODULE_DESCRIPTION("wbias rwlock test");