1 /* $NetBSD: emul.c,v 1.185 2017/11/21 15:22:06 ozaki-r Exp $ */ 2 3 /* 4 * Copyright (c) 2007-2011 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 <sys/cdefs.h> 29 __KERNEL_RCSID(0, "$NetBSD: emul.c,v 1.185 2017/11/21 15:22:06 ozaki-r Exp $"); 30 31 #include <sys/param.h> 32 #include <sys/cprng.h> 33 #include <sys/filedesc.h> 34 #include <sys/fstrans.h> 35 #include <sys/kauth.h> 36 #include <sys/module.h> 37 #include <sys/reboot.h> 38 #include <sys/syscall.h> 39 #include <sys/pserialize.h> 40 #ifdef LOCKDEBUG 41 #include <sys/sleepq.h> 42 #endif 43 44 #include <dev/cons.h> 45 46 #include <rump-sys/kern.h> 47 48 #include <rump/rumpuser.h> 49 50 void (*rump_vfs_fini)(void) = (void *)nullop; 51 52 /* 53 * physmem is largely unused (except for nmbcluster calculations), 54 * so pick a default value which suits ZFS. if an application wants 55 * a very small memory footprint, it can still adjust this before 56 * calling rump_init() 57 */ 58 #define PHYSMEM 512*256 59 psize_t physmem = PHYSMEM; 60 int nkmempages = PHYSMEM/2; /* from le chapeau */ 61 #undef PHYSMEM 62 63 struct vnode *rootvp; 64 dev_t rootdev = NODEV; 65 66 const int schedppq = 1; 67 bool mp_online = false; 68 struct timespec boottime; 69 int cold = 1; 70 int boothowto = AB_SILENT; 71 struct tty *constty; 72 73 const struct bdevsw *bdevsw0[255]; 74 const struct bdevsw **bdevsw = bdevsw0; 75 const int sys_cdevsws = 255; 76 int max_cdevsws = 255; 77 78 const struct cdevsw *cdevsw0[255]; 79 const struct cdevsw **cdevsw = cdevsw0; 80 const int sys_bdevsws = 255; 81 int max_bdevsws = 255; 82 83 int mem_no = 2; 84 85 device_t booted_device; 86 device_t booted_wedge; 87 int booted_partition; 88 const char *booted_method; 89 90 /* XXX: unused */ 91 kmutex_t tty_lock; 92 krwlock_t exec_lock; 93 94 /* sparc doesn't sport constant page size, pretend we have 4k pages */ 95 #ifdef __sparc__ 96 int nbpg = 4096; 97 int pgofset = 4096-1; 98 int pgshift = 12; 99 #endif 100 101 /* on sun3 VM_MAX_ADDRESS is a const variable */ 102 /* XXX: should be moved into rump.c and initialize for sun3 and sun3x? */ 103 #ifdef sun3 104 const vaddr_t kernbase = KERNBASE3; 105 #endif 106 107 struct loadavg averunnable = { 108 { 0 * FSCALE, 109 1 * FSCALE, 110 11 * FSCALE, }, 111 FSCALE, 112 }; 113 114 /* 115 * Include the autogenerated list of auto-loadable syscalls 116 */ 117 #include <kern/syscalls_autoload.c> 118 119 struct emul emul_netbsd = { 120 .e_name = "netbsd-rump", 121 .e_sysent = rump_sysent, 122 #ifndef __HAVE_MINIMAL_EMUL 123 .e_nsysent = SYS_NSYSENT, 124 #endif 125 .e_vm_default_addr = uvm_default_mapaddr, 126 #ifdef __HAVE_SYSCALL_INTERN 127 .e_syscall_intern = syscall_intern, 128 #endif 129 .e_sc_autoload = netbsd_syscalls_autoload, 130 }; 131 132 cprng_strong_t *kern_cprng; 133 134 /* not used, but need the symbols for pointer comparisons */ 135 syncobj_t mutex_syncobj, rw_syncobj; 136 137 int 138 kpause(const char *wmesg, bool intr, int timeo, kmutex_t *mtx) 139 { 140 extern int hz; 141 int rv __diagused; 142 uint64_t sec, nsec; 143 144 if (mtx) 145 mutex_exit(mtx); 146 147 sec = timeo / hz; 148 nsec = (timeo % hz) * (1000000000 / hz); 149 rv = rumpuser_clock_sleep(RUMPUSER_CLOCK_RELWALL, sec, nsec); 150 KASSERT(rv == 0); 151 152 if (mtx) 153 mutex_enter(mtx); 154 155 return 0; 156 } 157 158 vaddr_t 159 calc_cache_size(vsize_t vasz, int pct, int va_pct) 160 { 161 paddr_t t; 162 163 t = (paddr_t)physmem * pct / 100 * PAGE_SIZE; 164 if ((vaddr_t)t != t) { 165 panic("%s: needs tweak", __func__); 166 } 167 return t; 168 } 169 170 #define RETURN_ADDRESS (uintptr_t)__builtin_return_address(0) 171 172 void 173 assert_sleepable(void) 174 { 175 const char *reason = NULL; 176 177 /* always sleepable, although we should improve this */ 178 179 if (!pserialize_not_in_read_section()) { 180 reason = "pserialize"; 181 } 182 183 if (reason) { 184 panic("%s: %s caller=%p", __func__, reason, 185 (void *)RETURN_ADDRESS); 186 } 187 } 188 189 void 190 module_init_md(void) 191 { 192 193 /* 194 * Nothing for now. However, we should load the librump 195 * symbol table. 196 */ 197 } 198 199 /* 200 * Try to emulate all the MD definitions of DELAY() / delay(). 201 * Would be nice to fix the #defines in MD headers, but this quicker. 202 * 203 * XXX: we'd need a rumpuser_clock_sleep_nowrap() here. Since we 204 * don't have it in the current hypercall revision, busyloop. 205 * Note that rather than calibrate a loop delay and work with that, 206 * get call gettime (which does not block) in a loop to make sure 207 * we didn't get virtual ghosttime. That might be slightly inaccurate 208 * for very small delays ... 209 * 210 * The other option would be to run a thread in the hypervisor which 211 * sleeps for us and we can wait for it using rumpuser_cv_wait_nowrap() 212 * Probably too fussy. Better just wait for hypercall rev 18 ;) 213 */ 214 static void 215 rump_delay(unsigned int us) 216 { 217 struct timespec target, tmp; 218 uint64_t sec, sec_ini, sec_now; 219 long nsec, nsec_ini, nsec_now; 220 int loops; 221 222 rumpuser_clock_gettime(RUMPUSER_CLOCK_ABSMONO, &sec_ini, &nsec_ini); 223 224 #ifdef __mac68k__ 225 sec = us / 1000; 226 nsec = (us % 1000) * 1000000; 227 #else 228 sec = us / 1000000; 229 nsec = (us % 1000000) * 1000; 230 #endif 231 232 target.tv_sec = sec_ini; 233 tmp.tv_sec = sec; 234 target.tv_nsec = nsec_ini; 235 tmp.tv_nsec = nsec; 236 timespecadd(&target, &tmp, &target); 237 238 if (__predict_false(sec != 0)) 239 printf("WARNING: over 1s delay\n"); 240 241 for (loops = 0; loops < 1000*1000*100; loops++) { 242 struct timespec cur; 243 244 rumpuser_clock_gettime(RUMPUSER_CLOCK_ABSMONO, 245 &sec_now, &nsec_now); 246 cur.tv_sec = sec_now; 247 cur.tv_nsec = nsec_now; 248 if (timespeccmp(&cur, &target, >=)) { 249 return; 250 } 251 } 252 printf("WARNING: DELAY ESCAPED\n"); 253 } 254 void (*delay_func)(unsigned int) = rump_delay; 255 __strong_alias(delay,rump_delay); 256 __strong_alias(_delay,rump_delay); 257 258 /* Weak aliases for fstrans to be used unless librumpvfs is present. */ 259 260 void rump_fstrans_start(struct mount *); 261 void 262 rump_fstrans_start(struct mount *mp) 263 { 264 265 } 266 __weak_alias(fstrans_start,rump_fstrans_start); 267 268 int rump_fstrans_start_nowait(struct mount *); 269 int 270 rump_fstrans_start_nowait(struct mount *mp) 271 { 272 273 return 0; 274 } 275 __weak_alias(fstrans_start_nowait,rump_fstrans_start_nowait); 276 277 void rump_fstrans_done(struct mount *); 278 void 279 rump_fstrans_done(struct mount *mp) 280 { 281 282 } 283 __weak_alias(fstrans_done,rump_fstrans_done); 284 285 /* 286 * Provide weak aliases for tty routines used by printf. 287 * They will be used unless the rumpkern_tty component is present. 288 */ 289 290 int rump_ttycheckoutq(struct tty *, int); 291 int 292 rump_ttycheckoutq(struct tty *tp, int wait) 293 { 294 295 return 1; 296 } 297 __weak_alias(ttycheckoutq,rump_ttycheckoutq); 298 299 int rump_tputchar(int, int, struct tty *); 300 int 301 rump_tputchar(int c, int flags, struct tty *tp) 302 { 303 304 cnputc(c); 305 return 0; 306 } 307 __weak_alias(tputchar,rump_tputchar); 308 309 void 310 cnputc(int c) 311 { 312 313 rumpuser_putchar(c); 314 } 315 316 void 317 cnflush(void) 318 { 319 320 /* done */ 321 } 322 323 void 324 resettodr(void) 325 { 326 327 /* setting clocks is not in the jurisdiction of rump kernels */ 328 } 329 330 #ifdef __HAVE_SYSCALL_INTERN 331 void 332 syscall_intern(struct proc *p) 333 { 334 335 p->p_emuldata = NULL; 336 } 337 #endif 338 339 #ifdef LOCKDEBUG 340 void 341 turnstile_print(volatile void *obj, void (*pr)(const char *, ...)) 342 { 343 344 /* nada */ 345 } 346 #endif 347 348 void 349 cpu_reboot(int howto, char *bootstr) 350 { 351 int ruhow = 0; 352 void *finiarg; 353 354 printf("rump kernel halting...\n"); 355 356 if (!RUMP_LOCALPROC_P(curproc)) 357 finiarg = RUMP_SPVM2CTL(curproc->p_vmspace); 358 else 359 finiarg = NULL; 360 361 /* dump means we really take the dive here */ 362 if ((howto & RB_DUMP) || panicstr) { 363 ruhow = RUMPUSER_PANIC; 364 goto out; 365 } 366 367 /* try to sync */ 368 if (!((howto & RB_NOSYNC) || panicstr)) { 369 rump_vfs_fini(); 370 } 371 372 doshutdownhooks(); 373 374 /* your wish is my command */ 375 if (howto & RB_HALT) { 376 printf("rump kernel halted (with RB_HALT, not exiting)\n"); 377 rump_sysproxy_fini(finiarg); 378 for (;;) { 379 rumpuser_clock_sleep(RUMPUSER_CLOCK_RELWALL, 10, 0); 380 } 381 } 382 383 /* this function is __dead, we must exit */ 384 out: 385 rump_sysproxy_fini(finiarg); 386 rumpuser_exit(ruhow); 387 } 388 389 const char * 390 cpu_getmodel(void) 391 { 392 393 return "rumpcore (virtual)"; 394 } 395