lguest.c 57.6 KB
Newer Older
R
Rusty Russell 已提交
1 2 3 4 5 6
/*P:100
 * This is the Launcher code, a simple program which lays out the "physical"
 * memory for the new Guest by mapping the kernel image and the virtual
 * devices, then opens /dev/lguest to tell the kernel about the Guest and
 * control it.
:*/
7 8 9 10 11 12 13 14 15 16
#define _LARGEFILE64_SOURCE
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <err.h>
#include <stdint.h>
#include <stdlib.h>
#include <elf.h>
#include <sys/mman.h>
17
#include <sys/param.h>
18 19 20
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
21
#include <sys/eventfd.h>
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
#include <fcntl.h>
#include <stdbool.h>
#include <errno.h>
#include <ctype.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <time.h>
#include <netinet/in.h>
#include <net/if.h>
#include <linux/sockios.h>
#include <linux/if_tun.h>
#include <sys/uio.h>
#include <termios.h>
#include <getopt.h>
R
Rusty Russell 已提交
37 38
#include <assert.h>
#include <sched.h>
39 40
#include <limits.h>
#include <stddef.h>
41
#include <signal.h>
42 43 44
#include <pwd.h>
#include <grp.h>

45 46 47 48
#ifndef VIRTIO_F_ANY_LAYOUT
#define VIRTIO_F_ANY_LAYOUT		27
#endif

R
Rusty Russell 已提交
49
/*L:110
R
Rusty Russell 已提交
50
 * We can ignore the 43 include files we need for this program, but I do want
R
Rusty Russell 已提交
51
 * to draw attention to the use of kernel-style types.
52 53 54 55
 *
 * As Linus said, "C is a Spartan language, and so should your naming be."  I
 * like these abbreviations, so we define them here.  Note that u64 is always
 * unsigned long long, which works on all Linux systems: this means that we can
R
Rusty Russell 已提交
56 57
 * use %llu in printf for any u64.
 */
58 59 60 61
typedef unsigned long long u64;
typedef uint32_t u32;
typedef uint16_t u16;
typedef uint8_t u8;
62
/*:*/
63

64 65 66 67 68 69 70 71 72
#include <linux/virtio_config.h>
#include <linux/virtio_net.h>
#include <linux/virtio_blk.h>
#include <linux/virtio_console.h>
#include <linux/virtio_rng.h>
#include <linux/virtio_ring.h>
#include <asm/bootparam.h>
#include "../../include/linux/lguest_launcher.h"

73 74 75 76
#define BRIDGE_PFX "bridge:"
#ifndef SIOCBRADDIF
#define SIOCBRADDIF	0x89a2		/* add interface to bridge      */
#endif
77 78
/* We can have up to 256 pages for devices. */
#define DEVICE_PAGES 256
R
Rusty Russell 已提交
79 80
/* This will occupy 3 pages: it must be a power of 2. */
#define VIRTQUEUE_NUM 256
81

R
Rusty Russell 已提交
82 83 84 85
/*L:120
 * verbose is both a global flag and a macro.  The C preprocessor allows
 * this, and although I wouldn't recommend it, it works quite nicely here.
 */
86 87 88
static bool verbose;
#define verbose(args...) \
	do { if (verbose) printf(args); } while(0)
89 90
/*:*/

91 92 93 94
/* The pointer to the start of guest memory. */
static void *guest_base;
/* The maximum guest physical address allowed, and maximum possible. */
static unsigned long guest_limit, guest_max;
95 96
/* The /dev/lguest file descriptor. */
static int lguest_fd;
97

98 99 100
/* a per-cpu variable indicating whose vcpu is currently running */
static unsigned int __thread cpu_id;

101
/* This is our list of devices. */
102
struct device_list {
R
Rusty Russell 已提交
103 104 105 106 107 108
	/* Counter to assign interrupt numbers. */
	unsigned int next_irq;

	/* Counter to print out convenient device numbers. */
	unsigned int device_num;

109
	/* The descriptor page for the devices. */
R
Rusty Russell 已提交
110 111
	u8 *descpage;

112
	/* A single linked list of devices. */
113
	struct device *dev;
R
Rusty Russell 已提交
114
	/* And a pointer to the last device for easy append. */
115
	struct device *lastdev;
116 117
};

R
Rusty Russell 已提交
118 119 120
/* The list of Guest devices, based on command line arguments. */
static struct device_list devices;

121
/* The device structure describes a single device. */
122
struct device {
123
	/* The linked-list pointer. */
124
	struct device *next;
R
Rusty Russell 已提交
125

126
	/* The device's descriptor, as mapped into the Guest. */
127
	struct lguest_device_desc *desc;
R
Rusty Russell 已提交
128

129 130 131 132
	/* We can't trust desc values once Guest has booted: we use these. */
	unsigned int feature_len;
	unsigned int num_vq;

R
Rusty Russell 已提交
133 134
	/* The name of this device, for --verbose. */
	const char *name;
135

R
Rusty Russell 已提交
136 137
	/* Any queues attached to this device */
	struct virtqueue *vq;
138

139 140
	/* Is it operational */
	bool running;
141

142 143 144 145
	/* Device-specific data. */
	void *priv;
};

R
Rusty Russell 已提交
146
/* The virtqueue structure describes a queue attached to a device. */
147
struct virtqueue {
R
Rusty Russell 已提交
148 149 150 151 152 153 154 155 156 157 158 159 160 161
	struct virtqueue *next;

	/* Which device owns me. */
	struct device *dev;

	/* The configuration for this queue. */
	struct lguest_vqconfig config;

	/* The actual ring of buffers. */
	struct vring vring;

	/* Last available index we saw. */
	u16 last_avail_idx;

162 163 164
	/* How many are used since we sent last irq? */
	unsigned int pending_used;

165 166
	/* Eventfd where Guest notifications arrive. */
	int eventfd;
R
Rusty Russell 已提交
167

168 169 170
	/* Function for the thread which is servicing this virtqueue. */
	void (*service)(struct virtqueue *vq);
	pid_t thread;
R
Rusty Russell 已提交
171 172
};

B
Balaji Rao 已提交
173 174 175
/* Remember the arguments to the program so we can "reboot" */
static char **main_args;

176 177 178
/* The original tty settings to restore on exit. */
static struct termios orig_term;

R
Rusty Russell 已提交
179 180
/*
 * We have to be careful with barriers: our devices are all run in separate
181
 * threads and so we need to make sure that changes visible to the Guest happen
R
Rusty Russell 已提交
182 183
 * in precise order.
 */
184
#define wmb() __asm__ __volatile__("" : : : "memory")
R
Rusty Russell 已提交
185 186
#define rmb() __asm__ __volatile__("lock; addl $0,0(%%esp)" : : : "memory")
#define mb() __asm__ __volatile__("lock; addl $0,0(%%esp)" : : : "memory")
R
Rusty Russell 已提交
187

188 189 190
/* Wrapper for the last available index.  Makes it easier to change. */
#define lg_last_avail(vq)	((vq)->last_avail_idx)

R
Rusty Russell 已提交
191 192 193 194
/*
 * The virtio configuration space is defined to be little-endian.  x86 is
 * little-endian too, but it's nice to be explicit so we have these helpers.
 */
R
Rusty Russell 已提交
195 196 197 198 199
#define cpu_to_le16(v16) (v16)
#define cpu_to_le32(v32) (v32)
#define cpu_to_le64(v64) (v64)
#define le16_to_cpu(v16) (v16)
#define le32_to_cpu(v32) (v32)
200
#define le64_to_cpu(v64) (v64)
R
Rusty Russell 已提交
201

R
Rusty Russell 已提交
202 203 204 205 206 207 208 209 210 211 212 213
/* Is this iovec empty? */
static bool iov_empty(const struct iovec iov[], unsigned int num_iov)
{
	unsigned int i;

	for (i = 0; i < num_iov; i++)
		if (iov[i].iov_len)
			return false;
	return true;
}

/* Take len bytes from the front of this iovec. */
214 215
static void iov_consume(struct iovec iov[], unsigned num_iov,
			void *dest, unsigned len)
R
Rusty Russell 已提交
216 217 218 219 220 221 222
{
	unsigned int i;

	for (i = 0; i < num_iov; i++) {
		unsigned int used;

		used = iov[i].iov_len < len ? iov[i].iov_len : len;
223 224 225 226
		if (dest) {
			memcpy(dest, iov[i].iov_base, used);
			dest += used;
		}
R
Rusty Russell 已提交
227 228 229 230
		iov[i].iov_base += used;
		iov[i].iov_len -= used;
		len -= used;
	}
231 232
	if (len != 0)
		errx(1, "iovec too short!");
R
Rusty Russell 已提交
233 234
}

R
Rusty Russell 已提交
235 236 237 238
/* The device virtqueue descriptors are followed by feature bitmasks. */
static u8 *get_feature_bits(struct device *dev)
{
	return (u8 *)(dev->desc + 1)
239
		+ dev->num_vq * sizeof(struct lguest_vqconfig);
R
Rusty Russell 已提交
240 241
}

R
Rusty Russell 已提交
242 243 244 245 246 247
/*L:100
 * The Launcher code itself takes us out into userspace, that scary place where
 * pointers run wild and free!  Unfortunately, like most userspace programs,
 * it's quite boring (which is why everyone likes to hack on the kernel!).
 * Perhaps if you make up an Lguest Drinking Game at this point, it will get
 * you through this section.  Or, maybe not.
248 249 250 251 252 253
 *
 * The Launcher sets up a big chunk of memory to be the Guest's "physical"
 * memory and stores it in "guest_base".  In other words, Guest physical ==
 * Launcher virtual with an offset.
 *
 * This can be tough to get your head around, but usually it just means that we
254
 * use these trivial conversion functions when the Guest gives us its
R
Rusty Russell 已提交
255 256
 * "physical" addresses:
 */
257 258 259 260 261 262 263 264 265 266
static void *from_guest_phys(unsigned long addr)
{
	return guest_base + addr;
}

static unsigned long to_guest_phys(const void *addr)
{
	return (addr - guest_base);
}

267 268 269 270
/*L:130
 * Loading the Kernel.
 *
 * We start with couple of simple helper routines.  open_or_die() avoids
R
Rusty Russell 已提交
271 272
 * error-checking code cluttering the callers:
 */
273 274 275 276 277 278 279 280
static int open_or_die(const char *name, int flags)
{
	int fd = open(name, flags);
	if (fd < 0)
		err(1, "Failed to open %s", name);
	return fd;
}

