aboutsummaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
authorBjoern Brandenburg <bbb@mpi-sws.org>2014-03-19 09:06:44 -0400
committerBjoern Brandenburg <bbb@mpi-sws.org>2014-03-19 09:06:44 -0400
commit16cb0a3245a738633e3e21432386631f6cf0c202 (patch)
treea3d6f84eb56c7c2e7985da3fc946b7301d5a139f /tests
parent5eea6c90c3f71b94ac83c021d783b81dadfc44dd (diff)
Add test cases for exiting/mode-changing lock holders
This crashes old versions of the kernel. Kernel patches fixing the various panics have been merged into the kernel staging tree.
Diffstat (limited to 'tests')
-rw-r--r--tests/locks.c169
-rw-r--r--tests/pcp.c252
2 files changed, 421 insertions, 0 deletions
diff --git a/tests/locks.c b/tests/locks.c
index c3eba4e..bc35a8e 100644
--- a/tests/locks.c
+++ b/tests/locks.c
@@ -1,6 +1,7 @@
1#include <fcntl.h> 1#include <fcntl.h>
2#include <unistd.h> 2#include <unistd.h>
3#include <stdio.h> 3#include <stdio.h>
4#include <sys/wait.h> /* for waitpid() */
4 5
5#include "tests.h" 6#include "tests.h"
6#include "litmus.h" 7#include "litmus.h"
@@ -108,3 +109,171 @@ TESTCASE(lock_fmlp, PSN_EDF | GSN_EDF | P_FP,
108 109
109 SYSCALL( remove(".fmlp_locks") ); 110 SYSCALL( remove(".fmlp_locks") );
110} 111}
112
113TESTCASE(srp_lock_mode_change, P_FP | PSN_EDF,
114 "SRP task becomes non-RT task while holding lock")
115{
116 int fd, od;
117
118 int child, status;
119
120 struct rt_task params;
121 init_rt_task_param(&params);
122 params.cpu = 0;
123 params.exec_cost = ms2ns(10000);
124 params.period = ms2ns(100000);
125 params.relative_deadline = params.period;
126
127 SYSCALL( fd = open(".locks", O_RDONLY | O_CREAT, S_IRUSR) );
128
129
130 child = FORK_TASK(
131 params.priority = LITMUS_LOWEST_PRIORITY;
132 SYSCALL( set_rt_task_param(gettid(), &params) );
133 SYSCALL( be_migrate_to_cpu(params.cpu) );
134 SYSCALL( task_mode(LITMUS_RT_TASK) );
135
136 SYSCALL( od = open_srp_sem(fd, 0) );
137
138 SYSCALL( litmus_lock(od) );
139
140 SYSCALL( task_mode(BACKGROUND_TASK) );
141
142 SYSCALL( litmus_unlock(od) );
143
144 SYSCALL( od_close(od) );
145
146 exit(0);
147 );
148
149 SYSCALL( waitpid(child, &status, 0) );
150 ASSERT( WIFEXITED(status) );
151 ASSERT( WEXITSTATUS(status) == 0 );
152
153 SYSCALL( close(fd) );
154
155 SYSCALL( remove(".locks") );
156}
157
158TESTCASE(fmlp_lock_mode_change, P_FP | PSN_EDF | GSN_EDF,
159 "FMLP task becomes non-RT task while holding lock")
160{
161 int fd, od;
162
163 int child, status;
164
165 struct rt_task params;
166 init_rt_task_param(&params);
167 params.cpu = 0;
168 params.exec_cost = ms2ns(10000);
169 params.period = ms2ns(100000);
170 params.relative_deadline = params.period;
171
172 SYSCALL( fd = open(".locks", O_RDONLY | O_CREAT, S_IRUSR) );
173
174
175 child = FORK_TASK(
176 params.priority = LITMUS_LOWEST_PRIORITY;
177 SYSCALL( set_rt_task_param(gettid(), &params) );
178 SYSCALL( be_migrate_to_cpu(params.cpu) );
179 SYSCALL( task_mode(LITMUS_RT_TASK) );
180
181 SYSCALL( od = open_fmlp_sem(fd, 0) );
182
183 SYSCALL( litmus_lock(od) );
184
185 SYSCALL( task_mode(BACKGROUND_TASK) );
186
187 SYSCALL( litmus_unlock(od) );
188
189 SYSCALL( od_close(od) );
190
191 exit(0);
192 );
193
194 SYSCALL( waitpid(child, &status, 0) );
195 ASSERT( WIFEXITED(status) );
196 ASSERT( WEXITSTATUS(status) == 0 );
197
198 SYSCALL( close(fd) );
199
200 SYSCALL( remove(".locks") );
201}
202
203TESTCASE(srp_lock_teardown, P_FP | PSN_EDF,
204 "SRP task exits while holding lock")
205{
206 int fd, od;
207
208 int child, status;
209
210 struct rt_task params;
211 init_rt_task_param(&params);
212 params.cpu = 0;
213 params.exec_cost = ms2ns(10000);
214 params.period = ms2ns(100000);
215 params.relative_deadline = params.period;
216
217 SYSCALL( fd = open(".locks", O_RDONLY | O_CREAT, S_IRUSR) );
218
219 exit(0);
220
221 child = FORK_TASK(
222 params.priority = LITMUS_LOWEST_PRIORITY;
223 SYSCALL( set_rt_task_param(gettid(), &params) );
224 SYSCALL( be_migrate_to_cpu(params.cpu) );
225 SYSCALL( task_mode(LITMUS_RT_TASK) );
226
227 SYSCALL( od = open_srp_sem(fd, 0) );
228
229 SYSCALL( litmus_lock(od) );
230 exit(123);
231 );
232
233 SYSCALL( waitpid(child, &status, 0) );
234 ASSERT( WIFEXITED(status) );
235 ASSERT( WEXITSTATUS(status) == 123 );
236
237 SYSCALL( close(fd) );
238
239 SYSCALL( remove(".locks") );
240}
241
242TESTCASE(fmlp_lock_teardown, P_FP | PSN_EDF | GSN_EDF,
243 "FMLP task exits while holding lock")
244{
245 int fd, od;
246
247 int child, status;
248
249 struct rt_task params;
250 init_rt_task_param(&params);
251 params.cpu = 0;
252 params.exec_cost = ms2ns(10000);
253 params.period = ms2ns(100000);
254 params.relative_deadline = params.period;
255
256 SYSCALL( fd = open(".locks", O_RDONLY | O_CREAT, S_IRUSR) );
257
258 exit(0);
259
260 child = FORK_TASK(
261 params.priority = LITMUS_LOWEST_PRIORITY;
262 SYSCALL( set_rt_task_param(gettid(), &params) );
263 SYSCALL( be_migrate_to_cpu(params.cpu) );
264 SYSCALL( task_mode(LITMUS_RT_TASK) );
265
266 SYSCALL( od = open_fmlp_sem(fd, 0) );
267
268 SYSCALL( litmus_lock(od) );
269 exit(123);
270 );
271
272 SYSCALL( waitpid(child, &status, 0) );
273 ASSERT( WIFEXITED(status) );
274 ASSERT( WEXITSTATUS(status) == 123 );
275
276 SYSCALL( close(fd) );
277
278 SYSCALL( remove(".locks") );
279}
diff --git a/tests/pcp.c b/tests/pcp.c
index ed1920a..0b95a23 100644
--- a/tests/pcp.c
+++ b/tests/pcp.c
@@ -432,3 +432,255 @@ TESTCASE(lock_mpcp, P_FP,
432 432
433 SYSCALL( remove(".pcp_locks") ); 433 SYSCALL( remove(".pcp_locks") );
434} 434}
435
436TESTCASE(pcp_lock_mode_change, P_FP,
437 "PCP task becomes non-RT task while holding lock")
438{
439 int fd, od, cpu = 0;
440
441 int child, status;
442
443 struct rt_task params;
444 init_rt_task_param(&params);
445 params.cpu = 0;
446 params.exec_cost = ms2ns(10000);
447 params.period = ms2ns(100000);
448 params.relative_deadline = params.period;
449
450 SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
451
452
453 child = FORK_TASK(
454 params.priority = LITMUS_LOWEST_PRIORITY;
455 SYSCALL( set_rt_task_param(gettid(), &params) );
456 SYSCALL( be_migrate_to_cpu(params.cpu) );
457 SYSCALL( task_mode(LITMUS_RT_TASK) );
458
459 SYSCALL( od = open_pcp_sem(fd, 0, cpu) );
460
461 SYSCALL( litmus_lock(od) );
462
463 SYSCALL( task_mode(BACKGROUND_TASK) );
464
465 SYSCALL( litmus_unlock(od) );
466
467 SYSCALL( od_close(od) );
468
469 exit(0);
470 );
471
472 SYSCALL( waitpid(child, &status, 0) );
473 ASSERT( WIFEXITED(status) );
474 ASSERT( WEXITSTATUS(status) == 0 );
475
476 SYSCALL( close(fd) );
477
478 SYSCALL( remove(".pcp_locks") );
479}
480
481TESTCASE(mpcp_lock_mode_change, P_FP,
482 "MPCP task becomes non-RT task while holding lock")
483{
484 int fd, od;
485
486 int child, status;
487
488 struct rt_task params;
489 init_rt_task_param(&params);
490 params.cpu = 0;
491 params.exec_cost = ms2ns(10000);
492 params.period = ms2ns(100000);
493 params.relative_deadline = params.period;
494
495 SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
496
497
498 child = FORK_TASK(
499 params.priority = LITMUS_LOWEST_PRIORITY;
500 SYSCALL( set_rt_task_param(gettid(), &params) );
501 SYSCALL( be_migrate_to_cpu(params.cpu) );
502 SYSCALL( task_mode(LITMUS_RT_TASK) );
503
504 SYSCALL( od = open_mpcp_sem(fd, 0) );
505
506 SYSCALL( litmus_lock(od) );
507
508 SYSCALL( task_mode(BACKGROUND_TASK) );
509
510 SYSCALL( litmus_unlock(od) );
511
512 SYSCALL( od_close(od) );
513
514 exit(0);
515 );
516
517 SYSCALL( waitpid(child, &status, 0) );
518 ASSERT( WIFEXITED(status) );
519 ASSERT( WEXITSTATUS(status) == 0 );
520
521 SYSCALL( close(fd) );
522
523 SYSCALL( remove(".pcp_locks") );
524}
525
526TESTCASE(dpcp_lock_mode_change, P_FP,
527 "DPCP task becomes non-RT task while holding lock")
528{
529 int fd, od, cpu = 0;
530
531 int child, status;
532
533 struct rt_task params;
534 init_rt_task_param(&params);
535 params.cpu = 1;
536 params.exec_cost = ms2ns(10000);
537 params.period = ms2ns(100000);
538 params.relative_deadline = params.period;
539
540 SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
541
542
543 child = FORK_TASK(
544 params.priority = LITMUS_LOWEST_PRIORITY;
545 SYSCALL( set_rt_task_param(gettid(), &params) );
546 SYSCALL( be_migrate_to_cpu(params.cpu) );
547 SYSCALL( task_mode(LITMUS_RT_TASK) );
548
549 SYSCALL( od = open_dpcp_sem(fd, 0, cpu) );
550
551 SYSCALL( litmus_lock(od) );
552
553 SYSCALL( task_mode(BACKGROUND_TASK) );
554
555 SYSCALL( litmus_unlock(od) );
556
557 SYSCALL( od_close(od) );
558
559 exit(0);
560 );
561
562 SYSCALL( waitpid(child, &status, 0) );
563 ASSERT( WIFEXITED(status) );
564 ASSERT( WEXITSTATUS(status) == 0 );
565
566 SYSCALL( close(fd) );
567
568 SYSCALL( remove(".pcp_locks") );
569}
570
571TESTCASE(pcp_lock_teardown, P_FP,
572 "PCP task exits while holding lock")
573{
574 int fd, od, cpu = 0;
575
576 int child, status;
577
578 struct rt_task params;
579 init_rt_task_param(&params);
580 params.cpu = 0;
581 params.exec_cost = ms2ns(10000);
582 params.period = ms2ns(100000);
583 params.relative_deadline = params.period;
584
585 SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
586
587 exit(0);
588
589 child = FORK_TASK(
590 params.priority = LITMUS_LOWEST_PRIORITY;
591 SYSCALL( set_rt_task_param(gettid(), &params) );
592 SYSCALL( be_migrate_to_cpu(params.cpu) );
593 SYSCALL( task_mode(LITMUS_RT_TASK) );
594
595 SYSCALL( od = open_pcp_sem(fd, 0, cpu) );
596
597 SYSCALL( litmus_lock(od) );
598 exit(123);
599 );
600
601 SYSCALL( waitpid(child, &status, 0) );
602 ASSERT( WIFEXITED(status) );
603 ASSERT( WEXITSTATUS(status) == 123 );
604
605 SYSCALL( close(fd) );
606
607 SYSCALL( remove(".pcp_locks") );
608}
609
610TESTCASE(dpcp_lock_teardown, P_FP,
611 "DPCP task exits while holding lock")
612{
613 int fd, od, cpu = 0;
614
615 int child, status;
616
617 struct rt_task params;
618 init_rt_task_param(&params);
619 params.cpu = 1;
620 params.exec_cost = ms2ns(10000);
621 params.period = ms2ns(100000);
622 params.relative_deadline = params.period;
623
624 SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
625
626 exit(0);
627
628 child = FORK_TASK(
629 params.priority = LITMUS_LOWEST_PRIORITY;
630 SYSCALL( set_rt_task_param(gettid(), &params) );
631 SYSCALL( be_migrate_to_cpu(params.cpu) );
632 SYSCALL( task_mode(LITMUS_RT_TASK) );
633
634 SYSCALL( od = open_dpcp_sem(fd, 0, cpu) );
635
636 SYSCALL( litmus_lock(od) );
637 exit(123);
638 );
639
640 SYSCALL( waitpid(child, &status, 0) );
641 ASSERT( WIFEXITED(status) );
642 ASSERT( WEXITSTATUS(status) == 123 );
643
644 SYSCALL( close(fd) );
645
646 SYSCALL( remove(".pcp_locks") );
647}
648
649TESTCASE(mpcp_lock_teardown, P_FP,
650 "MPCP task exits while holding lock")
651{
652 int fd, od;
653
654 int child, status;
655
656 struct rt_task params;
657 init_rt_task_param(&params);
658 params.cpu = 0;
659 params.exec_cost = ms2ns(10000);
660 params.period = ms2ns(100000);
661 params.relative_deadline = params.period;
662
663 SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
664
665 exit(0);
666
667 child = FORK_TASK(
668 params.priority = LITMUS_LOWEST_PRIORITY;
669 SYSCALL( set_rt_task_param(gettid(), &params) );
670 SYSCALL( be_migrate_to_cpu(params.cpu) );
671 SYSCALL( task_mode(LITMUS_RT_TASK) );
672
673 SYSCALL( od = open_mpcp_sem(fd, 0) );
674
675 SYSCALL( litmus_lock(od) );
676 exit(123);
677 );
678
679 SYSCALL( waitpid(child, &status, 0) );
680 ASSERT( WIFEXITED(status) );
681 ASSERT( WEXITSTATUS(status) == 123 );
682
683 SYSCALL( close(fd) );
684
685 SYSCALL( remove(".pcp_locks") );
686}
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-25 16:08:10 -0400