Documentation/lguest/lguest.c

   1 /* Simple program to layout "physical" memory for new lguest guest.
   2  * Linked high to avoid likely physical memory.  */
   3 #define _LARGEFILE64_SOURCE
   4 #define _GNU_SOURCE
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <unistd.h>
   8 #include <err.h>
   9 #include <stdint.h>
  10 #include <stdlib.h>
  11 #include <elf.h>
  12 #include <sys/mman.h>
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <sys/wait.h>
  16 #include <fcntl.h>
  17 #include <stdbool.h>
  18 #include <errno.h>
  19 #include <ctype.h>
  20 #include <sys/socket.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/time.h>
  23 #include <time.h>
  24 #include <netinet/in.h>
  25 #include <net/if.h>
  26 #include <linux/sockios.h>
  27 #include <linux/if_tun.h>
  28 #include <sys/uio.h>
  29 #include <termios.h>
  30 #include <getopt.h>
  31 #include <zlib.h>
  32 typedef unsigned long long u64;
  33 typedef uint32_t u32;
  34 typedef uint16_t u16;
  35 typedef uint8_t u8;
  36 #include "../../include/linux/lguest_launcher.h"
  37 #include "../../include/asm-i386/e820.h"
  38
  39 #define PAGE_PRESENT 0x7        /* Present, RW, Execute */
  40 #define NET_PEERNUM 1
  41 #define BRIDGE_PFX "bridge:"
  42 #ifndef SIOCBRADDIF
  43 #define SIOCBRADDIF     0x89a2          /* add interface to bridge      */
  44 #endif
  45
  46 static bool verbose;
  47 #define verbose(args...) \
  48         do { if (verbose) printf(args); } while(0)
  49 static int waker_fd;
  50
  51 struct device_list
  52 {
  53         fd_set infds;
  54         int max_infd;
  55
  56         struct device *dev;
  57         struct device **lastdev;
  58 };
  59
  60 struct device
  61 {
  62         struct device *next;
  63         struct lguest_device_desc *desc;
  64         void *mem;
  65
  66         /* Watch this fd if handle_input non-NULL. */
  67         int fd;
  68         bool (*handle_input)(int fd, struct device *me);
  69
  70         /* Watch DMA to this key if handle_input non-NULL. */
  71         unsigned long watch_key;
  72         u32 (*handle_output)(int fd, const struct iovec *iov,
  73                              unsigned int num, struct device *me);
  74
  75         /* Device-specific data. */
  76         void *priv;
  77 };
  78
  79 static int open_or_die(const char *name, int flags)
  80 {
  81         int fd = open(name, flags);
  82         if (fd < 0)
  83                 err(1, "Failed to open %s", name);
  84         return fd;
  85 }
  86
  87 static void *map_zeroed_pages(unsigned long addr, unsigned int num)
  88 {
  89         static int fd = -1;
  90
  91         if (fd == -1)
  92                 fd = open_or_die("/dev/zero", O_RDONLY);
  93
  94         if (mmap((void *)addr, getpagesize() * num,
  95                  PROT_READ|PROT_WRITE|PROT_EXEC, MAP_FIXED|MAP_PRIVATE, fd, 0)
  96             != (void *)addr)
  97                 err(1, "Mmaping %u pages of /dev/zero @%p", num, (void *)addr);
  98         return (void *)addr;
  99 }
 100
 101 /* Find magic string marking entry point, return entry point. */
 102 static unsigned long entry_point(void *start, void *end,
 103                                  unsigned long page_offset)
 104 {
 105         void *p;
 106
 107         for (p = start; p < end; p++)
 108                 if (memcmp(p, "GenuineLguest", strlen("GenuineLguest")) == 0)
 109                         return (long)p + strlen("GenuineLguest") + page_offset;
 110
 111         err(1, "Is this image a genuine lguest?");
 112 }
 113
 114 /* Returns the entry point */
 115 static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr,
 116                              unsigned long *page_offset)
 117 {
 118         void *addr;
 119         Elf32_Phdr phdr[ehdr->e_phnum];
 120         unsigned int i;
 121         unsigned long start = -1UL, end = 0;
 122
 123         /* Sanity checks. */
 124         if (ehdr->e_type != ET_EXEC
 125             || ehdr->e_machine != EM_386
 126             || ehdr->e_phentsize != sizeof(Elf32_Phdr)
 127             || ehdr->e_phnum < 1 || ehdr->e_phnum > 65536U/sizeof(Elf32_Phdr))
 128                 errx(1, "Malformed elf header");
 129
 130         if (lseek(elf_fd, ehdr->e_phoff, SEEK_SET) < 0)
 131                 err(1, "Seeking to program headers");
 132         if (read(elf_fd, phdr, sizeof(phdr)) != sizeof(phdr))
 133                 err(1, "Reading program headers");
 134
 135         *page_offset = 0;
 136         /* We map the loadable segments at virtual addresses corresponding
 137          * to their physical addresses (our virtual == guest physical). */
 138         for (i = 0; i < ehdr->e_phnum; i++) {
 139                 if (phdr[i].p_type != PT_LOAD)
 140                         continue;
 141
 142                 verbose("Section %i: size %i addr %p\n",
 143                         i, phdr[i].p_memsz, (void *)phdr[i].p_paddr);
 144
 145                 /* We expect linear address space. */
 146                 if (!*page_offset)
 147                         *page_offset = phdr[i].p_vaddr - phdr[i].p_paddr;
 148                 else if (*page_offset != phdr[i].p_vaddr - phdr[i].p_paddr)
 149                         errx(1, "Page offset of section %i different", i);
 150
 151                 if (phdr[i].p_paddr < start)
 152                         start = phdr[i].p_paddr;
 153                 if (phdr[i].p_paddr + phdr[i].p_filesz > end)
 154                         end = phdr[i].p_paddr + phdr[i].p_filesz;
 155
 156                 /* We map everything private, writable. */
 157                 addr = mmap((void *)phdr[i].p_paddr,
 158                             phdr[i].p_filesz,
 159                             PROT_READ|PROT_WRITE|PROT_EXEC,
 160                             MAP_FIXED|MAP_PRIVATE,
 161                             elf_fd, phdr[i].p_offset);
 162                 if (addr != (void *)phdr[i].p_paddr)
 163                         err(1, "Mmaping vmlinux seg %i gave %p not %p",
 164                             i, addr, (void *)phdr[i].p_paddr);
 165         }
 166
 167         return entry_point((void *)start, (void *)end, *page_offset);
 168 }
 169
 170 /* This is amazingly reliable. */
 171 static unsigned long intuit_page_offset(unsigned char *img, unsigned long len)
 172 {
 173         unsigned int i, possibilities[256] = { 0 };
 174
 175         for (i = 0; i + 4 < len; i++) {
 176                 /* mov 0xXXXXXXXX,%eax */
 177                 if (img[i] == 0xA1 && ++possibilities[img[i+4]] > 3)
 178                         return (unsigned long)img[i+4] << 24;
 179         }
 180         errx(1, "could not determine page offset");
 181 }
 182
 183 static unsigned long unpack_bzimage(int fd, unsigned long *page_offset)
 184 {
 185         gzFile f;
 186         int ret, len = 0;
 187         void *img = (void *)0x100000;
 188
 189         f = gzdopen(fd, "rb");
 190         while ((ret = gzread(f, img + len, 65536)) > 0)
 191                 len += ret;
 192         if (ret < 0)
 193                 err(1, "reading image from bzImage");
 194
 195         verbose("Unpacked size %i addr %p\n", len, img);
 196         *page_offset = intuit_page_offset(img, len);
 197
 198         return entry_point(img, img + len, *page_offset);
 199 }
 200
 201 static unsigned long load_bzimage(int fd, unsigned long *page_offset)
 202 {
 203         unsigned char c;
 204         int state = 0;
 205
 206         /* Ugly brute force search for gzip header. */
 207         while (read(fd, &c, 1) == 1) {
 208                 switch (state) {
 209                 case 0:
 210                         if (c == 0x1F)
 211                                 state++;
 212                         break;
 213                 case 1:
 214                         if (c == 0x8B)
 215                                 state++;
 216                         else
 217                                 state = 0;
 218                         break;
 219                 case 2 ... 8:
 220                         state++;
 221                         break;
 222                 case 9:
 223                         lseek(fd, -10, SEEK_CUR);
 224                         if (c != 0x03) /* Compressed under UNIX. */
 225                                 state = -1;
 226                         else
 227                                 return unpack_bzimage(fd, page_offset);
 228                 }
 229         }
 230         errx(1, "Could not find kernel in bzImage");
 231 }
 232
 233 static unsigned long load_kernel(int fd, unsigned long *page_offset)
 234 {
 235         Elf32_Ehdr hdr;
 236
 237         if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr))
 238                 err(1, "Reading kernel");
 239
 240         if (memcmp(hdr.e_ident, ELFMAG, SELFMAG) == 0)
 241                 return map_elf(fd, &hdr, page_offset);
 242
 243         return load_bzimage(fd, page_offset);
 244 }
 245
 246 static inline unsigned long page_align(unsigned long addr)
 247 {
 248         return ((addr + getpagesize()-1) & ~(getpagesize()-1));
 249 }
 250
 251 /* initrd gets loaded at top of memory: return length. */
 252 static unsigned long load_initrd(const char *name, unsigned long mem)
 253 {
 254         int ifd;
 255         struct stat st;
 256         unsigned long len;
 257         void *iaddr;
 258
 259         ifd = open_or_die(name, O_RDONLY);
 260         if (fstat(ifd, &st) < 0)
 261                 err(1, "fstat() on initrd '%s'", name);
 262
 263         len = page_align(st.st_size);
 264         iaddr = mmap((void *)mem - len, st.st_size,
 265                      PROT_READ|PROT_EXEC|PROT_WRITE,
 266                      MAP_FIXED|MAP_PRIVATE, ifd, 0);
 267         if (iaddr != (void *)mem - len)
 268                 err(1, "Mmaping initrd '%s' returned %p not %p",
 269                     name, iaddr, (void *)mem - len);
 270         close(ifd);
 271         verbose("mapped initrd %s size=%lu @ %p\n", name, st.st_size, iaddr);
 272         return len;
 273 }
 274
 275 static unsigned long setup_pagetables(unsigned long mem,
 276                                       unsigned long initrd_size,
 277                                       unsigned long page_offset)
 278 {
 279         u32 *pgdir, *linear;
 280         unsigned int mapped_pages, i, linear_pages;
 281         unsigned int ptes_per_page = getpagesize()/sizeof(u32);
 282
 283         /* If we can map all of memory above page_offset, we do so. */
 284         if (mem <= -page_offset)
 285                 mapped_pages = mem/getpagesize();
 286         else
 287                 mapped_pages = -page_offset/getpagesize();
 288
 289         /* Each linear PTE page can map ptes_per_page pages. */
 290         linear_pages = (mapped_pages + ptes_per_page-1)/ptes_per_page;
 291
 292         /* We lay out top-level then linear mapping immediately below initrd */
 293         pgdir = (void *)mem - initrd_size - getpagesize();
 294         linear = (void *)pgdir - linear_pages*getpagesize();
 295
 296         for (i = 0; i < mapped_pages; i++)
 297                 linear[i] = ((i * getpagesize()) | PAGE_PRESENT);
 298
 299         /* Now set up pgd so that this memory is at page_offset */
 300         for (i = 0; i < mapped_pages; i += ptes_per_page) {
 301                 pgdir[(i + page_offset/getpagesize())/ptes_per_page]
 302                         = (((u32)linear + i*sizeof(u32)) | PAGE_PRESENT);
 303         }
 304
 305         verbose("Linear mapping of %u pages in %u pte pages at %p\n",
 306                 mapped_pages, linear_pages, linear);
 307
 308         return (unsigned long)pgdir;
 309 }
 310
 311 static void concat(char *dst, char *args[])
 312 {
 313         unsigned int i, len = 0;
 314
 315         for (i = 0; args[i]; i++) {
 316                 strcpy(dst+len, args[i]);
 317                 strcat(dst+len, " ");
 318                 len += strlen(args[i]) + 1;
 319         }
 320         /* In case it's empty. */
 321         dst[len] = '\0';
 322 }
 323
 324 static int tell_kernel(u32 pgdir, u32 start, u32 page_offset)
 325 {
 326         u32 args[] = { LHREQ_INITIALIZE,
 327                        LGUEST_GUEST_TOP/getpagesize(), /* Just below us */
 328                        pgdir, start, page_offset };
 329         int fd;
 330
 331         fd = open_or_die("/dev/lguest", O_RDWR);
 332         if (write(fd, args, sizeof(args)) < 0)
 333                 err(1, "Writing to /dev/lguest");
 334         return fd;
 335 }
 336
 337 static void set_fd(int fd, struct device_list *devices)
 338 {
 339         FD_SET(fd, &devices->infds);
 340         if (fd > devices->max_infd)
 341                 devices->max_infd = fd;
 342 }
 343
 344 /* When input arrives, we tell the kernel to kick lguest out with -EAGAIN. */
 345 static void wake_parent(int pipefd, int lguest_fd, struct device_list *devices)
 346 {
 347         set_fd(pipefd, devices);
 348
 349         for (;;) {
 350                 fd_set rfds = devices->infds;
 351                 u32 args[] = { LHREQ_BREAK, 1 };
 352
 353                 select(devices->max_infd+1, &rfds, NULL, NULL, NULL);
 354                 if (FD_ISSET(pipefd, &rfds)) {
 355                         int ignorefd;
 356                         if (read(pipefd, &ignorefd, sizeof(ignorefd)) == 0)
 357                                 exit(0);
 358                         FD_CLR(ignorefd, &devices->infds);
 359                 } else
 360                         write(lguest_fd, args, sizeof(args));
 361         }
 362 }
 363
 364 static int setup_waker(int lguest_fd, struct device_list *device_list)
 365 {
 366         int pipefd[2], child;
 367
 368         pipe(pipefd);
 369         child = fork();
 370         if (child == -1)
 371                 err(1, "forking");
 372
 373         if (child == 0) {
 374                 close(pipefd[1]);
 375                 wake_parent(pipefd[0], lguest_fd, device_list);
 376         }
 377         close(pipefd[0]);
 378
 379         return pipefd[1];
 380 }
 381
 382 static void *_check_pointer(unsigned long addr, unsigned int size,
 383                             unsigned int line)
 384 {
 385         if (addr >= LGUEST_GUEST_TOP || addr + size >= LGUEST_GUEST_TOP)
 386                 errx(1, "%s:%i: Invalid address %li", __FILE__, line, addr);
 387         return (void *)addr;
 388 }
 389 #define check_pointer(addr,size) _check_pointer(addr, size, __LINE__)
 390
 391 /* Returns pointer to dma->used_len */
 392 static u32 *dma2iov(unsigned long dma, struct iovec iov[], unsigned *num)
 393 {
 394         unsigned int i;
 395         struct lguest_dma *udma;
 396
 397         udma = check_pointer(dma, sizeof(*udma));
 398         for (i = 0; i < LGUEST_MAX_DMA_SECTIONS; i++) {
 399                 if (!udma->len[i])
 400                         break;
 401
 402                 iov[i].iov_base = check_pointer(udma->addr[i], udma->len[i]);
 403                 iov[i].iov_len = udma->len[i];
 404         }
 405         *num = i;
 406         return &udma->used_len;
 407 }
 408
 409 static u32 *get_dma_buffer(int fd, void *key,
 410                            struct iovec iov[], unsigned int *num, u32 *irq)
 411 {
 412         u32 buf[] = { LHREQ_GETDMA, (u32)key };
 413         unsigned long udma;
 414         u32 *res;
 415
 416         udma = write(fd, buf, sizeof(buf));
 417         if (udma == (unsigned long)-1)
 418                 return NULL;
 419
 420         /* Kernel stashes irq in ->used_len. */
 421         res = dma2iov(udma, iov, num);
 422         *irq = *res;
 423         return res;
 424 }
 425
 426 static void trigger_irq(int fd, u32 irq)
 427 {
 428         u32 buf[] = { LHREQ_IRQ, irq };
 429         if (write(fd, buf, sizeof(buf)) != 0)
 430                 err(1, "Triggering irq %i", irq);
 431 }
 432
 433 static void discard_iovec(struct iovec *iov, unsigned int *num)
 434 {
 435         static char discard_buf[1024];
 436         *num = 1;
 437         iov->iov_base = discard_buf;
 438         iov->iov_len = sizeof(discard_buf);
 439 }
 440
 441 static struct termios orig_term;
 442 static void restore_term(void)
 443 {
 444         tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
 445 }
 446
 447 struct console_abort
 448 {
 449         int count;
 450         struct timeval start;
 451 };
 452
 453 /* We DMA input to buffer bound at start of console page. */
 454 static bool handle_console_input(int fd, struct device *dev)
 455 {
 456         u32 irq = 0, *lenp;
 457         int len;
 458         unsigned int num;
 459         struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
 460         struct console_abort *abort = dev->priv;
 461
 462         lenp = get_dma_buffer(fd, dev->mem, iov, &num, &irq);
 463         if (!lenp) {
 464                 warn("console: no dma buffer!");
 465                 discard_iovec(iov, &num);
 466         }
 467
 468         len = readv(dev->fd, iov, num);
 469         if (len <= 0) {
 470                 warnx("Failed to get console input, ignoring console.");
 471                 len = 0;
 472         }
 473
 474         if (lenp) {
 475                 *lenp = len;
 476                 trigger_irq(fd, irq);
 477         }
 478
 479         /* Three ^C within one second?  Exit. */
 480         if (len == 1 && ((char *)iov[0].iov_base)[0] == 3) {
 481                 if (!abort->count++)
 482                         gettimeofday(&abort->start, NULL);
 483                 else if (abort->count == 3) {
 484                         struct timeval now;
 485                         gettimeofday(&now, NULL);
 486                         if (now.tv_sec <= abort->start.tv_sec+1) {
 487                                 /* Make sure waker is not blocked in BREAK */
 488                                 u32 args[] = { LHREQ_BREAK, 0 };
 489                                 close(waker_fd);
 490                                 write(fd, args, sizeof(args));
 491                                 exit(2);
 492                         }
 493                         abort->count = 0;
 494                 }
 495         } else
 496                 abort->count = 0;
 497
 498         if (!len) {
 499                 restore_term();
 500                 return false;
 501         }
 502         return true;
 503 }
 504
 505 static u32 handle_console_output(int fd, const struct iovec *iov,
 506                                  unsigned num, struct device*dev)
 507 {
 508         return writev(STDOUT_FILENO, iov, num);
 509 }
 510
 511 static u32 handle_tun_output(int fd, const struct iovec *iov,
 512                              unsigned num, struct device *dev)
 513 {
 514         /* Now we've seen output, we should warn if we can't get buffers. */
 515         *(bool *)dev->priv = true;
 516         return writev(dev->fd, iov, num);
 517 }
 518
 519 static unsigned long peer_offset(unsigned int peernum)
 520 {
 521         return 4 * peernum;
 522 }
 523
 524 static bool handle_tun_input(int fd, struct device *dev)
 525 {
 526         u32 irq = 0, *lenp;
 527         int len;
 528         unsigned num;
 529         struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
 530
 531         lenp = get_dma_buffer(fd, dev->mem+peer_offset(NET_PEERNUM), iov, &num,
 532                               &irq);
 533         if (!lenp) {
 534                 if (*(bool *)dev->priv)
 535                         warn("network: no dma buffer!");
 536                 discard_iovec(iov, &num);
 537         }
 538
 539         len = readv(dev->fd, iov, num);
 540         if (len <= 0)
 541                 err(1, "reading network");
 542         if (lenp) {
 543                 *lenp = len;
 544                 trigger_irq(fd, irq);
 545         }
 546         verbose("tun input packet len %i [%02x %02x] (%s)\n", len,
 547                 ((u8 *)iov[0].iov_base)[0], ((u8 *)iov[0].iov_base)[1],
 548                 lenp ? "sent" : "discarded");
 549         return true;
 550 }
 551
 552 static u32 handle_block_output(int fd, const struct iovec *iov,
 553                                unsigned num, struct device *dev)
 554 {
 555         struct lguest_block_page *p = dev->mem;
 556         u32 irq, *lenp;
 557         unsigned int len, reply_num;
 558         struct iovec reply[LGUEST_MAX_DMA_SECTIONS];
 559         off64_t device_len, off = (off64_t)p->sector * 512;
 560
 561         device_len = *(off64_t *)dev->priv;
 562
 563         if (off >= device_len)
 564                 err(1, "Bad offset %llu vs %llu", off, device_len);
 565         if (lseek64(dev->fd, off, SEEK_SET) != off)
 566                 err(1, "Bad seek to sector %i", p->sector);
 567
 568         verbose("Block: %s at offset %llu\n", p->type ? "WRITE" : "READ", off);
 569
 570         lenp = get_dma_buffer(fd, dev->mem, reply, &reply_num, &irq);
 571         if (!lenp)
 572                 err(1, "Block request didn't give us a dma buffer");
 573
 574         if (p->type) {
 575                 len = writev(dev->fd, iov, num);
 576                 if (off + len > device_len) {
 577                         ftruncate(dev->fd, device_len);
 578                         errx(1, "Write past end %llu+%u", off, len);
 579                 }
 580                 *lenp = 0;
 581         } else {
 582                 len = readv(dev->fd, reply, reply_num);
 583                 *lenp = len;
 584         }
 585
 586         p->result = 1 + (p->bytes != len);
 587         trigger_irq(fd, irq);
 588         return 0;
 589 }
 590
 591 static void handle_output(int fd, unsigned long dma, unsigned long key,
 592                           struct device_list *devices)
 593 {
 594         struct device *i;
 595         u32 *lenp;
 596         struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
 597         unsigned num = 0;
 598
 599         lenp = dma2iov(dma, iov, &num);
 600         for (i = devices->dev; i; i = i->next) {
 601                 if (i->handle_output && key == i->watch_key) {
 602                         *lenp = i->handle_output(fd, iov, num, i);
 603                         return;
 604                 }
 605         }
 606         warnx("Pending dma %p, key %p", (void *)dma, (void *)key);
 607 }
 608
 609 static void handle_input(int fd, struct device_list *devices)
 610 {
 611         struct timeval poll = { .tv_sec = 0, .tv_usec = 0 };
 612
 613         for (;;) {
 614                 struct device *i;
 615                 fd_set fds = devices->infds;
 616
 617                 if (select(devices->max_infd+1, &fds, NULL, NULL, &poll) == 0)
 618                         break;
 619
 620                 for (i = devices->dev; i; i = i->next) {
 621                         if (i->handle_input && FD_ISSET(i->fd, &fds)) {
 622                                 if (!i->handle_input(fd, i)) {
 623                                         FD_CLR(i->fd, &devices->infds);
 624                                         /* Tell waker to ignore it too... */
 625                                         write(waker_fd, &i->fd, sizeof(i->fd));
 626                                 }
 627                         }
 628                 }
 629         }
 630 }
 631
 632 static struct lguest_device_desc *new_dev_desc(u16 type, u16 features,
 633                                                u16 num_pages)
 634 {
 635         static unsigned long top = LGUEST_GUEST_TOP;
 636         struct lguest_device_desc *desc;
 637
 638         desc = malloc(sizeof(*desc));
 639         desc->type = type;
 640         desc->num_pages = num_pages;
 641         desc->features = features;
 642         desc->status = 0;
 643         if (num_pages) {
 644                 top -= num_pages*getpagesize();
 645                 map_zeroed_pages(top, num_pages);
 646                 desc->pfn = top / getpagesize();
 647         } else
 648                 desc->pfn = 0;
 649         return desc;
 650 }
 651
 652 static struct device *new_device(struct device_list *devices,
 653                                  u16 type, u16 num_pages, u16 features,
 654                                  int fd,
 655                                  bool (*handle_input)(int, struct device *),
 656                                  unsigned long watch_off,
 657                                  u32 (*handle_output)(int,
 658                                                       const struct iovec *,
 659                                                       unsigned,
 660                                                       struct device *))
 661 {
 662         struct device *dev = malloc(sizeof(*dev));
 663
 664         /* Append to device list. */
 665         *devices->lastdev = dev;
 666         dev->next = NULL;
 667         devices->lastdev = &dev->next;
 668
 669         dev->fd = fd;
 670         if (handle_input)
 671                 set_fd(dev->fd, devices);
 672         dev->desc = new_dev_desc(type, features, num_pages);
 673         dev->mem = (void *)(dev->desc->pfn * getpagesize());
 674         dev->handle_input = handle_input;
 675         dev->watch_key = (unsigned long)dev->mem + watch_off;
 676         dev->handle_output = handle_output;
 677         return dev;
 678 }
 679
 680 static void setup_console(struct device_list *devices)
 681 {
 682         struct device *dev;
 683
 684         if (tcgetattr(STDIN_FILENO, &orig_term) == 0) {
 685                 struct termios term = orig_term;
 686                 term.c_lflag &= ~(ISIG|ICANON|ECHO);
 687                 tcsetattr(STDIN_FILENO, TCSANOW, &term);
 688                 atexit(restore_term);
 689         }
 690
 691         /* We don't currently require a page for the console. */
 692         dev = new_device(devices, LGUEST_DEVICE_T_CONSOLE, 0, 0,
 693                          STDIN_FILENO, handle_console_input,
 694                          LGUEST_CONSOLE_DMA_KEY, handle_console_output);
 695         dev->priv = malloc(sizeof(struct console_abort));
 696         ((struct console_abort *)dev->priv)->count = 0;
 697         verbose("device %p: console\n",
 698                 (void *)(dev->desc->pfn * getpagesize()));
 699 }
 700
 701 static void setup_block_file(const char *filename, struct device_list *devices)
 702 {
 703         int fd;
 704         struct device *dev;
 705         off64_t *device_len;
 706         struct lguest_block_page *p;
 707
 708         fd = open_or_die(filename, O_RDWR|O_LARGEFILE|O_DIRECT);
 709         dev = new_device(devices, LGUEST_DEVICE_T_BLOCK, 1,
 710                          LGUEST_DEVICE_F_RANDOMNESS,
 711                          fd, NULL, 0, handle_block_output);
 712         device_len = dev->priv = malloc(sizeof(*device_len));
 713         *device_len = lseek64(fd, 0, SEEK_END);
 714         p = dev->mem;
 715
 716         p->num_sectors = *device_len/512;
 717         verbose("device %p: block %i sectors\n",
 718                 (void *)(dev->desc->pfn * getpagesize()), p->num_sectors);
 719 }
 720
 721 /* We use fnctl locks to reserve network slots (autocleanup!) */
 722 static unsigned int find_slot(int netfd, const char *filename)
 723 {
 724         struct flock fl;
 725
 726         fl.l_type = F_WRLCK;
 727         fl.l_whence = SEEK_SET;
 728         fl.l_len = 1;
 729         for (fl.l_start = 0;
 730              fl.l_start < getpagesize()/sizeof(struct lguest_net);
 731              fl.l_start++) {
 732                 if (fcntl(netfd, F_SETLK, &fl) == 0)
 733                         return fl.l_start;
 734         }
 735         errx(1, "No free slots in network file %s", filename);
 736 }
 737
 738 static void setup_net_file(const char *filename,
 739                            struct device_list *devices)
 740 {
 741         int netfd;
 742         struct device *dev;
 743
 744         netfd = open(filename, O_RDWR, 0);
 745         if (netfd < 0) {
 746                 if (errno == ENOENT) {
 747                         netfd = open(filename, O_RDWR|O_CREAT, 0600);
 748                         if (netfd >= 0) {
 749                                 char page[getpagesize()];
 750                                 memset(page, 0, sizeof(page));
 751                                 write(netfd, page, sizeof(page));
 752                         }
 753                 }
 754                 if (netfd < 0)
 755                         err(1, "cannot open net file '%s'", filename);
 756         }
 757
 758         dev = new_device(devices, LGUEST_DEVICE_T_NET, 1,
 759                          find_slot(netfd, filename)|LGUEST_NET_F_NOCSUM,
 760                          -1, NULL, 0, NULL);
 761
 762         /* We overwrite the /dev/zero mapping with the actual file. */
 763         if (mmap(dev->mem, getpagesize(), PROT_READ|PROT_WRITE,
 764                          MAP_FIXED|MAP_SHARED, netfd, 0) != dev->mem)
 765                         err(1, "could not mmap '%s'", filename);
 766         verbose("device %p: shared net %s, peer %i\n",
 767                 (void *)(dev->desc->pfn * getpagesize()), filename,
 768                 dev->desc->features & ~LGUEST_NET_F_NOCSUM);
 769 }
 770
 771 static u32 str2ip(const char *ipaddr)
 772 {
 773         unsigned int byte[4];
 774
 775         sscanf(ipaddr, "%u.%u.%u.%u", &byte[0], &byte[1], &byte[2], &byte[3]);
 776         return (byte[0] << 24) | (byte[1] << 16) | (byte[2] << 8) | byte[3];
 777 }
 778
 779 /* adapted from libbridge */
 780 static void add_to_bridge(int fd, const char *if_name, const char *br_name)
 781 {
 782         int ifidx;
 783         struct ifreq ifr;
 784
 785         if (!*br_name)
 786                 errx(1, "must specify bridge name");
 787
 788         ifidx = if_nametoindex(if_name);
 789         if (!ifidx)
 790                 errx(1, "interface %s does not exist!", if_name);
 791
 792         strncpy(ifr.ifr_name, br_name, IFNAMSIZ);
 793         ifr.ifr_ifindex = ifidx;
 794         if (ioctl(fd, SIOCBRADDIF, &ifr) < 0)
 795                 err(1, "can't add %s to bridge %s", if_name, br_name);
 796 }
 797
 798 static void configure_device(int fd, const char *devname, u32 ipaddr,
 799                              unsigned char hwaddr[6])
 800 {
 801         struct ifreq ifr;
 802         struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
 803
 804         memset(&ifr, 0, sizeof(ifr));
 805         strcpy(ifr.ifr_name, devname);
 806         sin->sin_family = AF_INET;
 807         sin->sin_addr.s_addr = htonl(ipaddr);
 808         if (ioctl(fd, SIOCSIFADDR, &ifr) != 0)
 809                 err(1, "Setting %s interface address", devname);
 810         ifr.ifr_flags = IFF_UP;
 811         if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0)
 812                 err(1, "Bringing interface %s up", devname);
 813
 814         if (ioctl(fd, SIOCGIFHWADDR, &ifr) != 0)
 815                 err(1, "getting hw address for %s", devname);
 816
 817         memcpy(hwaddr, ifr.ifr_hwaddr.sa_data, 6);
 818 }
 819
 820 static void setup_tun_net(const char *arg, struct device_list *devices)
 821 {
 822         struct device *dev;
 823         struct ifreq ifr;
 824         int netfd, ipfd;
 825         u32 ip;
 826         const char *br_name = NULL;
 827
 828         netfd = open_or_die("/dev/net/tun", O_RDWR);
 829         memset(&ifr, 0, sizeof(ifr));
 830         ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 831         strcpy(ifr.ifr_name, "tap%d");
 832         if (ioctl(netfd, TUNSETIFF, &ifr) != 0)
 833                 err(1, "configuring /dev/net/tun");
 834         ioctl(netfd, TUNSETNOCSUM, 1);
 835
 836         /* You will be peer 1: we should create enough jitter to randomize */
 837         dev = new_device(devices, LGUEST_DEVICE_T_NET, 1,
 838                          NET_PEERNUM|LGUEST_DEVICE_F_RANDOMNESS, netfd,
 839                          handle_tun_input, peer_offset(0), handle_tun_output);
 840         dev->priv = malloc(sizeof(bool));
 841         *(bool *)dev->priv = false;
 842
 843         ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 844         if (ipfd < 0)
 845                 err(1, "opening IP socket");
 846
 847         if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) {
 848                 ip = INADDR_ANY;
 849                 br_name = arg + strlen(BRIDGE_PFX);
 850                 add_to_bridge(ipfd, ifr.ifr_name, br_name);
 851         } else
 852                 ip = str2ip(arg);
 853
 854         /* We are peer 0, ie. first slot. */
 855         configure_device(ipfd, ifr.ifr_name, ip, dev->mem);
 856
 857         /* Set "promisc" bit: we want every single packet. */
 858         *((u8 *)dev->mem) |= 0x1;
 859
 860         close(ipfd);
 861
 862         verbose("device %p: tun net %u.%u.%u.%u\n",
 863                 (void *)(dev->desc->pfn * getpagesize()),
 864                 (u8)(ip>>24), (u8)(ip>>16), (u8)(ip>>8), (u8)ip);
 865         if (br_name)
 866                 verbose("attached to bridge: %s\n", br_name);
 867 }
 868
 869 /* Now we know how much memory we have, we copy in device descriptors */
 870 static void map_device_descriptors(struct device_list *devs, unsigned long mem)
 871 {
 872         struct device *i;
 873         unsigned int num;
 874         struct lguest_device_desc *descs;
 875
 876         /* Device descriptor array sits just above top of normal memory */
 877         descs = map_zeroed_pages(mem, 1);
 878
 879         for (i = devs->dev, num = 0; i; i = i->next, num++) {
 880                 if (num == LGUEST_MAX_DEVICES)
 881                         errx(1, "too many devices");
 882                 verbose("Device %i: %s\n", num,
 883                         i->desc->type == LGUEST_DEVICE_T_NET ? "net"
 884                         : i->desc->type == LGUEST_DEVICE_T_CONSOLE ? "console"
 885                         : i->desc->type == LGUEST_DEVICE_T_BLOCK ? "block"
 886                         : "unknown");
 887                 descs[num] = *i->desc;
 888                 free(i->desc);
 889                 i->desc = &descs[num];
 890         }
 891 }
 892
 893 static void __attribute__((noreturn))
 894 run_guest(int lguest_fd, struct device_list *device_list)
 895 {
 896         for (;;) {
 897                 u32 args[] = { LHREQ_BREAK, 0 };
 898                 unsigned long arr[2];
 899                 int readval;
 900
 901                 /* We read from the /dev/lguest device to run the Guest. */
 902                 readval = read(lguest_fd, arr, sizeof(arr));
 903
 904                 if (readval == sizeof(arr)) {
 905                         handle_output(lguest_fd, arr[0], arr[1], device_list);
 906                         continue;
 907                 } else if (errno == ENOENT) {
 908                         char reason[1024] = { 0 };
 909                         read(lguest_fd, reason, sizeof(reason)-1);
 910                         errx(1, "%s", reason);
 911                 } else if (errno != EAGAIN)
 912                         err(1, "Running guest failed");
 913                 handle_input(lguest_fd, device_list);
 914                 if (write(lguest_fd, args, sizeof(args)) < 0)
 915                         err(1, "Resetting break");
 916         }
 917 }
 918
 919 static struct option opts[] = {
 920         { "verbose", 0, NULL, 'v' },
 921         { "sharenet", 1, NULL, 's' },
 922         { "tunnet", 1, NULL, 't' },
 923         { "block", 1, NULL, 'b' },
 924         { "initrd", 1, NULL, 'i' },
 925         { NULL },
 926 };
 927 static void usage(void)
 928 {
 929         errx(1, "Usage: lguest [--verbose] "
 930              "[--sharenet=<filename>|--tunnet=(<ipaddr>|bridge:<bridgename>)\n"
 931              "|--block=<filename>|--initrd=<filename>]...\n"
 932              "<mem-in-mb> vmlinux [args...]");
 933 }
 934
 935 int main(int argc, char *argv[])
 936 {
 937         unsigned long mem, pgdir, start, page_offset, initrd_size = 0;
 938         int c, lguest_fd;
 939         struct device_list device_list;
 940         void *boot = (void *)0;
 941         const char *initrd_name = NULL;
 942
 943         device_list.max_infd = -1;
 944         device_list.dev = NULL;
 945         device_list.lastdev = &device_list.dev;
 946         FD_ZERO(&device_list.infds);
 947
 948         while ((c = getopt_long(argc, argv, "v", opts, NULL)) != EOF) {
 949                 switch (c) {
 950                 case 'v':
 951                         verbose = true;
 952                         break;
 953                 case 's':
 954                         setup_net_file(optarg, &device_list);
 955                         break;
 956                 case 't':
 957                         setup_tun_net(optarg, &device_list);
 958                         break;
 959                 case 'b':
 960                         setup_block_file(optarg, &device_list);
 961                         break;
 962                 case 'i':
 963                         initrd_name = optarg;
 964                         break;
 965                 default:
 966                         warnx("Unknown argument %s", argv[optind]);
 967                         usage();
 968                 }
 969         }
 970         if (optind + 2 > argc)
 971                 usage();
 972
 973         /* We need a console device */
 974         setup_console(&device_list);
 975
 976         /* First we map /dev/zero over all of guest-physical memory. */
 977         mem = atoi(argv[optind]) * 1024 * 1024;
 978         map_zeroed_pages(0, mem / getpagesize());
 979
 980         /* Now we load the kernel */
 981         start = load_kernel(open_or_die(argv[optind+1], O_RDONLY),
 982                             &page_offset);
 983
 984         /* Write the device descriptors into memory. */
 985         map_device_descriptors(&device_list, mem);
 986
 987         /* Map the initrd image if requested */
 988         if (initrd_name) {
 989                 initrd_size = load_initrd(initrd_name, mem);
 990                 *(unsigned long *)(boot+0x218) = mem - initrd_size;
 991                 *(unsigned long *)(boot+0x21c) = initrd_size;
 992                 *(unsigned char *)(boot+0x210) = 0xFF;
 993         }
 994
 995         /* Set up the initial linar pagetables. */
 996         pgdir = setup_pagetables(mem, initrd_size, page_offset);
 997
 998         /* E820 memory map: ours is a simple, single region. */
 999         *(char*)(boot+E820NR) = 1;
1000         *((struct e820entry *)(boot+E820MAP))
1001                 = ((struct e820entry) { 0, mem, E820_RAM });
1002         /* Command line pointer and command line (at 4096) */
1003         *(void **)(boot + 0x228) = boot + 4096;
1004         concat(boot + 4096, argv+optind+2);
1005         /* Paravirt type: 1 == lguest */
1006         *(int *)(boot + 0x23c) = 1;
1007
1008         lguest_fd = tell_kernel(pgdir, start, page_offset);
1009         waker_fd = setup_waker(lguest_fd, &device_list);
1010
1011         run_guest(lguest_fd, &device_list);
1012 }