281 282
/* map_zeroed_pages() takes a number of pages. */
static void *map_zeroed_pages(unsigned int num)
283
{
284 285
	int fd = open_or_die("/dev/zero", O_RDONLY);
	void *addr;
286

R
Rusty Russell 已提交
287 288
	/*
	 * We use a private mapping (ie. if we write to the page, it will be
289 290
	 * copied). We allocate an extra two pages PROT_NONE to act as guard
	 * pages against read/write attempts that exceed allocated space.
R
Rusty Russell 已提交
291
	 */
292 293 294
	addr = mmap(NULL, getpagesize() * (num+2),
		    PROT_NONE, MAP_PRIVATE, fd, 0);

295
	if (addr == MAP_FAILED)
296
		err(1, "Mmapping %u pages of /dev/zero", num);
R
Rusty Russell 已提交
297

298 299 300 301
	if (mprotect(addr + getpagesize(), getpagesize() * num,
		     PROT_READ|PROT_WRITE) == -1)
		err(1, "mprotect rw %u pages failed", num);

R
Rusty Russell 已提交
302 303 304 305
	/*
	 * One neat mmap feature is that you can close the fd, and it
	 * stays mapped.
	 */
306
	close(fd);
307

308 309
	/* Return address after PROT_NONE page */
	return addr + getpagesize();
310 311 312 313 314 315 316 317 318 319 320
}

/* Get some more pages for a device. */
static void *get_pages(unsigned int num)
{
	void *addr = from_guest_phys(guest_limit);

	guest_limit += num * getpagesize();
	if (guest_limit > guest_max)
		errx(1, "Not enough memory for devices");
	return addr;
321 322
}

R
Rusty Russell 已提交
323 324
/*
 * This routine is used to load the kernel or initrd.  It tries mmap, but if
325
 * that fails (Plan 9's kernel file isn't nicely aligned on page boundaries),
R
Rusty Russell 已提交
326 327
 * it falls back to reading the memory in.
 */
328 329 330 331
static void map_at(int fd, void *addr, unsigned long offset, unsigned long len)
{
	ssize_t r;

R
Rusty Russell 已提交
332 333
	/*
	 * We map writable even though for some segments are marked read-only.
334 335 336 337 338
	 * The kernel really wants to be writable: it patches its own
	 * instructions.
	 *
	 * MAP_PRIVATE means that the page won't be copied until a write is
	 * done to it.  This allows us to share untouched memory between
R
Rusty Russell 已提交
339 340
	 * Guests.
	 */
341
	if (mmap(addr, len, PROT_READ|PROT_WRITE,
342 343 344 345 346 347 348 349 350
		 MAP_FIXED|MAP_PRIVATE, fd, offset) != MAP_FAILED)
		return;

	/* pread does a seek and a read in one shot: saves a few lines. */
	r = pread(fd, addr, len, offset);
	if (r != len)
		err(1, "Reading offset %lu len %lu gave %zi", offset, len, r);
}

R
Rusty Russell 已提交
351 352
/*
 * This routine takes an open vmlinux image, which is in ELF, and maps it into
353 354 355 356
 * the Guest memory.  ELF = Embedded Linking Format, which is the format used
 * by all modern binaries on Linux including the kernel.
 *
 * The ELF headers give *two* addresses: a physical address, and a virtual
357 358
 * address.  We use the physical address; the Guest will map itself to the
 * virtual address.
359
 *
R
Rusty Russell 已提交
360 361
 * We return the starting address.
 */
362
static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr)
363 364 365 366
{
	Elf32_Phdr phdr[ehdr->e_phnum];
	unsigned int i;

R
Rusty Russell 已提交
367 368 369 370
	/*
	 * Sanity checks on the main ELF header: an x86 executable with a
	 * reasonable number of correctly-sized program headers.
	 */
371 372 373 374 375 376
	if (ehdr->e_type != ET_EXEC
	    || ehdr->e_machine != EM_386
	    || ehdr->e_phentsize != sizeof(Elf32_Phdr)
	    || ehdr->e_phnum < 1 || ehdr->e_phnum > 65536U/sizeof(Elf32_Phdr))
		errx(1, "Malformed elf header");

R
Rusty Russell 已提交
377 378
	/*
	 * An ELF executable contains an ELF header and a number of "program"
379
	 * headers which indicate which parts ("segments") of the program to
R
Rusty Russell 已提交
380 381
	 * load where.
	 */
382 383

	/* We read in all the program headers at once: */
384 385 386 387 388
	if (lseek(elf_fd, ehdr->e_phoff, SEEK_SET) < 0)
		err(1, "Seeking to program headers");
	if (read(elf_fd, phdr, sizeof(phdr)) != sizeof(phdr))
		err(1, "Reading program headers");

R
Rusty Russell 已提交
389 390 391 392
	/*
	 * Try all the headers: there are usually only three.  A read-only one,
	 * a read-write one, and a "note" section which we don't load.
	 */
393
	for (i = 0; i < ehdr->e_phnum; i++) {
394
		/* If this isn't a loadable segment, we ignore it */
395 396 397 398 399 400
		if (phdr[i].p_type != PT_LOAD)
			continue;

		verbose("Section %i: size %i addr %p\n",
			i, phdr[i].p_memsz, (void *)phdr[i].p_paddr);

401
		/* We map this section of the file at its physical address. */
402
		map_at(elf_fd, from_guest_phys(phdr[i].p_paddr),
403
		       phdr[i].p_offset, phdr[i].p_filesz);
404 405
	}

406 407
	/* The entry point is given in the ELF header. */
	return ehdr->e_entry;
408 409
}

R
Rusty Russell 已提交
410 411 412 413
/*L:150
 * A bzImage, unlike an ELF file, is not meant to be loaded.  You're supposed
 * to jump into it and it will unpack itself.  We used to have to perform some
 * hairy magic because the unpacking code scared me.
414
 *
R
Rusty Russell 已提交
415 416
 * Fortunately, Jeremy Fitzhardinge convinced me it wasn't that hard and wrote
 * a small patch to jump over the tricky bits in the Guest, so now we just read
R
Rusty Russell 已提交
417 418
 * the funky header so we know where in the file to load, and away we go!
 */
419
static unsigned long load_bzimage(int fd)
420
{
421
	struct boot_params boot;
R
Rusty Russell 已提交
422 423 424 425
	int r;
	/* Modern bzImages get loaded at 1M. */
	void *p = from_guest_phys(0x100000);

R
Rusty Russell 已提交
426 427
	/*
	 * Go back to the start of the file and read the header.  It should be
P
Paul Bolle 已提交
428
	 * a Linux boot header (see Documentation/x86/boot.txt)
R
Rusty Russell 已提交
429
	 */
R
Rusty Russell 已提交
430
	lseek(fd, 0, SEEK_SET);
431
	read(fd, &boot, sizeof(boot));
R
Rusty Russell 已提交
432

433 434
	/* Inside the setup_hdr, we expect the magic "HdrS" */
	if (memcmp(&boot.hdr.header, "HdrS", 4) != 0)
R
Rusty Russell 已提交
435 436
		errx(1, "This doesn't look like a bzImage to me");

437 438
	/* Skip over the extra sectors of the header. */
	lseek(fd, (boot.hdr.setup_sects+1) * 512, SEEK_SET);
R
Rusty Russell 已提交
439 440 441 442 443

	/* Now read everything into memory. in nice big chunks. */
	while ((r = read(fd, p, 65536)) > 0)
		p += r;

444 445
	/* Finally, code32_start tells us where to enter the kernel. */
	return boot.hdr.code32_start;
446 447
}

R
Rusty Russell 已提交
448 449
/*L:140
 * Loading the kernel is easy when it's a "vmlinux", but most kernels
R
Rusty Russell 已提交
450
 * come wrapped up in the self-decompressing "bzImage" format.  With a little
R
Rusty Russell 已提交
451 452
 * work, we can load those, too.
 */
453
static unsigned long load_kernel(int fd)
454 455 456
{
	Elf32_Ehdr hdr;

457
	/* Read in the first few bytes. */
458 459 460
	if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr))
		err(1, "Reading kernel");

461
	/* If it's an ELF file, it starts with "\177ELF" */
462
	if (memcmp(hdr.e_ident, ELFMAG, SELFMAG) == 0)
463
		return map_elf(fd, &hdr);
464

465
	/* Otherwise we assume it's a bzImage, and try to load it. */
466
	return load_bzimage(fd);
467 468
}

R
Rusty Russell 已提交
469 470
/*
 * This is a trivial little helper to align pages.  Andi Kleen hated it because
471 472 473
 * it calls getpagesize() twice: "it's dumb code."
 *
 * Kernel guys get really het up about optimization, even when it's not
R
Rusty Russell 已提交
474 475
 * necessary.  I leave this code as a reaction against that.
 */
476 477
static inline unsigned long page_align(unsigned long addr)
{
478
	/* Add upwards and truncate downwards. */
479 480 481
	return ((addr + getpagesize()-1) & ~(getpagesize()-1));
}

R
Rusty Russell 已提交
482 483 484 485 486
/*L:180
 * An "initial ram disk" is a disk image loaded into memory along with the
 * kernel which the kernel can use to boot from without needing any drivers.
 * Most distributions now use this as standard: the initrd contains the code to
 * load the appropriate driver modules for the current machine.
487 488
 *
 * Importantly, James Morris works for RedHat, and Fedora uses initrds for its
R
Rusty Russell 已提交
489 490
 * kernels.  He sent me this (and tells me when I break it).
 */
491 492 493 494 495 496 497
static unsigned long load_initrd(const char *name, unsigned long mem)
{
	int ifd;
	struct stat st;
	unsigned long len;

	ifd = open_or_die(name, O_RDONLY);
498
	/* fstat() is needed to get the file size. */
499 500 501
	if (fstat(ifd, &st) < 0)
		err(1, "fstat() on initrd '%s'", name);

R
Rusty Russell 已提交
502 503 504 505
	/*
	 * We map the initrd at the top of memory, but mmap wants it to be
	 * page-aligned, so we round the size up for that.
	 */
506
	len = page_align(st.st_size);
507
	map_at(ifd, from_guest_phys(mem - len), 0, st.st_size);
R
Rusty Russell 已提交
508 509 510 511
	/*
	 * Once a file is mapped, you can close the file descriptor.  It's a
	 * little odd, but quite useful.
	 */
512
	close(ifd);
513
	verbose("mapped initrd %s size=%lu @ %p\n", name, len, (void*)mem-len);
514 515

	/* We return the initrd size. */
516 517
	return len;
}
R
Rusty Russell 已提交
518
/*:*/
519

R
Rusty Russell 已提交
520 521 522 523
/*
 * Simple routine to roll all the commandline arguments together with spaces
 * between them.
 */
524 525 526 527 528
static void concat(char *dst, char *args[])
{
	unsigned int i, len = 0;

	for (i = 0; args[i]; i++) {
529 530 531 532
		if (i) {
			strcat(dst+len, " ");
			len++;
		}
533
		strcpy(dst+len, args[i]);
534
		len += strlen(args[i]);
535 536 537 538 539
	}
	/* In case it's empty. */
	dst[len] = '\0';
}

R
Rusty Russell 已提交
540 541
/*L:185
 * This is where we actually tell the kernel to initialize the Guest.  We
R
Rusty Russell 已提交
542
 * saw the arguments it expects when we looked at initialize() in lguest_user.c:
543
 * the base of Guest "physical" memory, the top physical page to allow and the
R
Rusty Russell 已提交
544 545
 * entry point for the Guest.
 */
