Home | History | Annotate | Line # | Download | only in librumpuser
rumpuser_pth_dummy.c revision 1.10 
      1 /*	$NetBSD: rumpuser_pth_dummy.c,v 1.10 2013/04/27 16:32:58 pooka Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2009 Antti Kantee.  All Rights Reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     18  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 #include "rumpuser_port.h"
     29 
     30 #include <sys/cdefs.h>
     31 #if !defined(lint)
     32 __RCSID("$NetBSD: rumpuser_pth_dummy.c,v 1.10 2013/04/27 16:32:58 pooka Exp $");
     33 #endif /* !lint */
     34 
     35 #include <sys/time.h>
     36 
     37 #include <assert.h>
     38 #include <errno.h>
     39 #include <stdlib.h>
     40 #include <stdio.h>
     41 #include <string.h>
     42 #include <stdint.h>
     43 
     44 #include <rump/rumpuser.h>
     45 
     46 #include "rumpuser_int.h"
     47 
     48 static struct lwp *curlwp;
     49 
     50 struct rumpuser_cv {};
     51 
     52 struct rumpuser_mtx {
     53 	int v;
     54 	struct lwp *o;
     55 };
     56 
     57 struct rumpuser_rw {
     58 	int v;
     59 };
     60 
     61 struct rumpuser_mtx rumpuser_aio_mtx;
     62 struct rumpuser_cv rumpuser_aio_cv;
     63 int rumpuser_aio_head, rumpuser_aio_tail;
     64 struct rumpuser_aio rumpuser_aios[N_AIOS];
     65 
     66 void
     67 rumpuser__thrinit(void)
     68 {
     69 
     70 	return;
     71 }
     72 
     73 /*ARGSUSED*/
     74 void
     75 rumpuser_biothread(void *arg)
     76 {
     77 
     78 	fprintf(stderr, "rumpuser: threads not available\n");
     79 	abort();
     80 }
     81 
     82 /*ARGSUSED*/
     83 int
     84 rumpuser_thread_create(void *(*f)(void *), void *arg, const char *thrname,
     85 	int joinable, void **tptr)
     86 {
     87 
     88 	fprintf(stderr, "rumpuser: threads not available\n");
     89 	abort();
     90 	return 0;
     91 }
     92 
     93 void
     94 rumpuser_thread_exit(void)
     95 {
     96 
     97 	fprintf(stderr, "rumpuser: threads not available\n");
     98 	abort();
     99 }
    100 
    101 void
    102 rumpuser_mutex_init(struct rumpuser_mtx **mtx, int flgas)
    103 {
    104 
    105 	*mtx = calloc(1, sizeof(struct rumpuser_mtx));
    106 }
    107 
    108 void
    109 rumpuser_mutex_enter(struct rumpuser_mtx *mtx)
    110 {
    111 
    112 	mtx->v++;
    113 	mtx->o = curlwp;
    114 }
    115 
    116 void
    117 rumpuser_mutex_enter_nowrap(struct rumpuser_mtx *mtx)
    118 {
    119 
    120 	rumpuser_mutex_enter(mtx);
    121 }
    122 
    123 int
    124 rumpuser_mutex_tryenter(struct rumpuser_mtx *mtx)
    125 {
    126 
    127 	mtx->v++;
    128 	return 1;
    129 }
    130 
    131 void
    132 rumpuser_mutex_exit(struct rumpuser_mtx *mtx)
    133 {
    134 
    135 	assert(mtx->v > 0);
    136 	if (--mtx->v == 0)
    137 		mtx->o = NULL;
    138 }
    139 
    140 void
    141 rumpuser_mutex_destroy(struct rumpuser_mtx *mtx)
    142 {
    143 
    144 	free(mtx);
    145 }
    146 
    147 struct lwp *
    148 rumpuser_mutex_owner(struct rumpuser_mtx *mtx)
    149 {
    150 
    151 	return mtx->o;
    152 }
    153 
    154 void
    155 rumpuser_rw_init(struct rumpuser_rw **rw)
    156 {
    157 
    158 	*rw = calloc(1, sizeof(struct rumpuser_rw));
    159 }
    160 
    161 void
    162 rumpuser_rw_enter(struct rumpuser_rw *rw, int write)
    163 {
    164 
    165 	if (write) {
    166 		rw->v++;
    167 		assert(rw->v == 1);
    168 	} else {
    169 		assert(rw->v <= 0);
    170 		rw->v--;
    171 	}
    172 }
    173 
    174 int
    175 rumpuser_rw_tryenter(struct rumpuser_rw *rw, int write)
    176 {
    177 
    178 	rumpuser_rw_enter(rw, write);
    179 	return 1;
    180 }
    181 
    182 void
    183 rumpuser_rw_exit(struct rumpuser_rw *rw)
    184 {
    185 
    186 	if (rw->v > 0) {
    187 		assert(rw->v == 1);
    188 		rw->v--;
    189 	} else {
    190 		rw->v++;
    191 	}
    192 }
    193 
    194 void
    195 rumpuser_rw_destroy(struct rumpuser_rw *rw)
    196 {
    197 
    198 	free(rw);
    199 }
    200 
    201 int
    202 rumpuser_rw_held(struct rumpuser_rw *rw)
    203 {
    204 
    205 	return rw->v != 0;
    206 }
    207 
    208 int
    209 rumpuser_rw_rdheld(struct rumpuser_rw *rw)
    210 {
    211 
    212 	return rw->v < 0;
    213 }
    214 
    215 int
    216 rumpuser_rw_wrheld(struct rumpuser_rw *rw)
    217 {
    218 
    219 	return rw->v > 0;
    220 }
    221 
    222 /*ARGSUSED*/
    223 void
    224 rumpuser_cv_init(struct rumpuser_cv **cv)
    225 {
    226 
    227 }
    228 
    229 /*ARGSUSED*/
    230 void
    231 rumpuser_cv_destroy(struct rumpuser_cv *cv)
    232 {
    233 
    234 }
    235 
    236 /*ARGSUSED*/
    237 void
    238 rumpuser_cv_wait(struct rumpuser_cv *cv, struct rumpuser_mtx *mtx)
    239 {
    240 
    241 }
    242 
    243 /*ARGSUSED*/
    244 int
    245 rumpuser_cv_timedwait(struct rumpuser_cv *cv, struct rumpuser_mtx *mtx,
    246 	int64_t sec, int64_t nsec)
    247 {
    248 	struct timespec ts;
    249 
    250 	/*LINTED*/
    251 	ts.tv_sec = sec;
    252 	/*LINTED*/
    253 	ts.tv_nsec = nsec;
    254 
    255 	nanosleep(&ts, NULL);
    256 	return 0;
    257 }
    258 
    259 /*ARGSUSED*/
    260 void
    261 rumpuser_cv_signal(struct rumpuser_cv *cv)
    262 {
    263 
    264 }
    265 
    266 /*ARGSUSED*/
    267 void
    268 rumpuser_cv_broadcast(struct rumpuser_cv *cv)
    269 {
    270 
    271 }
    272 
    273 /*ARGSUSED*/
    274 int
    275 rumpuser_cv_has_waiters(struct rumpuser_cv *cv)
    276 {
    277 
    278 	return 0;
    279 }
    280 
    281 /*
    282  * curlwp
    283  */
    284 
    285 void
    286 rumpuser_set_curlwp(struct lwp *l)
    287 {
    288 
    289 	curlwp = l;
    290 }
    291 
    292 struct lwp *
    293 rumpuser_get_curlwp(void)
    294 {
    295 
    296 	return curlwp;
    297 }
    298