regress/sys/kern/priority_inheritance1/test_priority_inheritance1.c

   1 /*      $NetBSD: test_priority_inheritance1.c,v 1.1 2007/02/25 09:52:47 yamt Exp $      */
   2
   3 /*-
   4  * Copyright (c) 2007 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Andrew Doran.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: test_priority_inheritance1.c,v 1.1 2007/02/25 09:52:47 yamt Exp $");
  34
  35 #include <sys/param.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/systm.h>
  38 #include <sys/proc.h>
  39 #include <sys/kthread.h>
  40 #include <sys/kernel.h>
  41
  42 #define SECONDS         5
  43
  44 int     testcall(struct lwp *, void *, register_t *);
  45 void    dummy(void *);
  46 void    lowprio(void *);
  47 void    highprio(void *);
  48 void    thread_exit(int, int);
  49 void    thread_enter(int *, int);
  50
  51 kmutex_t        test_mutex;
  52 kcondvar_t      test_cv;
  53 bool            test_exit;
  54
  55 int             started;
  56 kcondvar_t      start_cv;
  57 int             exited;
  58 kcondvar_t      exit_cv;
  59
  60 void
  61 changepri(int prio)
  62 {
  63         struct lwp *l = curlwp;
  64
  65         lwp_lock(l);
  66         lwp_changepri(l, prio);
  67         lwp_unlock(l);
  68 }
  69
  70 void
  71 printpri(const char *msg)
  72 {
  73         struct lwp *l = curlwp;
  74
  75 #if 0
  76         printf("%s: %s: eprio=%d l_priority=%d l_usrpri=%d\n",
  77             l->l_proc->p_comm, msg, lwp_eprio(l), l->l_priority, l->l_usrpri);
  78 #else
  79         printf("%s: %s: l_priority=%d l_usrpri=%d\n",
  80             l->l_proc->p_comm, msg, l->l_priority, l->l_usrpri);
  81 #endif
  82 }
  83
  84 void
  85 thread_enter(int *nlocks, int prio)
  86 {
  87         struct lwp *l = curlwp;
  88
  89         KERNEL_UNLOCK_ALL(l, nlocks);
  90         changepri(prio);
  91         yield(); /* XXX */
  92         printpri("enter");
  93 }
  94
  95 void
  96 thread_exit(int nlocks, int prio)
  97 {
  98         struct lwp *l = curlwp;
  99
 100         mutex_enter(&test_mutex);
 101         exited++;
 102         cv_signal(&exit_cv);
 103         mutex_exit(&test_mutex);
 104
 105 #if 0
 106         if (lwp_eprio(l) != prio)
 107 #else
 108         if (l->l_priority != prio || l->l_usrpri != prio)
 109 #endif
 110                 printpri("ERROR: priority changed");
 111
 112         printpri("exit");
 113
 114         KERNEL_LOCK(nlocks, curlwp);
 115         kthread_exit(0);
 116 }
 117
 118 void
 119 dummy(void *cookie)
 120 {
 121         int count, nlocks;
 122         int prio = (int)cookie;
 123
 124         thread_enter(&nlocks, prio);
 125
 126         mutex_enter(&test_mutex);
 127         started++;
 128         cv_signal(&start_cv);
 129         mutex_exit(&test_mutex);
 130         while (!test_exit)
 131                 yield();
 132
 133         thread_exit(nlocks, prio);
 134 }
 135
 136 void
 137 lowprio(void *cookie)
 138 {
 139         struct lwp *l = curlwp;
 140         int count, nlocks;
 141         int prio = (int)cookie;
 142
 143         thread_enter(&nlocks, prio);
 144
 145         mutex_enter(&test_mutex);
 146         started++;
 147         cv_signal(&start_cv);
 148
 149         changepri(PUSER-1);
 150         kpause("test", false, hz, NULL);
 151
 152         printpri("have mutex");
 153         mutex_exit(&test_mutex);
 154         printpri("released mutex");
 155
 156         thread_exit(nlocks, PUSER-1);
 157 }
 158
 159 void
 160 highprio(void *cookie)
 161 {
 162         int count, nlocks;
 163         int prio = (int)cookie;
 164
 165         thread_enter(&nlocks, prio);
 166
 167         printf("highprio start\n");
 168         mutex_enter(&test_mutex);
 169         while (started < ncpu + 1)
 170                 cv_wait(&start_cv, &test_mutex);
 171         mutex_exit(&test_mutex);
 172         printf("highprio done\n");
 173
 174         test_exit = true;
 175
 176         thread_exit(nlocks, prio);
 177 }
 178
 179 int
 180 testcall(struct lwp *l, void *uap, register_t *retval)
 181 {
 182         void (*func)(void *);
 183         int i;
 184
 185         mutex_init(&test_mutex, MUTEX_DEFAULT, IPL_NONE);
 186         cv_init(&start_cv, "startcv");
 187         cv_init(&exit_cv, "exitcv");
 188         cv_init(&test_cv, "testcv");
 189
 190         printf("test: creating threads\n");
 191
 192         test_exit = false;
 193         started = exited = 0;
 194
 195         changepri(PUSER-30);
 196
 197         for (i = 0; i < ncpu; i++)
 198                 kthread_create1(dummy, (void *)(PUSER-10), NULL, "dummy-%d", i);
 199         mutex_enter(&test_mutex);
 200         while (started < ncpu)
 201                 cv_wait(&start_cv, &test_mutex);
 202         mutex_exit(&test_mutex);
 203
 204         kthread_create1(lowprio, (void *)(PUSER-20), NULL, "lowprio");
 205         i++;
 206         kthread_create1(highprio, (void *)(PUSER-20), NULL, "highprio");
 207         i++;
 208
 209         printf("test: sleeping\n");
 210         kpause("test", false, hz * SECONDS, NULL);
 211         printf("test: woken\n");
 212
 213         if (!test_exit)
 214                 printf("test: FAIL\n");
 215         test_exit = true;
 216         mutex_enter(&test_mutex);
 217         while (exited != i) {
 218                 cv_wait(&exit_cv, &test_mutex);
 219         }
 220         mutex_exit(&test_mutex);
 221
 222         printf("test: finished\n");
 223
 224         cv_destroy(&test_cv);
 225         mutex_destroy(&test_mutex);
 226
 227         return 0;
 228 }