546
static void tell_kernel(unsigned long start)
547
{
548 549
	unsigned long args[] = { LHREQ_INITIALIZE,
				 (unsigned long)guest_base,
550
				 guest_limit / getpagesize(), start };
551 552
	verbose("Guest: %p - %p (%#lx)\n",
		guest_base, guest_base + guest_limit, guest_limit);
553 554
	lguest_fd = open_or_die("/dev/lguest", O_RDWR);
	if (write(lguest_fd, args, sizeof(args)) < 0)
555 556
		err(1, "Writing to /dev/lguest");
}
557
/*:*/
558

R
Rusty Russell 已提交
559
/*L:200
560 561
 * Device Handling.
 *
R
Rusty Russell 已提交
562
 * When the Guest gives us a buffer, it sends an array of addresses and sizes.
563
 * We need to make sure it's not trying to reach into the Launcher itself, so
R
Rusty Russell 已提交
564
 * we have a convenient routine which checks it and exits with an error message
565 566
 * if something funny is going on:
 */
567 568 569
static void *_check_pointer(unsigned long addr, unsigned int size,
			    unsigned int line)
{
R
Rusty Russell 已提交
570
	/*
571 572
	 * Check if the requested address and size exceeds the allocated memory,
	 * or addr + size wraps around.
R
Rusty Russell 已提交
573
	 */
574
	if ((addr + size) > guest_limit || (addr + size) < addr)
R
Rusty Russell 已提交
575
		errx(1, "%s:%i: Invalid address %#lx", __FILE__, line, addr);
R
Rusty Russell 已提交
576 577 578 579
	/*
	 * We return a pointer for the caller's convenience, now we know it's
	 * safe to use.
	 */
580
	return from_guest_phys(addr);
581
}
582
/* A macro which transparently hands the line number to the real function. */
583 584
#define check_pointer(addr,size) _check_pointer(addr, size, __LINE__)

R
Rusty Russell 已提交
585 586
/*
 * Each buffer in the virtqueues is actually a chain of descriptors.  This
R
Rusty Russell 已提交
587
 * function returns the next descriptor in the chain, or vq->vring.num if we're
R
Rusty Russell 已提交
588 589
 * at the end.
 */
590 591
static unsigned next_desc(struct vring_desc *desc,
			  unsigned int i, unsigned int max)
R
Rusty Russell 已提交
592 593 594 595
{
	unsigned int next;

	/* If this descriptor says it doesn't chain, we're done. */
596 597
	if (!(desc[i].flags & VRING_DESC_F_NEXT))
		return max;
R
Rusty Russell 已提交
598 599

	/* Check they're not leading us off end of descriptors. */
600
	next = desc[i].next;
R
Rusty Russell 已提交
601 602 603
	/* Make sure compiler knows to grab that: we don't want it changing! */
	wmb();

604
	if (next >= max)
R
Rusty Russell 已提交
605 606 607 608 609
		errx(1, "Desc next is %u", next);

	return next;
}

R
Rusty Russell 已提交
610 611 612 613
/*
 * This actually sends the interrupt for this virtqueue, if we've used a
 * buffer.
 */
614 615 616 617
static void trigger_irq(struct virtqueue *vq)
{
	unsigned long buf[] = { LHREQ_IRQ, vq->config.irq };

618 619 620 621 622
	/* Don't inform them if nothing used. */
	if (!vq->pending_used)
		return;
	vq->pending_used = 0;

623 624
	/* If they don't want an interrupt, don't send one... */
	if (vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT) {
625
		return;
626
	}
627 628 629 630 631 632

	/* Send the Guest an interrupt tell them we used something up. */
	if (write(lguest_fd, buf, sizeof(buf)) != 0)
		err(1, "Triggering irq %i", vq->config.irq);
}

R
Rusty Russell 已提交
633
/*
R
Rusty Russell 已提交
634
 * This looks in the virtqueue for the first available buffer, and converts
R
Rusty Russell 已提交
635 636 637 638
 * it to an iovec for convenient access.  Since descriptors consist of some
 * number of output then some number of input descriptors, it's actually two
 * iovecs, but we pack them into one and note how many of each there were.
 *
R
Rusty Russell 已提交
639
 * This function waits if necessary, and returns the descriptor number found.
R
Rusty Russell 已提交
640
 */
641 642 643
static unsigned wait_for_vq_desc(struct virtqueue *vq,
				 struct iovec iov[],
				 unsigned int *out_num, unsigned int *in_num)
R
Rusty Russell 已提交
644
{
645 646
	unsigned int i, head, max;
	struct vring_desc *desc;
647 648
	u16 last_avail = lg_last_avail(vq);

R
Rusty Russell 已提交
649
	/* There's nothing available? */
650 651 652
	while (last_avail == vq->vring.avail->idx) {
		u64 event;

R
Rusty Russell 已提交
653 654 655 656
		/*
		 * Since we're about to sleep, now is a good time to tell the
		 * Guest about what we've used up to now.
		 */
657 658
		trigger_irq(vq);

659 660 661
		/* OK, now we need to know about added descriptors. */
		vq->vring.used->flags &= ~VRING_USED_F_NO_NOTIFY;

R
Rusty Russell 已提交
662 663 664 665
		/*
		 * They could have slipped one in as we were doing that: make
		 * sure it's written, then check again.
		 */
666 667 668 669 670 671
		mb();
		if (last_avail != vq->vring.avail->idx) {
			vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
			break;
		}

672 673 674
		/* Nothing new?  Wait for eventfd to tell us they refilled. */
		if (read(vq->eventfd, &event, sizeof(event)) != sizeof(event))
			errx(1, "Event read failed?");
675 676 677

		/* We don't need to be notified again. */
		vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
678
	}
R
Rusty Russell 已提交
679 680

	/* Check it isn't doing very strange things with descriptor numbers. */
681
	if ((u16)(vq->vring.avail->idx - last_avail) > vq->vring.num)
R
Rusty Russell 已提交
682
		errx(1, "Guest moved used index from %u to %u",
683
		     last_avail, vq->vring.avail->idx);
R
Rusty Russell 已提交
684

R
Rusty Russell 已提交
685 686 687 688 689 690
	/* 
	 * Make sure we read the descriptor number *after* we read the ring
	 * update; don't let the cpu or compiler change the order.
	 */
	rmb();

R
Rusty Russell 已提交
691 692 693 694
	/*
	 * Grab the next descriptor number they're advertising, and increment
	 * the index we've seen.
	 */
695 696
	head = vq->vring.avail->ring[last_avail % vq->vring.num];
	lg_last_avail(vq)++;
R
Rusty Russell 已提交
697 698 699 700 701 702 703 704

	/* If their number is silly, that's a fatal mistake. */
	if (head >= vq->vring.num)
		errx(1, "Guest says index %u is available", head);

	/* When we start there are none of either input nor output. */
	*out_num = *in_num = 0;

705 706
	max = vq->vring.num;
	desc = vq->vring.desc;
R
Rusty Russell 已提交
707
	i = head;
708

R
Rusty Russell 已提交
709 710 711 712 713 714
	/*
	 * We have to read the descriptor after we read the descriptor number,
	 * but there's a data dependency there so the CPU shouldn't reorder
	 * that: no rmb() required.
	 */

R
Rusty Russell 已提交
715 716 717 718
	/*
	 * If this is an indirect entry, then this buffer contains a descriptor
	 * table which we handle as if it's any normal descriptor chain.
	 */
719 720 721 722 723 724 725 726 727
	if (desc[i].flags & VRING_DESC_F_INDIRECT) {
		if (desc[i].len % sizeof(struct vring_desc))
			errx(1, "Invalid size for indirect buffer table");

		max = desc[i].len / sizeof(struct vring_desc);
		desc = check_pointer(desc[i].addr, desc[i].len);
		i = 0;
	}

R
Rusty Russell 已提交
728 729
	do {
		/* Grab the first descriptor, and check it's OK. */
730
		iov[*out_num + *in_num].iov_len = desc[i].len;
R
Rusty Russell 已提交
731
		iov[*out_num + *in_num].iov_base
732
			= check_pointer(desc[i].addr, desc[i].len);
R
Rusty Russell 已提交
733
		/* If this is an input descriptor, increment that count. */
734
		if (desc[i].flags & VRING_DESC_F_WRITE)
R
Rusty Russell 已提交
735 736
			(*in_num)++;
		else {
R
Rusty Russell 已提交
737 738 739 740
			/*
			 * If it's an output descriptor, they're all supposed
			 * to come before any input descriptors.
			 */
R
Rusty Russell 已提交
741 742 743 744 745 746
			if (*in_num)
				errx(1, "Descriptor has out after in");
			(*out_num)++;
		}

		/* If we've got too many, that implies a descriptor loop. */
747
		if (*out_num + *in_num > max)
R
Rusty Russell 已提交
748
			errx(1, "Looped descriptor");
749
	} while ((i = next_desc(desc, i, max)) != max);
750

R
Rusty Russell 已提交
751
	return head;
752 753
}

R
Rusty Russell 已提交
754
/*
R
Rusty Russell 已提交
755 756 757
 * After we've used one of their buffers, we tell the Guest about it.  Sometime
 * later we'll want to send them an interrupt using trigger_irq(); note that
 * wait_for_vq_desc() does that for us if it has to wait.
R
Rusty Russell 已提交
758
 */
R
Rusty Russell 已提交
759
static void add_used(struct virtqueue *vq, unsigned int head, int len)
760
{
R
Rusty Russell 已提交
761 762
	struct vring_used_elem *used;

R
Rusty Russell 已提交
763 764 765 766
	/*
	 * The virtqueue contains a ring of used buffers.  Get a pointer to the
	 * next entry in that used ring.
	 */
R
Rusty Russell 已提交
767 768 769 770 771 772
	used = &vq->vring.used->ring[vq->vring.used->idx % vq->vring.num];
	used->id = head;
	used->len = len;
	/* Make sure buffer is written before we update index. */
	wmb();
	vq->vring.used->idx++;
773
	vq->pending_used++;
774 775
}

R
Rusty Russell 已提交
776
/* And here's the combo meal deal.  Supersize me! */
777
static void add_used_and_trigger(struct virtqueue *vq, unsigned head, int len)
778
{
R
Rusty Russell 已提交
779
	add_used(vq, head, len);
780
	trigger_irq(vq);
781 782
}

R
Rusty Russell 已提交
783 784 785
/*
 * The Console
 *
R
Rusty Russell 已提交
786 787
 * We associate some data with the console for our exit hack.
 */
788
struct console_abort {
789
	/* How many times have they hit ^C? */
790
	int count;
791
	/* When did they start? */
792 793 794
	struct timeval start;
};

