rumpuser.c revision 1.30
1 /* $NetBSD: rumpuser.c,v 1.30 2013/04/27 14:59:08 pooka Exp $ */ 2 3 /* 4 * Copyright (c) 2007-2010 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 #if !defined(lint) 31 __RCSID("$NetBSD: rumpuser.c,v 1.30 2013/04/27 14:59:08 pooka Exp $"); 32 #endif /* !lint */ 33 34 #include <sys/ioctl.h> 35 #include <sys/mman.h> 36 #include <sys/uio.h> 37 #include <sys/stat.h> 38 #include <sys/time.h> 39 40 #ifdef __NetBSD__ 41 #include <sys/disk.h> 42 #include <sys/disklabel.h> 43 #include <sys/dkio.h> 44 #include <sys/event.h> 45 #endif 46 47 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) 48 #include <sys/sysctl.h> 49 #endif 50 51 #include <assert.h> 52 #include <errno.h> 53 #include <fcntl.h> 54 #include <netdb.h> 55 #include <poll.h> 56 #include <signal.h> 57 #include <stdarg.h> 58 #include <stdint.h> 59 #include <stdio.h> 60 #include <stdlib.h> 61 #include <string.h> 62 #include <time.h> 63 #include <unistd.h> 64 65 #include <rump/rumpuser.h> 66 67 #include "rumpuser_int.h" 68 69 rump_unschedulefn rumpuser__unschedule; 70 rump_reschedulefn rumpuser__reschedule; 71 72 int 73 rumpuser_init(int version, 74 rump_reschedulefn rumpkern_resched, rump_unschedulefn rumpkern_unsched) 75 { 76 77 if (version != RUMPUSER_VERSION) { 78 fprintf(stderr, "rumpuser mismatch, kern: %d, hypervisor %d\n", 79 version, RUMPUSER_VERSION); 80 return 1; 81 } 82 83 #ifdef RUMPUSER_USE_RANDOM 84 uint32_t rv; 85 int fd; 86 87 if ((fd = open("/dev/urandom", O_RDONLY)) == -1) { 88 srandom(time(NULL)); 89 } else { 90 if (read(fd, &rv, sizeof(rv)) != sizeof(rv)) 91 srandom(time(NULL)); 92 else 93 srandom(rv); 94 close(fd); 95 } 96 #endif 97 98 rumpuser__thrinit(); 99 100 rumpuser__unschedule = rumpkern_unsched; 101 rumpuser__reschedule = rumpkern_resched; 102 103 return 0; 104 } 105 106 int 107 rumpuser_getfileinfo(const char *path, uint64_t *sizep, int *ftp, int *error) 108 { 109 struct stat sb; 110 uint64_t size; 111 int needsdev = 0, rv = 0, ft; 112 int fd = -1; 113 114 if (stat(path, &sb) == -1) { 115 seterror(errno); 116 return -1; 117 } 118 119 switch (sb.st_mode & S_IFMT) { 120 case S_IFDIR: 121 ft = RUMPUSER_FT_DIR; 122 break; 123 case S_IFREG: 124 ft = RUMPUSER_FT_REG; 125 break; 126 case S_IFBLK: 127 ft = RUMPUSER_FT_BLK; 128 needsdev = 1; 129 break; 130 case S_IFCHR: 131 ft = RUMPUSER_FT_CHR; 132 needsdev = 1; 133 break; 134 default: 135 ft = RUMPUSER_FT_OTHER; 136 break; 137 } 138 139 if (!needsdev) { 140 size = sb.st_size; 141 } else if (sizep) { 142 /* 143 * Welcome to the jungle. Of course querying the kernel 144 * for a device partition size is supposed to be far from 145 * trivial. On NetBSD we use ioctl. On $other platform 146 * we have a problem. We try "the lseek trick" and just 147 * fail if that fails. Platform specific code can later 148 * be written here if appropriate. 149 * 150 * On NetBSD we hope and pray that for block devices nobody 151 * else is holding them open, because otherwise the kernel 152 * will not permit us to open it. Thankfully, this is 153 * usually called only in bootstrap and then we can 154 * forget about it. 155 */ 156 #ifndef __NetBSD__ 157 off_t off; 158 159 fd = open(path, O_RDONLY); 160 if (fd == -1) { 161 seterror(errno); 162 rv = -1; 163 goto out; 164 } 165 166 off = lseek(fd, 0, SEEK_END); 167 if (off != 0) { 168 size = off; 169 goto out; 170 } 171 fprintf(stderr, "error: device size query not implemented on " 172 "this platform\n"); 173 seterror(EOPNOTSUPP); 174 rv = -1; 175 goto out; 176 #else 177 struct disklabel lab; 178 struct partition *parta; 179 struct dkwedge_info dkw; 180 181 fd = open(path, O_RDONLY); 182 if (fd == -1) { 183 seterror(errno); 184 rv = -1; 185 goto out; 186 } 187 188 if (ioctl(fd, DIOCGDINFO, &lab) == 0) { 189 parta = &lab.d_partitions[DISKPART(sb.st_rdev)]; 190 size = (uint64_t)lab.d_secsize * parta->p_size; 191 goto out; 192 } 193 194 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) == 0) { 195 /* 196 * XXX: should use DIOCGDISKINFO to query 197 * sector size, but that requires proplib, 198 * so just don't bother for now. it's nice 199 * that something as difficult as figuring out 200 * a partition's size has been made so easy. 201 */ 202 size = dkw.dkw_size << DEV_BSHIFT; 203 goto out; 204 } 205 206 seterror(errno); 207 rv = -1; 208 #endif /* __NetBSD__ */ 209 } 210 211 out: 212 if (rv == 0 && sizep) 213 *sizep = size; 214 if (rv == 0 && ftp) 215 *ftp = ft; 216 if (fd != -1) 217 close(fd); 218 219 return rv; 220 } 221 222 int 223 rumpuser_nanosleep(uint64_t *sec, uint64_t *nsec, int *error) 224 { 225 struct timespec rqt, rmt; 226 int rv; 227 228 /*LINTED*/ 229 rqt.tv_sec = *sec; 230 /*LINTED*/ 231 rqt.tv_nsec = *nsec; 232 233 KLOCK_WRAP(rv = nanosleep(&rqt, &rmt)); 234 if (rv == -1) 235 seterror(errno); 236 237 *sec = rmt.tv_sec; 238 *nsec = rmt.tv_nsec; 239 240 return rv; 241 } 242 243 void * 244 rumpuser_malloc(size_t howmuch, int alignment) 245 { 246 void *mem; 247 int rv; 248 249 if (alignment == 0) 250 alignment = sizeof(void *); 251 252 rv = posix_memalign(&mem, (size_t)alignment, howmuch); 253 if (__predict_false(rv != 0)) { 254 if (rv == EINVAL) { 255 printf("rumpuser_malloc: invalid alignment %d\n", 256 alignment); 257 abort(); 258 } 259 mem = NULL; 260 } 261 262 return mem; 263 } 264 265 void * 266 rumpuser_realloc(void *ptr, size_t howmuch) 267 { 268 269 return realloc(ptr, howmuch); 270 } 271 272 void 273 rumpuser_free(void *ptr) 274 { 275 276 free(ptr); 277 } 278 279 void * 280 rumpuser_anonmmap(void *prefaddr, size_t size, int alignbit, 281 int exec, int *error) 282 { 283 void *rv; 284 int prot; 285 286 #ifndef MAP_ALIGNED 287 #define MAP_ALIGNED(a) 0 288 if (alignbit) 289 fprintf(stderr, "rumpuser_anonmmap: warning, requested " 290 "alignment not supported by hypervisor\n"); 291 #endif 292 293 prot = PROT_READ|PROT_WRITE; 294 if (exec) 295 prot |= PROT_EXEC; 296 rv = mmap(prefaddr, size, prot, 297 MAP_PRIVATE | MAP_ANON | MAP_ALIGNED(alignbit), -1, 0); 298 if (rv == MAP_FAILED) { 299 seterror(errno); 300 return NULL; 301 } 302 return rv; 303 } 304 305 void 306 rumpuser_unmap(void *addr, size_t len) 307 { 308 int rv; 309 310 rv = munmap(addr, len); 311 assert(rv == 0); 312 } 313 314 void * 315 rumpuser_filemmap(int fd, off_t offset, size_t len, int flags, int *error) 316 { 317 void *rv; 318 int mmflags, prot; 319 320 if (flags & RUMPUSER_FILEMMAP_TRUNCATE) { 321 if (ftruncate(fd, offset + len) == -1) { 322 seterror(errno); 323 return NULL; 324 } 325 } 326 327 /* it's implicit */ 328 #if defined(__sun__) && !defined(MAP_FILE) 329 #define MAP_FILE 0 330 #endif 331 332 mmflags = MAP_FILE; 333 if (flags & RUMPUSER_FILEMMAP_SHARED) 334 mmflags |= MAP_SHARED; 335 else 336 mmflags |= MAP_PRIVATE; 337 338 prot = 0; 339 if (flags & RUMPUSER_FILEMMAP_READ) 340 prot |= PROT_READ; 341 if (flags & RUMPUSER_FILEMMAP_WRITE) 342 prot |= PROT_WRITE; 343 344 rv = mmap(NULL, len, PROT_READ|PROT_WRITE, mmflags, fd, offset); 345 if (rv == MAP_FAILED) { 346 seterror(errno); 347 return NULL; 348 } 349 350 seterror(0); 351 return rv; 352 } 353 354 int 355 rumpuser_memsync(void *addr, size_t len, int *error) 356 { 357 358 DOCALL_KLOCK(int, (msync(addr, len, MS_SYNC))); 359 } 360 361 int 362 rumpuser_open(const char *path, int ruflags, int *error) 363 { 364 int flags; 365 366 switch (ruflags & RUMPUSER_OPEN_ACCMODE) { 367 case RUMPUSER_OPEN_RDONLY: 368 flags = O_RDONLY; 369 break; 370 case RUMPUSER_OPEN_WRONLY: 371 flags = O_WRONLY; 372 break; 373 case RUMPUSER_OPEN_RDWR: 374 flags = O_RDWR; 375 break; 376 default: 377 *error = EINVAL; 378 return -1; 379 } 380 381 #define TESTSET(_ru_, _h_) if (ruflags & _ru_) flags |= _h_; 382 TESTSET(RUMPUSER_OPEN_CREATE, O_CREAT); 383 TESTSET(RUMPUSER_OPEN_EXCL, O_EXCL); 384 #ifdef O_DIRECT 385 TESTSET(RUMPUSER_OPEN_DIRECT, O_DIRECT); 386 #else 387 if (ruflags & RUMPUSER_OPEN_DIRECT) { 388 *error = EOPNOTSUPP; 389 return -1; 390 } 391 #endif 392 #undef TESTSET 393 394 DOCALL_KLOCK(int, (open(path, flags, 0644))); 395 } 396 397 int 398 rumpuser_ioctl(int fd, u_long cmd, void *data, int *error) 399 { 400 401 DOCALL_KLOCK(int, (ioctl(fd, cmd, data))); 402 } 403 404 int 405 rumpuser_close(int fd, int *error) 406 { 407 408 DOCALL(int, close(fd)); 409 } 410 411 int 412 rumpuser_fsync(int fd, int *error) 413 { 414 415 DOCALL_KLOCK(int, fsync(fd)); 416 } 417 418 ssize_t 419 rumpuser_read(int fd, void *data, size_t size, int *error) 420 { 421 ssize_t rv; 422 423 KLOCK_WRAP(rv = read(fd, data, size)); 424 if (rv == -1) 425 seterror(errno); 426 427 return rv; 428 } 429 430 ssize_t 431 rumpuser_pread(int fd, void *data, size_t size, off_t offset, int *error) 432 { 433 ssize_t rv; 434 435 KLOCK_WRAP(rv = pread(fd, data, size, offset)); 436 if (rv == -1) 437 seterror(errno); 438 439 return rv; 440 } 441 442 void 443 rumpuser_read_bio(int fd, void *data, size_t size, off_t offset, 444 rump_biodone_fn biodone, void *biodonecookie) 445 { 446 ssize_t rv; 447 int error = 0; 448 449 rv = rumpuser_pread(fd, data, size, offset, &error); 450 /* check against <0 instead of ==-1 to get typing below right */ 451 if (rv < 0) 452 rv = 0; 453 454 /* LINTED: see above */ 455 biodone(biodonecookie, rv, error); 456 } 457 458 ssize_t 459 rumpuser_write(int fd, const void *data, size_t size, int *error) 460 { 461 ssize_t rv; 462 463 KLOCK_WRAP(rv = write(fd, data, size)); 464 if (rv == -1) 465 seterror(errno); 466 467 return rv; 468 } 469 470 ssize_t 471 rumpuser_pwrite(int fd, const void *data, size_t size, off_t offset, int *error) 472 { 473 ssize_t rv; 474 475 KLOCK_WRAP(rv = pwrite(fd, data, size, offset)); 476 if (rv == -1) 477 seterror(errno); 478 479 return rv; 480 } 481 482 void 483 rumpuser_write_bio(int fd, const void *data, size_t size, off_t offset, 484 rump_biodone_fn biodone, void *biodonecookie) 485 { 486 ssize_t rv; 487 int error = 0; 488 489 rv = rumpuser_pwrite(fd, data, size, offset, &error); 490 /* check against <0 instead of ==-1 to get typing below right */ 491 if (rv < 0) 492 rv = 0; 493 494 /* LINTED: see above */ 495 biodone(biodonecookie, rv, error); 496 } 497 498 ssize_t 499 rumpuser_readv(int fd, const struct rumpuser_iovec *riov, int iovcnt, 500 int *error) 501 { 502 struct iovec *iovp; 503 ssize_t rv; 504 int i; 505 506 iovp = malloc(iovcnt * sizeof(struct iovec)); 507 if (iovp == NULL) { 508 seterror(ENOMEM); 509 return -1; 510 } 511 for (i = 0; i < iovcnt; i++) { 512 iovp[i].iov_base = riov[i].iov_base; 513 /*LINTED*/ 514 iovp[i].iov_len = riov[i].iov_len; 515 } 516 517 KLOCK_WRAP(rv = readv(fd, iovp, iovcnt)); 518 if (rv == -1) 519 seterror(errno); 520 free(iovp); 521 522 return rv; 523 } 524 525 ssize_t 526 rumpuser_writev(int fd, const struct rumpuser_iovec *riov, int iovcnt, 527 int *error) 528 { 529 struct iovec *iovp; 530 ssize_t rv; 531 int i; 532 533 iovp = malloc(iovcnt * sizeof(struct iovec)); 534 if (iovp == NULL) { 535 seterror(ENOMEM); 536 return -1; 537 } 538 for (i = 0; i < iovcnt; i++) { 539 iovp[i].iov_base = riov[i].iov_base; 540 /*LINTED*/ 541 iovp[i].iov_len = riov[i].iov_len; 542 } 543 544 KLOCK_WRAP(rv = writev(fd, iovp, iovcnt)); 545 if (rv == -1) 546 seterror(errno); 547 free(iovp); 548 549 return rv; 550 } 551 552 int 553 rumpuser_gettime(uint64_t *sec, uint64_t *nsec, int *error) 554 { 555 struct timeval tv; 556 int rv; 557 558 rv = gettimeofday(&tv, NULL); 559 if (rv == -1) { 560 seterror(errno); 561 return rv; 562 } 563 564 *sec = tv.tv_sec; 565 *nsec = tv.tv_usec * 1000; 566 567 return 0; 568 } 569 570 int 571 rumpuser_getenv(const char *name, char *buf, size_t blen, int *error) 572 { 573 574 DOCALL(int, getenv_r(name, buf, blen)); 575 } 576 577 int 578 rumpuser_gethostname(char *name, size_t namelen, int *error) 579 { 580 char tmp[MAXHOSTNAMELEN]; 581 582 if (gethostname(tmp, sizeof(tmp)) == -1) { 583 snprintf(name, namelen, "rump-%05d.rumpdomain", (int)getpid()); 584 } else { 585 snprintf(name, namelen, "rump-%05d.%s.rumpdomain", 586 (int)getpid(), tmp); 587 } 588 589 *error = 0; 590 return 0; 591 } 592 593 int 594 rumpuser_poll(struct pollfd *fds, int nfds, int timeout, int *error) 595 { 596 597 DOCALL_KLOCK(int, (poll(fds, (nfds_t)nfds, timeout))); 598 } 599 600 int 601 rumpuser_putchar(int c, int *error) 602 { 603 604 DOCALL(int, (putchar(c))); 605 } 606 607 void 608 rumpuser_exit(int rv) 609 { 610 611 if (rv == RUMPUSER_PANIC) 612 abort(); 613 else 614 exit(rv); 615 } 616 617 void 618 rumpuser_seterrno(int error) 619 { 620 621 errno = error; 622 } 623 624 /* 625 * On NetBSD we use kqueue, on Linux we use inotify. The underlying 626 * interface requirements aren't quite the same, but we have a very 627 * good chance of doing the fd->path mapping on Linux thanks to dcache, 628 * so just keep the existing interfaces for now. 629 */ 630 #if defined(__NetBSD__) 631 int 632 rumpuser_writewatchfile_setup(int kq, int fd, intptr_t opaque, int *error) 633 { 634 struct kevent kev; 635 636 if (kq == -1) { 637 kq = kqueue(); 638 if (kq == -1) { 639 seterror(errno); 640 return -1; 641 } 642 } 643 644 EV_SET(&kev, fd, EVFILT_VNODE, EV_ADD|EV_ENABLE|EV_CLEAR, 645 NOTE_WRITE, 0, opaque); 646 if (kevent(kq, &kev, 1, NULL, 0, NULL) == -1) { 647 seterror(errno); 648 return -1; 649 } 650 651 return kq; 652 } 653 654 int 655 rumpuser_writewatchfile_wait(int kq, intptr_t *opaque, int *error) 656 { 657 struct kevent kev; 658 int rv; 659 660 again: 661 KLOCK_WRAP(rv = kevent(kq, NULL, 0, &kev, 1, NULL)); 662 if (rv == -1) { 663 if (errno == EINTR) 664 goto again; 665 seterror(errno); 666 return -1; 667 } 668 669 if (opaque) 670 *opaque = kev.udata; 671 return rv; 672 } 673 674 #elif defined(__linux__) 675 #include <sys/inotify.h> 676 677 int 678 rumpuser_writewatchfile_setup(int inotify, int fd, intptr_t notused, int *error) 679 { 680 char procbuf[PATH_MAX], linkbuf[PATH_MAX]; 681 ssize_t nn; 682 683 if (inotify == -1) { 684 inotify = inotify_init(); 685 if (inotify == -1) { 686 seterror(errno); 687 return -1; 688 } 689 } 690 691 /* ok, need to map fd into path for inotify */ 692 snprintf(procbuf, sizeof(procbuf), "/proc/self/fd/%d", fd); 693 nn = readlink(procbuf, linkbuf, sizeof(linkbuf)-1); 694 if (nn >= (ssize_t)sizeof(linkbuf)-1) { 695 nn = -1; 696 errno = E2BIG; /* pick something */ 697 } 698 if (nn == -1) { 699 seterror(errno); 700 close(inotify); 701 return -1; 702 } 703 704 linkbuf[nn] = '\0'; 705 if (inotify_add_watch(inotify, linkbuf, IN_MODIFY) == -1) { 706 seterror(errno); 707 close(inotify); 708 return -1; 709 } 710 711 return inotify; 712 } 713 714 int 715 rumpuser_writewatchfile_wait(int kq, intptr_t *opaque, int *error) 716 { 717 struct inotify_event iev; 718 ssize_t nn; 719 720 do { 721 KLOCK_WRAP(nn = read(kq, &iev, sizeof(iev))); 722 } while (errno == EINTR); 723 724 if (nn == -1) { 725 seterror(errno); 726 return -1; 727 } 728 return (nn/sizeof(iev)); 729 } 730 731 #else 732 733 /* a polling default implementation */ 734 int 735 rumpuser_writewatchfile_setup(int inotify, int fd, intptr_t notused, int *error) 736 { 737 static int warned = 0; 738 739 if (!warned) { 740 fprintf(stderr, "WARNING: rumpuser writewatchfile routines are " 741 "polling-only on this platform\n"); 742 warned = 1; 743 } 744 745 return 0; 746 } 747 748 int 749 rumpuser_writewatchfile_wait(int kq, intptr_t *opaque, int *error) 750 { 751 752 KLOCK_WRAP(usleep(10000)); 753 return 0; 754 } 755 #endif 756 757 /* 758 * This is meant for safe debugging prints from the kernel. 759 */ 760 int 761 rumpuser_dprintf(const char *format, ...) 762 { 763 va_list ap; 764 int rv; 765 766 va_start(ap, format); 767 rv = vfprintf(stderr, format, ap); 768 va_end(ap); 769 770 return rv; 771 } 772 773 int 774 rumpuser_kill(int64_t pid, int sig, int *error) 775 { 776 777 #ifdef __NetBSD__ 778 if (pid == RUMPUSER_PID_SELF) { 779 DOCALL(int, raise(sig)); 780 } else { 781 DOCALL(int, kill((pid_t)pid, sig)); 782 } 783 #else 784 /* XXXfixme: signal numbers may not match on non-NetBSD */ 785 seterror(EOPNOTSUPP); 786 return -1; 787 #endif 788 } 789 790 int 791 rumpuser_getnhostcpu(void) 792 { 793 int ncpu = 1; 794 795 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) 796 size_t sz = sizeof(ncpu); 797 798 sysctlbyname("hw.ncpu", &ncpu, &sz, NULL, 0); 799 #elif defined(__linux__) || defined(__CYGWIN__) 800 FILE *fp; 801 char *line = NULL; 802 size_t n = 0; 803 804 /* If anyone knows a better way, I'm all ears */ 805 if ((fp = fopen("/proc/cpuinfo", "r")) != NULL) { 806 ncpu = 0; 807 while (getline(&line, &n, fp) != -1) { 808 if (strncmp(line, 809 "processor", sizeof("processor")-1) == 0) 810 ncpu++; 811 } 812 if (ncpu == 0) 813 ncpu = 1; 814 free(line); 815 fclose(fp); 816 } 817 #elif __sun__ 818 /* XXX: this is just a rough estimate ... */ 819 ncpu = sysconf(_SC_NPROCESSORS_ONLN); 820 #endif 821 822 return ncpu; 823 } 824 825 /* XXX: this hypercall needs a better name */ 826 uint32_t 827 rumpuser_arc4random(void) 828 { 829 830 return arc4random(); 831 } 832
Indexes created Wed Sep 24 05:09:52 GMT 2025