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