795
/* This is the routine which handles console input (ie. stdin). */
796
static void console_input(struct virtqueue *vq)
797 798
{
	int len;
R
Rusty Russell 已提交
799
	unsigned int head, in_num, out_num;
800 801
	struct console_abort *abort = vq->dev->priv;
	struct iovec iov[vq->vring.num];
802

R
Rusty Russell 已提交
803
	/* Make sure there's a descriptor available. */
804
	head = wait_for_vq_desc(vq, iov, &out_num, &in_num);
805
	if (out_num)
R
Rusty Russell 已提交
806
		errx(1, "Output buffers in console in queue?");
807

R
Rusty Russell 已提交
808
	/* Read into it.  This is where we usually wait. */
809
	len = readv(STDIN_FILENO, iov, in_num);
810
	if (len <= 0) {
811
		/* Ran out of input? */
812
		warnx("Failed to get console input, ignoring console.");
R
Rusty Russell 已提交
813 814 815 816
		/*
		 * For simplicity, dying threads kill the whole Launcher.  So
		 * just nap here.
		 */
817 818
		for (;;)
			pause();
819 820
	}

R
Rusty Russell 已提交
821
	/* Tell the Guest we used a buffer. */
822
	add_used_and_trigger(vq, head, len);
823

R
Rusty Russell 已提交
824 825
	/*
	 * Three ^C within one second?  Exit.
826
	 *
827 828 829
	 * This is such a hack, but works surprisingly well.  Each ^C has to
	 * be in a buffer by itself, so they can't be too fast.  But we check
	 * that we get three within about a second, so they can't be too
R
Rusty Russell 已提交
830 831
	 * slow.
	 */
832
	if (len != 1 || ((char *)iov[0].iov_base)[0] != 3) {
833
		abort->count = 0;
834 835
		return;
	}
836

837 838 839 840 841 842 843 844 845 846 847
	abort->count++;
	if (abort->count == 1)
		gettimeofday(&abort->start, NULL);
	else if (abort->count == 3) {
		struct timeval now;
		gettimeofday(&now, NULL);
		/* Kill all Launcher processes with SIGINT, like normal ^C */
		if (now.tv_sec <= abort->start.tv_sec+1)
			kill(0, SIGINT);
		abort->count = 0;
	}
848 849
}

850 851
/* This is the routine which handles console output (ie. stdout). */
static void console_output(struct virtqueue *vq)
852
{
R
Rusty Russell 已提交
853 854 855
	unsigned int head, out, in;
	struct iovec iov[vq->vring.num];

R
Rusty Russell 已提交
856
	/* We usually wait in here, for the Guest to give us something. */
857 858 859
	head = wait_for_vq_desc(vq, iov, &out, &in);
	if (in)
		errx(1, "Input buffers in console output queue?");
R
Rusty Russell 已提交
860 861

	/* writev can return a partial write, so we loop here. */
862 863
	while (!iov_empty(iov, out)) {
		int len = writev(STDOUT_FILENO, iov, out);
864 865 866 867
		if (len <= 0) {
			warn("Write to stdout gave %i (%d)", len, errno);
			break;
		}
868
		iov_consume(iov, out, NULL, len);
R
Rusty Russell 已提交
869
	}
R
Rusty Russell 已提交
870 871 872 873 874

	/*
	 * We're finished with that buffer: if we're going to sleep,
	 * wait_for_vq_desc() will prod the Guest with an interrupt.
	 */
875
	add_used(vq, head, 0);
876 877
}

R
Rusty Russell 已提交
878 879 880 881
/*
 * The Network
 *
 * Handling output for network is also simple: we get all the output buffers
882
 * and write them to /dev/net/tun.
883
 */
884 885 886 887 888
struct net_info {
	int tunfd;
};

static void net_output(struct virtqueue *vq)
889
{
890 891
	struct net_info *net_info = vq->dev->priv;
	unsigned int head, out, in;
R
Rusty Russell 已提交
892
	struct iovec iov[vq->vring.num];
893

R
Rusty Russell 已提交
894
	/* We usually wait in here for the Guest to give us a packet. */
895 896 897
	head = wait_for_vq_desc(vq, iov, &out, &in);
	if (in)
		errx(1, "Input buffers in net output queue?");
R
Rusty Russell 已提交
898 899 900 901
	/*
	 * Send the whole thing through to /dev/net/tun.  It expects the exact
	 * same format: what a coincidence!
	 */
902
	if (writev(net_info->tunfd, iov, out) < 0)
903
		warnx("Write to tun failed (%d)?", errno);
R
Rusty Russell 已提交
904 905 906 907 908

	/*
	 * Done with that one; wait_for_vq_desc() will send the interrupt if
	 * all packets are processed.
	 */
909
	add_used(vq, head, 0);
910 911
}

R
Rusty Russell 已提交
912 913 914 915 916 917
/*
 * Handling network input is a bit trickier, because I've tried to optimize it.
 *
 * First we have a helper routine which tells is if from this file descriptor
 * (ie. the /dev/net/tun device) will block:
 */
918 919 920 921 922 923 924 925 926
static bool will_block(int fd)
{
	fd_set fdset;
	struct timeval zero = { 0, 0 };
	FD_ZERO(&fdset);
	FD_SET(fd, &fdset);
	return select(fd+1, &fdset, NULL, NULL, &zero) != 1;
}

R
Rusty Russell 已提交
927 928 929 930 931
/*
 * This handles packets coming in from the tun device to our Guest.  Like all
 * service routines, it gets called again as soon as it returns, so you don't
 * see a while(1) loop here.
 */
932
static void net_input(struct virtqueue *vq)
933 934
{
	int len;
935 936 937 938
	unsigned int head, out, in;
	struct iovec iov[vq->vring.num];
	struct net_info *net_info = vq->dev->priv;

R
Rusty Russell 已提交
939 940 941 942
	/*
	 * Get a descriptor to write an incoming packet into.  This will also
	 * send an interrupt if they're out of descriptors.
	 */
943 944 945
	head = wait_for_vq_desc(vq, iov, &out, &in);
	if (out)
		errx(1, "Output buffers in net input queue?");
946

R
Rusty Russell 已提交
947 948 949 950
	/*
	 * If it looks like we'll block reading from the tun device, send them
	 * an interrupt.
	 */
951 952 953
	if (vq->pending_used && will_block(net_info->tunfd))
		trigger_irq(vq);

R
Rusty Russell 已提交
954 955 956 957
	/*
	 * Read in the packet.  This is where we normally wait (when there's no
	 * incoming network traffic).
	 */
958
	len = readv(net_info->tunfd, iov, in);
959
	if (len <= 0)
960
		warn("Failed to read from tun (%d).", errno);
R
Rusty Russell 已提交
961 962 963 964 965

	/*
	 * Mark that packet buffer as used, but don't interrupt here.  We want
	 * to wait until we've done as much work as we can.
	 */
966
	add_used(vq, head, len);
967
}
R
Rusty Russell 已提交
968
/*:*/
969

R
Rusty Russell 已提交
970
/* This is the helper to create threads: run the service routine in a loop. */
971 972 973
static int do_thread(void *_vq)
{
	struct virtqueue *vq = _vq;
R
Rusty Russell 已提交
974

975 976 977 978
	for (;;)
		vq->service(vq);
	return 0;
}
R
Rusty Russell 已提交
979

R
Rusty Russell 已提交
980 981 982 983
/*
 * When a child dies, we kill our entire process group with SIGTERM.  This
 * also has the side effect that the shell restores the console for us!
 */
984 985 986
static void kill_launcher(int signal)
{
	kill(0, SIGTERM);
987 988
}

989
static void reset_device(struct device *dev)
990
{
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	struct virtqueue *vq;

	verbose("Resetting device %s\n", dev->name);

	/* Clear any features they've acked. */
	memset(get_feature_bits(dev) + dev->feature_len, 0, dev->feature_len);

	/* We're going to be explicitly killing threads, so ignore them. */
	signal(SIGCHLD, SIG_IGN);

	/* Zero out the virtqueues, get rid of their threads */
	for (vq = dev->vq; vq; vq = vq->next) {
		if (vq->thread != (pid_t)-1) {
			kill(vq->thread, SIGTERM);
			waitpid(vq->thread, NULL, 0);
			vq->thread = (pid_t)-1;
		}
		memset(vq->vring.desc, 0,
		       vring_size(vq->config.num, LGUEST_VRING_ALIGN));
		lg_last_avail(vq) = 0;
	}
	dev->running = false;

	/* Now we care if threads die. */
	signal(SIGCHLD, (void *)kill_launcher);
1016 1017
}

R
Rusty Russell 已提交
1018 1019 1020
/*L:216
 * This actually creates the thread which services the virtqueue for a device.
 */
1021
static void create_thread(struct virtqueue *vq)
1022
{
R
Rusty Russell 已提交
1023
	/*
R
Rusty Russell 已提交
1024 1025
	 * Create stack for thread.  Since the stack grows upwards, we point
	 * the stack pointer to the end of this region.
R
Rusty Russell 已提交
1026
	 */
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
	char *stack = malloc(32768);
	unsigned long args[] = { LHREQ_EVENTFD,
				 vq->config.pfn*getpagesize(), 0 };

	/* Create a zero-initialized eventfd. */
	vq->eventfd = eventfd(0, 0);
	if (vq->eventfd < 0)
		err(1, "Creating eventfd");
	args[2] = vq->eventfd;

R
Rusty Russell 已提交
1037 1038 1039 1040
	/*
	 * Attach an eventfd to this virtqueue: it will go off when the Guest
	 * does an LHCALL_NOTIFY for this vq.
	 */
1041 1042 1043
	if (write(lguest_fd, &args, sizeof(args)) != 0)
		err(1, "Attaching eventfd");

R
Rusty Russell 已提交
1044 1045 1046 1047
	/*
	 * CLONE_VM: because it has to access the Guest memory, and SIGCHLD so
	 * we get a signal if it dies.
	 */
1048 1049 1050
	vq->thread = clone(do_thread, stack + 32768, CLONE_VM | SIGCHLD, vq);
	if (vq->thread == (pid_t)-1)
		err(1, "Creating clone");
R
Rusty Russell 已提交
1051 1052

	/* We close our local copy now the child has it. */
1053
	close(vq->eventfd);
1054 1055
}

1056
static void start_device(struct device *dev)
R
Rusty Russell 已提交
1057
{
1058
	unsigned int i;
R
Rusty Russell 已提交
1059 1060
	struct virtqueue *vq;

1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
	verbose("Device %s OK: offered", dev->name);
	for (i = 0; i < dev->feature_len; i++)
		verbose(" %02x", get_feature_bits(dev)[i]);
	verbose(", accepted");
	for (i = 0; i < dev->feature_len; i++)
		verbose(" %02x", get_feature_bits(dev)
			[dev->feature_len+i]);

	for (vq = dev->vq; vq; vq = vq->next) {
		if (vq->service)
			create_thread(vq);
	}
	dev->running = true;
}

static void cleanup_devices(void)
{
	struct device *dev;

	for (dev = devices.dev; dev; dev = dev->next)
		reset_device(dev);
R
Rusty Russell 已提交
1082

1083 1084 1085 1086
	/* If we saved off the original terminal settings, restore them now. */
	if (orig_term.c_lflag & (ISIG|ICANON|ECHO))
		tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
}
R
Rusty Russell 已提交
1087

1088 1089 1090 1091 1092 1093 1094
/* When the Guest tells us they updated the status field, we handle it. */
static void update_device_status(struct device *dev)
{
	/* A zero status is a reset, otherwise it's a set of flags. */
	if (dev->desc->status == 0)
		reset_device(dev);
	else if (dev->desc->status & VIRTIO_CONFIG_S_FAILED) {
1095
		warnx("Device %s configuration FAILED", dev->name);
1096 1097
		if (dev->running)
			reset_device(dev);
1098 1099 1100 1101
	} else {
		if (dev->running)
			err(1, "Device %s features finalized twice", dev->name);
		start_device(dev);
R
Rusty Russell 已提交
1102 1103 1104
	}
}

R
Rusty Russell 已提交
1105 1106 1107 1108
/*L:215
 * This is the generic routine we call when the Guest uses LHCALL_NOTIFY.  In
 * particular, it's used to notify us of device status changes during boot.
 */
1109
static void handle_output(unsigned long addr)
1110 1111
{
	struct device *i;
R
Rusty Russell 已提交
1112

1113
	/* Check each device. */
R
Rusty Russell 已提交
1114
	for (i = devices.dev; i; i = i->next) {
1115 1116
		struct virtqueue *vq;

R
Rusty Russell 已提交
1117 1118 1119 1120
		/*
		 * Notifications to device descriptors mean they updated the
		 * device status.
		 */
R
Rusty Russell 已提交
1121
		if (from_guest_phys(addr) == i->desc) {
1122
			update_device_status(i);
R
Rusty Russell 已提交
1123 1124 1125
			return;
		}

1126
		/* Devices should not be used before features are finalized. */
R
Rusty Russell 已提交
1127
		for (vq = i->vq; vq; vq = vq->next) {
1128
			if (addr != vq->config.pfn*getpagesize())
R
Rusty Russell 已提交
1129
				continue;
1130
			errx(1, "Notification on %s before setup!", i->name);
1131 1132
		}
	}
1133

R
Rusty Russell 已提交
1134 1135 1136 1137 1138
	/*
	 * Early console write is done using notify on a nul-terminated string
	 * in Guest memory.  It's also great for hacking debugging messages
	 * into a Guest.
	 */
R
Rusty Russell 已提交
1139 1140 1141 1142 1143
	if (addr >= guest_limit)
		errx(1, "Bad NOTIFY %#lx", addr);

	write(STDOUT_FILENO, from_guest_phys(addr),
	      strnlen(from_guest_phys(addr), guest_limit - addr));
1144 1145
}

1146 1147 1148 1149 1150
/*L:190
 * Device Setup
 *
 * All devices need a descriptor so the Guest knows it exists, and a "struct
 * device" so the Launcher can keep track of it.  We have common helper
1151 1152
 * routines to allocate and manage them.
 */
1153

R
Rusty Russell 已提交
1154 1155
/*
 * The layout of the device page is a "struct lguest_device_desc" followed by a
1156 1157
 * number of virtqueue descriptors, then two sets of feature bits, then an
 * array of configuration bytes.  This routine returns the configuration
R
Rusty Russell 已提交
1158 1159
 * pointer.
 */
1160 1161 1162
static u8 *device_config(const struct device *dev)
{
	return (void *)(dev->desc + 1)
1163 1164
		+ dev->num_vq * sizeof(struct lguest_vqconfig)
		+ dev->feature_len * 2;
R
Rusty Russell 已提交
1165 1166
}

R
Rusty Russell 已提交
1167 1168
/*
 * This routine allocates a new "struct lguest_device_desc" from descriptor
1169
 * table page just above the Guest's normal memory.  It returns a pointer to
R
Rusty Russell 已提交
1170 1171
 * that descriptor.
 */
1172
static struct lguest_device_desc *new_dev_desc(u16 type)
R
Rusty Russell 已提交
1173
{
1174 1175
	struct lguest_device_desc d = { .type = type };
	void *p;
R
Rusty Russell 已提交
1176

1177 1178 1179 1180 1181 1182
	/* Figure out where the next device config is, based on the last one. */
	if (devices.lastdev)
		p = device_config(devices.lastdev)
			+ devices.lastdev->desc->config_len;
	else
		p = devices.descpage;
R
Rusty Russell 已提交
1183

1184 1185 1186
	/* We only have one page for all the descriptors. */
	if (p + sizeof(d) > (void *)devices.descpage + getpagesize())
		errx(1, "Too many devices");
R
Rusty Russell 已提交
1187

1188 1189
	/* p might not be aligned, so we memcpy in. */
	return memcpy(p, &d, sizeof(d));
R
Rusty Russell 已提交
1190 1191
}

R
Rusty Russell 已提交
1192 1193 1194 1195
/*
 * Each device descriptor is followed by the description of its virtqueues.  We
 * specify how many descriptors the virtqueue is to have.
 */
R
Rusty Russell 已提交
1196
static void add_virtqueue(struct device *dev, unsigned int num_descs,
1197
			  void (*service)(struct virtqueue *))
R
Rusty Russell 已提交
1198 1199 1200 1201 1202
{
	unsigned int pages;
	struct virtqueue **i, *vq = malloc(sizeof(*vq));
	void *p;

1203
	/* First we need some memory for this virtqueue. */
1204
	pages = (vring_size(num_descs, LGUEST_VRING_ALIGN) + getpagesize() - 1)
1205
		/ getpagesize();
R
Rusty Russell 已提交
1206 1207
	p = get_pages(pages);

1208 1209 1210 1211
	/* Initialize the virtqueue */
	vq->next = NULL;
	vq->last_avail_idx = 0;
	vq->dev = dev;
R
Rusty Russell 已提交
1212 1213 1214 1215 1216

	/*
	 * This is the routine the service thread will run, and its Process ID
	 * once it's running.
	 */
1217 1218
	vq->service = service;
	vq->thread = (pid_t)-1;
1219

R
Rusty Russell 已提交
1220 1221 1222 1223 1224 1225
	/* Initialize the configuration. */
	vq->config.num = num_descs;
	vq->config.irq = devices.next_irq++;
	vq->config.pfn = to_guest_phys(p) / getpagesize();

	/* Initialize the vring. */
1226
	vring_init(&vq->vring, num_descs, p, LGUEST_VRING_ALIGN);
R
Rusty Russell 已提交
1227

R
Rusty Russell 已提交
1228 1229
	/*
	 * Append virtqueue to this device's descriptor.  We use
1230 1231
	 * device_config() to get the end of the device's current virtqueues;
	 * we check that we haven't added any config or feature information
R
Rusty Russell 已提交
1232 1233
	 * yet, otherwise we'd be overwriting them.
	 */
1234 1235
	assert(dev->desc->config_len == 0 && dev->desc->feature_len == 0);
	memcpy(device_config(dev), &vq->config, sizeof(vq->config));
1236
	dev->num_vq++;
1237 1238 1239
	dev->desc->num_vq++;

	verbose("Virtqueue page %#lx\n", to_guest_phys(p));
R
Rusty Russell 已提交
1240

R
Rusty Russell 已提交
1241 1242 1243 1244
	/*
	 * Add to tail of list, so dev->vq is first vq, dev->vq->next is
	 * second.
	 */
R
Rusty Russell 已提交
1245 1246
	for (i = &dev->vq; *i; i = &(*i)->next);
	*i = vq;
1247 1248
}

R
Rusty Russell 已提交
1249 1250 1251 1252
/*
 * The first half of the feature bitmask is for us to advertise features.  The
 * second half is for the Guest to accept features.
 */
1253 1254
static void add_feature(struct device *dev, unsigned bit)
{
R
Rusty Russell 已提交
1255
	u8 *features = get_feature_bits(dev);
1256 1257 1258 1259

	/* We can't extend the feature bits once we've added config bytes */
	if (dev->desc->feature_len <= bit / CHAR_BIT) {
		assert(dev->desc->config_len == 0);
1260
		dev->feature_len = dev->desc->feature_len = (bit/CHAR_BIT) + 1;
1261 1262 1263 1264 1265
	}

	features[bit / CHAR_BIT] |= (1 << (bit % CHAR_BIT));
}

R
Rusty Russell 已提交
1266 1267
/*
 * This routine sets the configuration fields for an existing device's
1268
 * descriptor.  It only works for the last device, but that's OK because that's
R
Rusty Russell 已提交
1269 1270
 * how we use it.
 */
1271 1272 1273 1274 1275 1276 1277 1278 1279
static void set_config(struct device *dev, unsigned len, const void *conf)
{
	/* Check we haven't overflowed our single page. */
	if (device_config(dev) + len > devices.descpage + getpagesize())
		errx(1, "Too many devices");

	/* Copy in the config information, and store the length. */
	memcpy(device_config(dev), conf, len);
	dev->desc->config_len = len;
1280 1281 1282

	/* Size must fit in config_len field (8 bits)! */
	assert(dev->desc->config_len == len);
1283 1284
}

R
Rusty Russell 已提交
1285 1286
/*
 * This routine does all the creation and setup of a new device, including
R
Rusty Russell 已提交
1287 1288
 * calling new_dev_desc() to allocate the descriptor and device memory.  We
 * don't actually start the service threads until later.
1289
 *
R
Rusty Russell 已提交
1290 1291
 * See what I mean about userspace being boring?
 */
1292
static struct device *new_device(const char *name, u16 type)
1293 1294 1295
{
	struct device *dev = malloc(sizeof(*dev));

1296
	/* Now we populate the fields one at a time. */
R
Rusty Russell 已提交
1297 1298
	dev->desc = new_dev_desc(type);
	dev->name = name;
1299
	dev->vq = NULL;
1300 1301
	dev->feature_len = 0;
	dev->num_vq = 0;
1302
	dev->running = false;
1303
	dev->next = NULL;
1304

R
Rusty Russell 已提交
1305 1306
	/*
	 * Append to device list.  Prepending to a single-linked list is
1307 1308
	 * easier, but the user expects the devices to be arranged on the bus
	 * in command-line order.  The first network device on the command line
R
Rusty Russell 已提交
1309 1310
	 * is eth0, the first block device /dev/vda, etc.
	 */
1311 1312 1313 1314 1315 1316
	if (devices.lastdev)
		devices.lastdev->next = dev;
	else
		devices.dev = dev;
	devices.lastdev = dev;

1317 1318 1319
	return dev;
}

R
Rusty Russell 已提交
1320 1321 1322 1323
/*
 * Our first setup routine is the console.  It's a fairly simple device, but
 * UNIX tty handling makes it uglier than it could be.
 */
R
Rusty Russell 已提交
1324
static void setup_console(void)
1325 1326 1327
{
	struct device *dev;

1328
	/* If we can save the initial standard input settings... */
1329 1330
	if (tcgetattr(STDIN_FILENO, &orig_term) == 0) {
		struct termios term = orig_term;
R
Rusty Russell 已提交
1331 1332 1333 1334
		/*
		 * Then we turn off echo, line buffering and ^C etc: We want a
		 * raw input stream to the Guest.
		 */
1335 1336 1337 1338
		term.c_lflag &= ~(ISIG|ICANON|ECHO);
		tcsetattr(STDIN_FILENO, TCSANOW, &term);
	}

1339 1340
	dev = new_device("console", VIRTIO_ID_CONSOLE);

1341
	/* We store the console state in dev->priv, and initialize it. */
1342 1343 1344
	dev->priv = malloc(sizeof(struct console_abort));
	((struct console_abort *)dev->priv)->count = 0;

R
Rusty Russell 已提交
1345 1346
	/*
	 * The console needs two virtqueues: the input then the output.  When
1347 1348
	 * they put something the input queue, we make sure we're listening to
	 * stdin.  When they put something in the output queue, we write it to
R
Rusty Russell 已提交
1349 1350
	 * stdout.
	 */
1351 1352
	add_virtqueue(dev, VIRTQUEUE_NUM, console_input);
	add_virtqueue(dev, VIRTQUEUE_NUM, console_output);
R
Rusty Russell 已提交
1353

1354
	verbose("device %u: console\n", ++devices.device_num);
1355
}
R
Rusty Russell 已提交
1356
/*:*/
1357

R
Rusty Russell 已提交
1358 1359
/*M:010
 * Inter-guest networking is an interesting area.  Simplest is to have a
R
Rusty Russell 已提交
1360 1361
 * --sharenet=<name> option which opens or creates a named pipe.  This can be
 * used to send packets to another guest in a 1:1 manner.
1362
 *
R
Rusty Russell 已提交
1363
 * More sophisticated is to use one of the tools developed for project like UML
R
Rusty Russell 已提交
1364
 * to do networking.
1365
 *
R
Rusty Russell 已提交
1366 1367 1368 1369 1370 1371 1372
 * Faster is to do virtio bonding in kernel.  Doing this 1:1 would be
 * completely generic ("here's my vring, attach to your vring") and would work
 * for any traffic.  Of course, namespace and permissions issues need to be
 * dealt with.  A more sophisticated "multi-channel" virtio_net.c could hide
 * multiple inter-guest channels behind one interface, although it would
 * require some manner of hotplugging new virtio channels.
 *
R
Rusty Russell 已提交
1373
 * Finally, we could use a virtio network switch in the kernel, ie. vhost.
R
Rusty Russell 已提交
1374
:*/
1375 1376 1377

static u32 str2ip(const char *ipaddr)
{
1378
	unsigned int b[4];
1379

1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
	if (sscanf(ipaddr, "%u.%u.%u.%u", &b[0], &b[1], &b[2], &b[3]) != 4)
		errx(1, "Failed to parse IP address '%s'", ipaddr);
	return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
}

static void str2mac(const char *macaddr, unsigned char mac[6])
{
	unsigned int m[6];
	if (sscanf(macaddr, "%02x:%02x:%02x:%02x:%02x:%02x",
		   &m[0], &m[1], &m[2], &m[3], &m[4], &m[5]) != 6)
		errx(1, "Failed to parse mac address '%s'", macaddr);
	mac[0] = m[0];
	mac[1] = m[1];
	mac[2] = m[2];
	mac[3] = m[3];
	mac[4] = m[4];
	mac[5] = m[5];
1397 1398
}

R
Rusty Russell 已提交
1399 1400
/*
 * This code is "adapted" from libbridge: it attaches the Host end of the
1401 1402 1403
 * network device to the bridge device specified by the command line.
 *
 * This is yet another James Morris contribution (I'm an IP-level guy, so I
R
Rusty Russell 已提交
1404 1405
 * dislike bridging), and I just try not to break it.
 */
1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
static void add_to_bridge(int fd, const char *if_name, const char *br_name)
{
	int ifidx;
	struct ifreq ifr;

	if (!*br_name)
		errx(1, "must specify bridge name");

	ifidx = if_nametoindex(if_name);
	if (!ifidx)
		errx(1, "interface %s does not exist!", if_name);

	strncpy(ifr.ifr_name, br_name, IFNAMSIZ);
1419
	ifr.ifr_name[IFNAMSIZ-1] = '\0';
1420 1421 1422 1423 1424
	ifr.ifr_ifindex = ifidx;
	if (ioctl(fd, SIOCBRADDIF, &ifr) < 0)
		err(1, "can't add %s to bridge %s", if_name, br_name);
}

R
Rusty Russell 已提交
1425 1426
/*
 * This sets up the Host end of the network device with an IP address, brings
1427
 * it up so packets will flow, the copies the MAC address into the hwaddr
R
Rusty Russell 已提交
1428 1429
 * pointer.
 */
1430
static void configure_device(int fd, const char *tapif, u32 ipaddr)
1431 1432
{
	struct ifreq ifr;
1433
	struct sockaddr_in sin;
1434 1435

	memset(&ifr, 0, sizeof(ifr));
1436 1437 1438
	strcpy(ifr.ifr_name, tapif);

	/* Don't read these incantations.  Just cut & paste them like I did! */
1439 1440 1441
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = htonl(ipaddr);
	memcpy(&ifr.ifr_addr, &sin, sizeof(sin));
1442
	if (ioctl(fd, SIOCSIFADDR, &ifr) != 0)
1443
		err(1, "Setting %s interface address", tapif);
1444 1445
	ifr.ifr_flags = IFF_UP;
	if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0)
1446 1447 1448 1449
		err(1, "Bringing interface %s up", tapif);
}

static int get_tun_device(char tapif[IFNAMSIZ])
1450 1451
{
	struct ifreq ifr;
1452 1453 1454 1455
	int netfd;

	/* Start with this zeroed.  Messy but sure. */
	memset(&ifr, 0, sizeof(ifr));
1456

R
Rusty Russell 已提交
1457 1458
	/*
	 * We open the /dev/net/tun device and tell it we want a tap device.  A
1459 1460
	 * tap device is like a tun device, only somehow different.  To tell
	 * the truth, I completely blundered my way through this code, but it
R
Rusty Russell 已提交
1461 1462
	 * works now!
	 */
1463
	netfd = open_or_die("/dev/net/tun", O_RDWR);
1464
	ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_VNET_HDR;
1465 1466 1467
	strcpy(ifr.ifr_name, "tap%d");
	if (ioctl(netfd, TUNSETIFF, &ifr) != 0)
		err(1, "configuring /dev/net/tun");
1468

1469 1470 1471 1472
	if (ioctl(netfd, TUNSETOFFLOAD,
		  TUN_F_CSUM|TUN_F_TSO4|TUN_F_TSO6|TUN_F_TSO_ECN) != 0)
		err(1, "Could not set features for tun device");

R
Rusty Russell 已提交
1473 1474 1475 1476
	/*
	 * We don't need checksums calculated for packets coming in this
	 * device: trust us!
	 */
1477 1478
	ioctl(netfd, TUNSETNOCSUM, 1);

1479 1480 1481 1482
	memcpy(tapif, ifr.ifr_name, IFNAMSIZ);
	return netfd;
}

R
Rusty Russell 已提交
1483 1484
/*L:195
 * Our network is a Host<->Guest network.  This can either use bridging or
1485 1486
 * routing, but the principle is the same: it uses the "tun" device to inject
 * packets into the Host as if they came in from a normal network card.  We
R
Rusty Russell 已提交
1487 1488
 * just shunt packets between the Guest and the tun device.
 */
1489 1490 1491
static void setup_tun_net(char *arg)
{
	struct device *dev;
1492 1493
	struct net_info *net_info = malloc(sizeof(*net_info));
	int ipfd;
1494 1495 1496 1497 1498
	u32 ip = INADDR_ANY;
	bool bridging = false;
	char tapif[IFNAMSIZ], *p;
	struct virtio_net_config conf;

1499
	net_info->tunfd = get_tun_device(tapif);
1500

R
Rusty Russell 已提交
1501
	/* First we create a new network device. */
1502 1503
	dev = new_device("net", VIRTIO_ID_NET);
	dev->priv = net_info;
1504

R
Rusty Russell 已提交
1505
	/* Network devices need a recv and a send queue, just like console. */
1506 1507
	add_virtqueue(dev, VIRTQUEUE_NUM, net_input);
	add_virtqueue(dev, VIRTQUEUE_NUM, net_output);
1508

R
Rusty Russell 已提交
1509 1510 1511 1512
	/*
	 * We need a socket to perform the magic network ioctls to bring up the
	 * tap interface, connect to the bridge etc.  Any socket will do!
	 */
1513 1514 1515 1516
	ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
	if (ipfd < 0)
		err(1, "opening IP socket");

1517
	/* If the command line was --tunnet=bridge:<name> do bridging. */
1518
	if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) {
1519 1520 1521 1522 1523 1524 1525 1526
		arg += strlen(BRIDGE_PFX);
		bridging = true;
	}

	/* A mac address may follow the bridge name or IP address */
	p = strchr(arg, ':');
	if (p) {
		str2mac(p+1, conf.mac);
1527
		add_feature(dev, VIRTIO_NET_F_MAC);
1528 1529 1530 1531 1532 1533 1534
		*p = '\0';
	}

	/* arg is now either an IP address or a bridge name */
	if (bridging)
		add_to_bridge(ipfd, tapif, arg);
	else
1535 1536
		ip = str2ip(arg);

1537 1538
	/* Set up the tun device. */
	configure_device(ipfd, tapif, ip);
1539

1540 1541 1542 1543 1544 1545 1546 1547 1548
	/* Expect Guest to handle everything except UFO */
	add_feature(dev, VIRTIO_NET_F_CSUM);
	add_feature(dev, VIRTIO_NET_F_GUEST_CSUM);
	add_feature(dev, VIRTIO_NET_F_GUEST_TSO4);
	add_feature(dev, VIRTIO_NET_F_GUEST_TSO6);
	add_feature(dev, VIRTIO_NET_F_GUEST_ECN);
	add_feature(dev, VIRTIO_NET_F_HOST_TSO4);
	add_feature(dev, VIRTIO_NET_F_HOST_TSO6);
	add_feature(dev, VIRTIO_NET_F_HOST_ECN);
1549 1550
	/* We handle indirect ring entries */
	add_feature(dev, VIRTIO_RING_F_INDIRECT_DESC);
1551 1552
	/* We're compliant with the damn spec. */
	add_feature(dev, VIRTIO_F_ANY_LAYOUT);
1553
	set_config(dev, sizeof(conf), &conf);
1554

1555
	/* We don't need the socket any more; setup is done. */
1556 1557
	close(ipfd);

1558 1559 1560 1561 1562 1563 1564 1565
	devices.device_num++;

	if (bridging)
		verbose("device %u: tun %s attached to bridge: %s\n",
			devices.device_num, tapif, arg);
	else
		verbose("device %u: tun %s: %s\n",
			devices.device_num, tapif, arg);
1566
}
R
Rusty Russell 已提交
1567
/*:*/
R
Rusty Russell 已提交
1568

R
Rusty Russell 已提交
1569
/* This hangs off device->priv. */
1570
struct vblk_info {
R
Rusty Russell 已提交
1571 1572 1573 1574 1575 1576 1577 1578
	/* The size of the file. */
	off64_t len;

	/* The file descriptor for the file. */
	int fd;

};

R
Rusty Russell 已提交
1579 1580 1581
/*L:210
 * The Disk
 *
R
Rusty Russell 已提交
1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
 * The disk only has one virtqueue, so it only has one thread.  It is really
 * simple: the Guest asks for a block number and we read or write that position
 * in the file.
 *
 * Before we serviced each virtqueue in a separate thread, that was unacceptably
 * slow: the Guest waits until the read is finished before running anything
 * else, even if it could have been doing useful work.
 *
 * We could have used async I/O, except it's reputed to suck so hard that
 * characters actually go missing from your code when you try to use it.
R
Rusty Russell 已提交
1592
 */
1593
static void blk_request(struct virtqueue *vq)
R
Rusty Russell 已提交
1594
{
1595
	struct vblk_info *vblk = vq->dev->priv;
R
Rusty Russell 已提交
1596
	unsigned int head, out_num, in_num, wlen;
1597
	int ret, i;
1598
	u8 *in;
1599
	struct virtio_blk_outhdr out;
1600
	struct iovec iov[vq->vring.num];
R
Rusty Russell 已提交
1601 1602
	off64_t off;

R
Rusty Russell 已提交
1603 1604 1605 1606
	/*
	 * Get the next request, where we normally wait.  It triggers the
	 * interrupt to acknowledge previously serviced requests (if any).
	 */
1607
	head = wait_for_vq_desc(vq, iov, &out_num, &in_num);
R
Rusty Russell 已提交
1608

1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
	/* Copy the output header from the front of the iov (adjusts iov) */
	iov_consume(iov, out_num, &out, sizeof(out));

	/* Find and trim end of iov input array, for our status byte. */
	in = NULL;
	for (i = out_num + in_num - 1; i >= out_num; i--) {
		if (iov[i].iov_len > 0) {
			in = iov[i].iov_base + iov[i].iov_len - 1;
			iov[i].iov_len--;
			break;
		}
	}
	if (!in)
		errx(1, "Bad virtblk cmd with no room for status");
R
Rusty Russell 已提交
1623

R
Rusty Russell 已提交
1624 1625 1626 1627
	/*
	 * For historical reasons, block operations are expressed in 512 byte
	 * "sectors".
	 */
1628
	off = out.sector * 512;
R
Rusty Russell 已提交
1629

R
Rusty Russell 已提交
1630 1631 1632 1633
	/*
	 * In general the virtio block driver is allowed to try SCSI commands.
	 * It'd be nice if we supported eject, for example, but we don't.
	 */
1634
	if (out.type & VIRTIO_BLK_T_SCSI_CMD) {
R
Rusty Russell 已提交
1635
		fprintf(stderr, "Scsi commands unsupported\n");
1636
		*in = VIRTIO_BLK_S_UNSUPP;
1637
		wlen = sizeof(*in);
1638
	} else if (out.type & VIRTIO_BLK_T_OUT) {
R
Rusty Russell 已提交
1639 1640 1641 1642 1643 1644
		/*
		 * Write
		 *
		 * Move to the right location in the block file.  This can fail
		 * if they try to write past end.
		 */
R
Rusty Russell 已提交
1645
		if (lseek64(vblk->fd, off, SEEK_SET) != off)
1646
			err(1, "Bad seek to sector %llu", out.sector);
R
Rusty Russell 已提交
1647

1648 1649
		ret = writev(vblk->fd, iov, out_num);
		verbose("WRITE to sector %llu: %i\n", out.sector, ret);
R
Rusty Russell 已提交
1650

R
Rusty Russell 已提交
1651 1652
		/*
		 * Grr... Now we know how long the descriptor they sent was, we
R
Rusty Russell 已提交
1653
		 * make sure they didn't try to write over the end of the block
R
Rusty Russell 已提交
1654 1655
		 * file (possibly extending it).
		 */
R
Rusty Russell 已提交
1656 1657 1658 1659 1660 1661
		if (ret > 0 && off + ret > vblk->len) {
			/* Trim it back to the correct length */
			ftruncate64(vblk->fd, vblk->len);
			/* Die, bad Guest, die. */
			errx(1, "Write past end %llu+%u", off, ret);
		}
1662 1663 1664

		wlen = sizeof(*in);
		*in = (ret >= 0 ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR);
1665
	} else if (out.type & VIRTIO_BLK_T_FLUSH) {
1666 1667 1668
		/* Flush */
		ret = fdatasync(vblk->fd);
		verbose("FLUSH fdatasync: %i\n", ret);
1669
		wlen = sizeof(*in);
1670
		*in = (ret >= 0 ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR);
R
Rusty Russell 已提交
1671
	} else {
R
Rusty Russell 已提交
1672 1673 1674 1675 1676 1677
		/*
		 * Read
		 *
		 * Move to the right location in the block file.  This can fail
		 * if they try to read past end.
		 */
R
Rusty Russell 已提交
1678
		if (lseek64(vblk->fd, off, SEEK_SET) != off)
1679
			err(1, "Bad seek to sector %llu", out.sector);
R
Rusty Russell 已提交
1680

1681
		ret = readv(vblk->fd, iov + out_num, in_num);
R
Rusty Russell 已提交
1682
		if (ret >= 0) {
1683
			wlen = sizeof(*in) + ret;
1684
			*in = VIRTIO_BLK_S_OK;
R
Rusty Russell 已提交
1685
		} else {
1686
			wlen = sizeof(*in);
1687
			*in = VIRTIO_BLK_S_IOERR;
R
Rusty Russell 已提交
1688 1689 1690
		}
	}

R
Rusty Russell 已提交
1691
	/* Finished that request. */
1692
	add_used(vq, head, wlen);
R
Rusty Russell 已提交
1693 1694
}

R
Rusty Russell 已提交
1695
/*L:198 This actually sets up a virtual block device. */
R
Rusty Russell 已提交
1696 1697 1698 1699
static void setup_block_file(const char *filename)
{
	struct device *dev;
	struct vblk_info *vblk;
1700
	struct virtio_blk_config conf;
R
Rusty Russell 已提交
1701

R
Rusty Russell 已提交
1702
	/* Creat the device. */
1703
	dev = new_device("block", VIRTIO_ID_BLOCK);
R
Rusty Russell 已提交
1704

R
Rusty Russell 已提交
1705
	/* The device has one virtqueue, where the Guest places requests. */
1706
	add_virtqueue(dev, VIRTQUEUE_NUM, blk_request);
R
Rusty Russell 已提交
1707 1708 1709 1710 1711 1712 1713 1714

	/* Allocate the room for our own bookkeeping */
	vblk = dev->priv = malloc(sizeof(*vblk));

	/* First we open the file and store the length. */
	vblk->fd = open_or_die(filename, O_RDWR|O_LARGEFILE);
	vblk->len = lseek64(vblk->fd, 0, SEEK_END);

1715 1716
	/* We support FLUSH. */
	add_feature(dev, VIRTIO_BLK_F_FLUSH);
1717

R
Rusty Russell 已提交
1718
	/* Tell Guest how many sectors this device has. */
1719
	conf.capacity = cpu_to_le64(vblk->len / 512);
R
Rusty Russell 已提交
1720

R
Rusty Russell 已提交
1721 1722 1723 1724
	/*
	 * Tell Guest not to put in too many descriptors at once: two are used
	 * for the in and out elements.
	 */
1725 1726 1727
	add_feature(dev, VIRTIO_BLK_F_SEG_MAX);
	conf.seg_max = cpu_to_le32(VIRTQUEUE_NUM - 2);

1728 1729
	/* Don't try to put whole struct: we have 8 bit limit. */
	set_config(dev, offsetof(struct virtio_blk_config, geometry), &conf);
R
Rusty Russell 已提交
1730 1731

	verbose("device %u: virtblock %llu sectors\n",
1732
		++devices.device_num, le64_to_cpu(conf.capacity));
R
Rusty Russell 已提交
1733
}
R
Rusty Russell 已提交
1734

R
Rusty Russell 已提交
1735
/*L:211
1736
 * Our random number generator device reads from /dev/urandom into the Guest's
R
Rusty Russell 已提交
1737
 * input buffers.  The usual case is that the Guest doesn't want random numbers
1738
 * and so has no buffers although /dev/urandom is still readable, whereas
R
Rusty Russell 已提交
1739 1740
 * console is the reverse.
 *
R
Rusty Russell 已提交
1741 1742 1743 1744 1745 1746
 * The same logic applies, however.
 */
struct rng_info {
	int rfd;
};

1747
static void rng_input(struct virtqueue *vq)
R
Rusty Russell 已提交
1748 1749 1750
{
	int len;
	unsigned int head, in_num, out_num, totlen = 0;
1751 1752
	struct rng_info *rng_info = vq->dev->priv;
	struct iovec iov[vq->vring.num];
R
Rusty Russell 已提交
1753 1754

	/* First we need a buffer from the Guests's virtqueue. */
1755
	head = wait_for_vq_desc(vq, iov, &out_num, &in_num);
R
Rusty Russell 已提交
1756 1757 1758
	if (out_num)
		errx(1, "Output buffers in rng?");

R
Rusty Russell 已提交
1759
	/*
R
Rusty Russell 已提交
1760 1761
	 * Just like the console write, we loop to cover the whole iovec.
	 * In this case, short reads actually happen quite a bit.
R
Rusty Russell 已提交
1762
	 */
R
Rusty Russell 已提交
1763
	while (!iov_empty(iov, in_num)) {
1764
		len = readv(rng_info->rfd, iov, in_num);
R
Rusty Russell 已提交
1765
		if (len <= 0)
1766
			err(1, "Read from /dev/urandom gave %i", len);
1767
		iov_consume(iov, in_num, NULL, len);
R
Rusty Russell 已提交
1768 1769 1770 1771
		totlen += len;
	}

	/* Tell the Guest about the new input. */
1772
	add_used(vq, head, totlen);
R
Rusty Russell 已提交
1773 1774
}

R
Rusty Russell 已提交
1775 1776 1777
/*L:199
 * This creates a "hardware" random number device for the Guest.
 */
R
Rusty Russell 已提交
1778 1779 1780
static void setup_rng(void)
{
	struct device *dev;
1781
	struct rng_info *rng_info = malloc(sizeof(*rng_info));
R
Rusty Russell 已提交
1782

1783 1784
	/* Our device's private info simply contains the /dev/urandom fd. */
	rng_info->rfd = open_or_die("/dev/urandom", O_RDONLY);
R
Rusty Russell 已提交
1785

R
Rusty Russell 已提交
1786
	/* Create the new device. */
1787 1788
	dev = new_device("rng", VIRTIO_ID_RNG);
	dev->priv = rng_info;
R
Rusty Russell 已提交
1789 1790

	/* The device has one virtqueue, where the Guest places inbufs. */
1791
	add_virtqueue(dev, VIRTQUEUE_NUM, rng_input);
R
Rusty Russell 已提交
1792 1793 1794

	verbose("device %u: rng\n", devices.device_num++);
}
1795
/* That's the end of device setup. */
B
Balaji Rao 已提交
1796

1797
/*L:230 Reboot is pretty easy: clean up and exec() the Launcher afresh. */
B
Balaji Rao 已提交
1798 1799 1800 1801
static void __attribute__((noreturn)) restart_guest(void)
{
	unsigned int i;

R
Rusty Russell 已提交
1802 1803 1804 1805
	/*
	 * Since we don't track all open fds, we simply close everything beyond
	 * stderr.
	 */
B
Balaji Rao 已提交
1806 1807
	for (i = 3; i < FD_SETSIZE; i++)
		close(i);
1808

1809 1810 1811
	/* Reset all the devices (kills all threads). */
	cleanup_devices();

B
Balaji Rao 已提交
1812 1813 1814
	execv(main_args[0], main_args);
	err(1, "Could not exec %s", main_args[0]);
}
1815

R
Rusty Russell 已提交
1816 1817 1818 1819
/*L:220
 * Finally we reach the core of the Launcher which runs the Guest, serves
 * its input and output, and finally, lays it to rest.
 */
1820
static void __attribute__((noreturn)) run_guest(void)
1821 1822
{
	for (;;) {
1823
		struct lguest_pending notify;
1824 1825 1826
		int readval;

		/* We read from the /dev/lguest device to run the Guest. */
1827
		readval = pread(lguest_fd, &notify, sizeof(notify), cpu_id);
1828

R
Rusty Russell 已提交
1829
		/* One unsigned long means the Guest did HCALL_NOTIFY */
1830 1831 1832 1833 1834 1835 1836 1837
		if (readval == sizeof(notify)) {
			if (notify.trap == 0x1F) {
				verbose("Notify on address %#08x\n",
					notify.addr);
				handle_output(notify.addr);
			} else
				errx(1, "Unknown trap %i addr %#08x\n",
				     notify.trap, notify.addr);
1838
		/* ENOENT means the Guest died.  Reading tells us why. */
1839 1840
		} else if (errno == ENOENT) {
			char reason[1024] = { 0 };
1841
			pread(lguest_fd, reason, sizeof(reason)-1, cpu_id);
1842
			errx(1, "%s", reason);
B
Balaji Rao 已提交
1843 1844 1845
		/* ERESTART means that we need to reboot the guest */
		} else if (errno == ERESTART) {
			restart_guest();
1846 1847
		/* Anything else means a bug or incompatible change. */
		} else
1848 1849 1850
			err(1, "Running guest failed");
	}
}
1851
/*L:240
R
Rusty Russell 已提交
1852 1853 1854
 * This is the end of the Launcher.  The good news: we are over halfway
 * through!  The bad news: the most fiendish part of the code still lies ahead
 * of us.
1855
 *
R
Rusty Russell 已提交
1856 1857
 * Are you ready?  Take a deep breath and join me in the core of the Host, in
 * "make Host".
R
Rusty Russell 已提交
1858
:*/
1859 1860 1861 1862 1863

static struct option opts[] = {
	{ "verbose", 0, NULL, 'v' },
	{ "tunnet", 1, NULL, 't' },
	{ "block", 1, NULL, 'b' },
R
Rusty Russell 已提交
1864
	{ "rng", 0, NULL, 'r' },
1865
	{ "initrd", 1, NULL, 'i' },
1866 1867
	{ "username", 1, NULL, 'u' },
	{ "chroot", 1, NULL, 'c' },
1868 1869 1870 1871 1872
	{ NULL },
};
static void usage(void)
{
	errx(1, "Usage: lguest [--verbose] "
1873
	     "[--tunnet=(<ipaddr>:<macaddr>|bridge:<bridgename>:<macaddr>)\n"
1874 1875 1876 1877
	     "|--block=<filename>|--initrd=<filename>]...\n"
	     "<mem-in-mb> vmlinux [args...]");
}

1878
/*L:105 The main routine is where the real work begins: */
1879 1880
int main(int argc, char *argv[])
{
R
Rusty Russell 已提交
1881
	/* Memory, code startpoint and size of the (optional) initrd. */
1882
	unsigned long mem = 0, start, initrd_size = 0;
1883 1884
	/* Two temporaries. */
	int i, c;
1885
	/* The boot information for the Guest. */
1886
	struct boot_params *boot;
1887
	/* If they specify an initrd file to load. */
1888 1889
	const char *initrd_name = NULL;

1890 1891 1892 1893 1894 1895
	/* Password structure for initgroups/setres[gu]id */
	struct passwd *user_details = NULL;

	/* Directory to chroot to */
	char *chroot_path = NULL;

B
Balaji Rao 已提交
1896 1897 1898
	/* Save the args: we "reboot" by execing ourselves again. */
	main_args = argv;

R
Rusty Russell 已提交
1899 1900
	/*
	 * First we initialize the device list.  We keep a pointer to the last
1901
	 * device, and the next interrupt number to use for devices (1:
R
Rusty Russell 已提交
1902 1903
	 * remember that 0 is used by the timer).
	 */
1904
	devices.lastdev = NULL;
R
Rusty Russell 已提交
1905
	devices.next_irq = 1;
1906

R
Rusty Russell 已提交
1907
	/* We're CPU 0.  In fact, that's the only CPU possible right now. */
1908
	cpu_id = 0;
R
Rusty Russell 已提交
1909

R
Rusty Russell 已提交
1910 1911
	/*
	 * We need to know how much memory so we can set up the device
1912 1913
	 * descriptor and memory pages for the devices as we parse the command
	 * line.  So we quickly look through the arguments to find the amount
R
Rusty Russell 已提交
1914 1915
	 * of memory now.
	 */
1916 1917
	for (i = 1; i < argc; i++) {
		if (argv[i][0] != '-') {
1918
			mem = atoi(argv[i]) * 1024 * 1024;
R
Rusty Russell 已提交
1919 1920
			/*
			 * We start by mapping anonymous pages over all of
1921 1922
			 * guest-physical memory range.  This fills it with 0,
			 * and ensures that the Guest won't be killed when it
R
Rusty Russell 已提交
1923 1924
			 * tries to access it.
			 */
1925 1926 1927 1928
			guest_base = map_zeroed_pages(mem / getpagesize()
						      + DEVICE_PAGES);
			guest_limit = mem;
			guest_max = mem + DEVICE_PAGES*getpagesize();
R
Rusty Russell 已提交
1929
			devices.descpage = get_pages(1);
1930 1931 1932
			break;
		}
	}
1933 1934

	/* The options are fairly straight-forward */
1935 1936 1937 1938 1939 1940
	while ((c = getopt_long(argc, argv, "v", opts, NULL)) != EOF) {
		switch (c) {
		case 'v':
			verbose = true;
			break;
		case 't':
R
Rusty Russell 已提交
1941
			setup_tun_net(optarg);
1942 1943
			break;
		case 'b':
R
Rusty Russell 已提交
1944
			setup_block_file(optarg);
1945
			break;
R
Rusty Russell 已提交
1946 1947 1948
		case 'r':
			setup_rng();
			break;
1949 1950 1951
		case 'i':
			initrd_name = optarg;
			break;
1952 1953 1954 1955 1956 1957 1958 1959
		case 'u':
			user_details = getpwnam(optarg);
			if (!user_details)
				err(1, "getpwnam failed, incorrect username?");
			break;
		case 'c':
			chroot_path = optarg;
			break;
1960 1961 1962 1963 1964
		default:
			warnx("Unknown argument %s", argv[optind]);
			usage();
		}
	}
R
Rusty Russell 已提交
1965 1966 1967 1968
	/*
	 * After the other arguments we expect memory and kernel image name,
	 * followed by command line arguments for the kernel.
	 */
1969 1970 1971
	if (optind + 2 > argc)
		usage();

1972 1973
	verbose("Guest base is at %p\n", guest_base);

1974
	/* We always have a console device */
R
Rusty Russell 已提交
1975
	setup_console();
1976 1977

	/* Now we load the kernel */
1978
	start = load_kernel(open_or_die(argv[optind+1], O_RDONLY));
1979

1980 1981 1982
	/* Boot information is stashed at physical address 0 */
	boot = from_guest_phys(0);

1983
	/* Map the initrd image if requested (at top of physical memory) */
1984 1985
	if (initrd_name) {
		initrd_size = load_initrd(initrd_name, mem);
R
Rusty Russell 已提交
1986 1987 1988 1989
		/*
		 * These are the location in the Linux boot header where the
		 * start and size of the initrd are expected to be found.
		 */
1990 1991
		boot->hdr.ramdisk_image = mem - initrd_size;
		boot->hdr.ramdisk_size = initrd_size;
1992
		/* The bootloader type 0xFF means "unknown"; that's OK. */
1993
		boot->hdr.type_of_loader = 0xFF;
1994 1995
	}

R
Rusty Russell 已提交
1996 1997 1998 1999
	/*
	 * The Linux boot header contains an "E820" memory map: ours is a
	 * simple, single region.
	 */
2000 2001
	boot->e820_entries = 1;
	boot->e820_map[0] = ((struct e820entry) { 0, mem, E820_RAM });
R
Rusty Russell 已提交
2002 2003 2004 2005
	/*
	 * The boot header contains a command line pointer: we put the command
	 * line after the boot header.
	 */
2006
	boot->hdr.cmd_line_ptr = to_guest_phys(boot + 1);
R
Rusty Russell 已提交
2007
	/* We use a simple helper to copy the arguments separated by spaces. */
2008
	concat((char *)(boot + 1), argv+optind+2);
2009

2010 2011 2012
	/* Set kernel alignment to 16M (CONFIG_PHYSICAL_ALIGN) */
	boot->hdr.kernel_alignment = 0x1000000;

2013
	/* Boot protocol version: 2.07 supports the fields for lguest. */
2014
	boot->hdr.version = 0x207;
2015 2016

	/* The hardware_subarch value of "1" tells the Guest it's an lguest. */
2017
	boot->hdr.hardware_subarch = 1;
2018

2019 2020
	/* Tell the entry path not to try to reload segment registers. */
	boot->hdr.loadflags |= KEEP_SEGMENTS;
2021

R
Rusty Russell 已提交
2022
	/* We tell the kernel to initialize the Guest. */
2023
	tell_kernel(start);
2024

R
Rusty Russell 已提交
2025
	/* Ensure that we terminate if a device-servicing child dies. */
2026 2027 2028 2029
	signal(SIGCHLD, kill_launcher);

	/* If we exit via err(), this kills all the threads, restores tty. */
	atexit(cleanup_devices);
2030

2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
	/* If requested, chroot to a directory */
	if (chroot_path) {
		if (chroot(chroot_path) != 0)
			err(1, "chroot(\"%s\") failed", chroot_path);

		if (chdir("/") != 0)
			err(1, "chdir(\"/\") failed");

		verbose("chroot done\n");
	}

	/* If requested, drop privileges */
	if (user_details) {
		uid_t u;
		gid_t g;

		u = user_details->pw_uid;
		g = user_details->pw_gid;

		if (initgroups(user_details->pw_name, g) != 0)
			err(1, "initgroups failed");

		if (setresgid(g, g, g) != 0)
			err(1, "setresgid failed");

		if (setresuid(u, u, u) != 0)
			err(1, "setresuid failed");

		verbose("Dropping privileges completed\n");
	}

2062
	/* Finally, run the Guest.  This doesn't return. */
2063
	run_guest();
2064
}
2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076
/*:*/

/*M:999
 * Mastery is done: you now know everything I do.
 *
 * But surely you have seen code, features and bugs in your wanderings which
 * you now yearn to attack?  That is the real game, and I look forward to you
 * patching and forking lguest into the Your-Name-Here-visor.
 *
 * Farewell, and good coding!
 * Rusty Russell.
 */