Merge branch 'bug-fixes' of git://farnsworth.org/dale/linux-2.6-mv643xx_eth into...
authorJeff Garzik <jeff@garzik.org>
Wed, 24 Oct 2007 00:15:05 +0000 (20:15 -0400)
committerJeff Garzik <jeff@garzik.org>
Wed, 24 Oct 2007 00:15:05 +0000 (20:15 -0400)
777 files changed:
Documentation/Intel-IOMMU.txt [new file with mode: 0644]
Documentation/feature-removal-schedule.txt
Documentation/filesystems/9p.txt
Documentation/filesystems/Exporting
Documentation/i386/boot.txt
Documentation/kbuild/makefiles.txt
Documentation/kernel-parameters.txt
Documentation/lguest/Makefile
Documentation/lguest/lguest.c
Documentation/lguest/lguest.txt
Documentation/memory-hotplug.txt
Documentation/powerpc/mpc52xx-device-tree-bindings.txt
MAINTAINERS
Makefile
arch/alpha/kernel/pci_iommu.c
arch/arm/common/dmabounce.c
arch/avr32/boards/atstk1000/atstk1002.c
arch/avr32/mach-at32ap/at32ap7000.c
arch/avr32/mach-at32ap/extint.c
arch/avr32/mach-at32ap/pm.h
arch/avr32/mach-at32ap/time-tc.c
arch/blackfin/Kconfig
arch/blackfin/Makefile
arch/blackfin/boot/Makefile
arch/blackfin/boot/install.sh [new file with mode: 0644]
arch/blackfin/configs/BF527-EZKIT_defconfig [new file with mode: 0644]
arch/blackfin/configs/BF548-EZKIT_defconfig
arch/blackfin/kernel/Makefile
arch/blackfin/kernel/bfin_dma_5xx.c
arch/blackfin/kernel/bfin_gpio.c
arch/blackfin/kernel/dma-mapping.c
arch/blackfin/kernel/gptimers.c [new file with mode: 0644]
arch/blackfin/kernel/reboot.c
arch/blackfin/kernel/setup.c
arch/blackfin/kernel/traps.c
arch/blackfin/lib/Makefile
arch/blackfin/lib/udivdi3.S [new file with mode: 0644]
arch/blackfin/mach-bf527/Kconfig [new file with mode: 0644]
arch/blackfin/mach-bf527/Makefile [new file with mode: 0644]
arch/blackfin/mach-bf527/boards/Makefile [new file with mode: 0644]
arch/blackfin/mach-bf527/boards/eth_mac.c [new file with mode: 0644]
arch/blackfin/mach-bf527/boards/ezkit.c [new file with mode: 0644]
arch/blackfin/mach-bf527/cpu.c [new file with mode: 0644]
arch/blackfin/mach-bf527/dma.c [new file with mode: 0644]
arch/blackfin/mach-bf527/head.S [new file with mode: 0644]
arch/blackfin/mach-bf527/ints-priority.c [new file with mode: 0644]
arch/blackfin/mach-bf533/boards/cm_bf533.c
arch/blackfin/mach-bf533/boards/ezkit.c
arch/blackfin/mach-bf533/boards/generic_board.c
arch/blackfin/mach-bf533/boards/stamp.c
arch/blackfin/mach-bf537/boards/cm_bf537.c
arch/blackfin/mach-bf537/boards/generic_board.c
arch/blackfin/mach-bf537/boards/pnav10.c
arch/blackfin/mach-bf537/boards/stamp.c
arch/blackfin/mach-bf548/boards/ezkit.c
arch/blackfin/mach-bf548/dma.c
arch/blackfin/mach-bf561/boards/cm_bf561.c
arch/blackfin/mach-bf561/boards/ezkit.c
arch/blackfin/mach-bf561/boards/generic_board.c
arch/blackfin/mach-bf561/boards/tepla.c
arch/blackfin/mach-common/ints-priority-dc.c
arch/blackfin/mach-common/ints-priority-sc.c
arch/i386/Kconfig
arch/i386/Makefile
arch/ia64/hp/common/sba_iommu.c
arch/ia64/hp/sim/simscsi.c
arch/ia64/kernel/efi.c
arch/ia64/kernel/setup.c
arch/ia64/sn/pci/pci_dma.c
arch/m68k/kernel/dma.c
arch/m68knommu/Kconfig
arch/m68knommu/Makefile
arch/m68knommu/defconfig
arch/m68knommu/kernel/setup.c
arch/m68knommu/kernel/signal.c
arch/m68knommu/kernel/time.c
arch/m68knommu/platform/5206/config.c
arch/m68knommu/platform/5206e/config.c
arch/m68knommu/platform/520x/config.c
arch/m68knommu/platform/523x/config.c
arch/m68knommu/platform/5249/config.c
arch/m68knommu/platform/5272/config.c
arch/m68knommu/platform/527x/config.c
arch/m68knommu/platform/528x/config.c
arch/m68knommu/platform/5307/config.c
arch/m68knommu/platform/5307/entry.S
arch/m68knommu/platform/5307/pit.c
arch/m68knommu/platform/5307/timers.c
arch/m68knommu/platform/532x/config.c
arch/m68knommu/platform/5407/config.c
arch/mips/Kconfig
arch/mips/Kconfig.debug
arch/mips/Makefile
arch/mips/cobalt/Makefile
arch/mips/cobalt/setup.c
arch/mips/cobalt/time.c [new file with mode: 0644]
arch/mips/kernel/Makefile
arch/mips/kernel/cevt-gt641xx.c [new file with mode: 0644]
arch/mips/kernel/cevt-r4k.c
arch/mips/kernel/time.c
arch/mips/mips-boards/generic/time.c
arch/mips/mm/dma-default.c
arch/mips/sgi-ip27/ip27-init.c
arch/mips/sgi-ip27/ip27-timer.c
arch/mips/sibyte/bcm1480/irq.c
arch/mips/sibyte/bcm1480/smp.c
arch/mips/sibyte/bcm1480/time.c
arch/mips/sibyte/sb1250/irq.c
arch/mips/sibyte/sb1250/smp.c
arch/mips/sibyte/sb1250/time.c
arch/parisc/Makefile
arch/parisc/configs/712_defconfig
arch/parisc/configs/a500_defconfig
arch/parisc/configs/b180_defconfig
arch/parisc/configs/c3000_defconfig
arch/parisc/defconfig
arch/parisc/hpux/gate.S
arch/parisc/kernel/asm-offsets.c
arch/parisc/kernel/entry.S
arch/parisc/kernel/head.S
arch/parisc/kernel/hpmc.S
arch/parisc/kernel/init_task.c
arch/parisc/kernel/pacache.S
arch/parisc/kernel/parisc_ksyms.c
arch/parisc/kernel/pci-dma.c
arch/parisc/kernel/pci.c
arch/parisc/kernel/processor.c
arch/parisc/kernel/smp.c
arch/parisc/kernel/sys_parisc32.c
arch/parisc/kernel/syscall.S
arch/parisc/kernel/syscall_table.S
arch/parisc/kernel/time.c
arch/parisc/kernel/unwind.c
arch/parisc/kernel/vmlinux.lds.S
arch/parisc/lib/Makefile
arch/parisc/lib/libgcc/Makefile [new file with mode: 0644]
arch/parisc/lib/libgcc/__ashldi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__ashrdi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__clzsi2.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__divdi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__divsi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__lshrdi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__moddi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__modsi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__muldi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__udivdi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__udivmoddi4.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__udivmodsi4.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__udivsi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__umoddi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__umodsi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/__umulsidi3.c [new file with mode: 0644]
arch/parisc/lib/libgcc/libgcc.h [new file with mode: 0644]
arch/parisc/lib/memcpy.c
arch/parisc/lib/milli/Makefile [new file with mode: 0644]
arch/parisc/lib/milli/divI.S [new file with mode: 0644]
arch/parisc/lib/milli/divU.S [new file with mode: 0644]
arch/parisc/lib/milli/div_const.S [new file with mode: 0644]
arch/parisc/lib/milli/dyncall.S [new file with mode: 0644]
arch/parisc/lib/milli/milli.S [new file with mode: 0644]
arch/parisc/lib/milli/milli.h [new file with mode: 0644]
arch/parisc/lib/milli/mulI.S [new file with mode: 0644]
arch/parisc/lib/milli/remI.S [new file with mode: 0644]
arch/parisc/lib/milli/remU.S [new file with mode: 0644]
arch/parisc/mm/init.c
arch/powerpc/Kconfig.debug
arch/powerpc/boot/dts/bamboo.dts
arch/powerpc/boot/dts/lite5200.dts
arch/powerpc/boot/dts/lite5200b.dts
arch/powerpc/boot/dts/sequoia.dts
arch/powerpc/boot/dts/walnut.dts
arch/powerpc/boot/treeboot-walnut.c
arch/powerpc/configs/bamboo_defconfig
arch/powerpc/configs/ebony_defconfig
arch/powerpc/configs/walnut_defconfig
arch/powerpc/kernel/dma_64.c
arch/powerpc/kernel/ibmebus.c
arch/powerpc/kernel/iommu.c
arch/powerpc/platforms/40x/Kconfig
arch/powerpc/platforms/44x/Kconfig
arch/powerpc/platforms/52xx/lite5200.c
arch/powerpc/platforms/52xx/mpc52xx_common.c
arch/powerpc/platforms/Kconfig.cputype
arch/powerpc/platforms/ps3/system-bus.c
arch/powerpc/sysdev/bestcomm/bestcomm.c
arch/ppc/boot/Makefile
arch/s390/defconfig
arch/s390/kernel/ipl.c
arch/s390/kernel/process.c
arch/s390/kernel/smp.c
arch/s390/lib/uaccess_pt.c
arch/s390/mm/Makefile
arch/s390/mm/init.c
arch/s390/mm/pgtable.c [new file with mode: 0644]
arch/s390/mm/vmem.c
arch/sparc/kernel/ioport.c
arch/sparc/mm/io-unit.c
arch/sparc/mm/iommu.c
arch/sparc/mm/sun4c.c
arch/sparc64/Kconfig
arch/sparc64/Makefile
arch/sparc64/defconfig
arch/sparc64/kernel/Makefile
arch/sparc64/kernel/iommu.c
arch/sparc64/kernel/iommu_common.c
arch/sparc64/kernel/irq.c
arch/sparc64/kernel/ldc.c
arch/sparc64/kernel/pci.c
arch/sparc64/kernel/pci_msi.c
arch/sparc64/kernel/pci_sun4v.c
arch/sparc64/math-emu/Makefile
arch/um/drivers/ubd_kern.c
arch/x86/boot/compressed/head_32.S
arch/x86/boot/compressed/misc_32.c
arch/x86/boot/header.S
arch/x86/kernel/asm-offsets_32.c
arch/x86/kernel/e820_32.c
arch/x86/kernel/e820_64.c
arch/x86/kernel/efi_32.c
arch/x86/kernel/head_32.S
arch/x86/kernel/io_apic_64.c
arch/x86/kernel/pci-calgary_64.c
arch/x86/kernel/pci-dma_64.c
arch/x86/kernel/pci-gart_64.c
arch/x86/kernel/pci-nommu_64.c
arch/x86/kernel/setup_32.c
arch/x86/kernel/setup_64.c
arch/x86/lguest/Kconfig [new file with mode: 0644]
arch/x86/lguest/Makefile [new file with mode: 0644]
arch/x86/lguest/boot.c [moved from drivers/lguest/lguest.c with 93% similarity]
arch/x86/lguest/i386_head.S [moved from drivers/lguest/lguest_asm.S with 73% similarity]
arch/x86/mm/pageattr_64.c
arch/x86/xen/Kconfig
arch/x86_64/Kconfig
arch/xtensa/boot/Makefile
block/ll_rw_blk.c
crypto/digest.c
crypto/hmac.c
crypto/scatterwalk.c
crypto/scatterwalk.h
crypto/tcrypt.c
crypto/xcbc.c
drivers/Kconfig
drivers/Makefile
drivers/ata/libata-core.c
drivers/ata/libata-scsi.c
drivers/base/memory.c
drivers/block/DAC960.c
drivers/block/Kconfig
drivers/block/Makefile
drivers/block/cciss.c
drivers/block/cpqarray.c
drivers/block/cryptoloop.c
drivers/block/lguest_blk.c [deleted file]
drivers/block/sunvdc.c
drivers/block/sx8.c
drivers/block/ub.c
drivers/block/viodasd.c
drivers/block/virtio_blk.c [new file with mode: 0644]
drivers/bluetooth/Kconfig
drivers/bluetooth/Makefile
drivers/bluetooth/bluecard_cs.c
drivers/bluetooth/bpa10x.c
drivers/bluetooth/bt3c_cs.c
drivers/bluetooth/btsdio.c [new file with mode: 0644]
drivers/bluetooth/btuart_cs.c
drivers/bluetooth/btusb.c [new file with mode: 0644]
drivers/bluetooth/dtl1_cs.c
drivers/bluetooth/hci_bcsp.c
drivers/bluetooth/hci_ldisc.c
drivers/bluetooth/hci_ll.c [new file with mode: 0644]
drivers/bluetooth/hci_uart.h
drivers/char/Kconfig
drivers/char/Makefile
drivers/char/cyclades.c
drivers/char/hvc_lguest.c [deleted file]
drivers/char/virtio_console.c [new file with mode: 0644]
drivers/firewire/fw-ohci.c
drivers/ide/cris/ide-cris.c
drivers/ide/ide-probe.c
drivers/ide/ide-taskfile.c
drivers/ide/mips/au1xxx-ide.c
drivers/ieee1394/dma.c
drivers/ieee1394/sbp2.c
drivers/infiniband/core/cma.c
drivers/infiniband/core/umem.c
drivers/infiniband/core/uverbs_cmd.c
drivers/infiniband/hw/ehca/ehca_classes.h
drivers/infiniband/hw/ehca/ehca_hca.c
drivers/infiniband/hw/ehca/ehca_main.c
drivers/infiniband/hw/ehca/ehca_mrmw.c
drivers/infiniband/hw/ehca/ehca_qp.c
drivers/infiniband/hw/ipath/ipath_dma.c
drivers/infiniband/hw/ipath/ipath_mr.c
drivers/infiniband/hw/mlx4/qp.c
drivers/infiniband/hw/mthca/mthca_cq.c
drivers/infiniband/hw/mthca/mthca_doorbell.h
drivers/infiniband/hw/mthca/mthca_eq.c
drivers/infiniband/hw/mthca/mthca_memfree.c
drivers/infiniband/hw/mthca/mthca_qp.c
drivers/infiniband/hw/mthca/mthca_srq.c
drivers/infiniband/ulp/ipoib/ipoib.h
drivers/infiniband/ulp/ipoib/ipoib_cm.c
drivers/infiniband/ulp/ipoib/ipoib_ib.c
drivers/infiniband/ulp/ipoib/ipoib_main.c
drivers/infiniband/ulp/iser/iser_memory.c
drivers/input/keyboard/bf54x-keys.c
drivers/input/mouse/appletouch.c
drivers/input/serio/i8042.c
drivers/input/serio/i8042.h
drivers/input/touchscreen/Kconfig
drivers/input/touchscreen/usbtouchscreen.c
drivers/kvm/Kconfig
drivers/kvm/kvm_main.c
drivers/kvm/lapic.c
drivers/kvm/mmu.c
drivers/kvm/vmx.c
drivers/kvm/x86_emulate.c
drivers/lguest/Kconfig
drivers/lguest/Makefile
drivers/lguest/core.c
drivers/lguest/hypercalls.c
drivers/lguest/interrupts_and_traps.c
drivers/lguest/io.c [deleted file]
drivers/lguest/lg.h
drivers/lguest/lguest_bus.c [deleted file]
drivers/lguest/lguest_device.c [new file with mode: 0644]
drivers/lguest/lguest_user.c
drivers/lguest/page_tables.c
drivers/lguest/segments.c
drivers/lguest/x86/core.c [new file with mode: 0644]
drivers/lguest/x86/switcher_32.S [moved from drivers/lguest/switcher.S with 99% similarity]
drivers/md/bitmap.c
drivers/md/dm-crypt.c
drivers/md/raid5.c
drivers/media/common/ir-keymaps.c
drivers/media/common/saa7146_core.c
drivers/media/dvb/cinergyT2/cinergyT2.c
drivers/media/dvb/dvb-core/dvb_ca_en50221.c
drivers/media/dvb/dvb-usb/dib0700_devices.c
drivers/media/radio/miropcm20-radio.c
drivers/media/radio/radio-gemtek.c
drivers/media/video/arv.c
drivers/media/video/bt8xx/bttv-driver.c
drivers/media/video/bw-qcam.c
drivers/media/video/c-qcam.c
drivers/media/video/cpia.c
drivers/media/video/cpia2/cpia2_v4l.c
drivers/media/video/cx23885/cx23885-core.c
drivers/media/video/cx88/cx88-alsa.c
drivers/media/video/cx88/cx88-blackbird.c
drivers/media/video/cx88/cx88-dvb.c
drivers/media/video/cx88/cx88-mpeg.c
drivers/media/video/cx88/cx88-video.c
drivers/media/video/cx88/cx88-vp3054-i2c.c
drivers/media/video/cx88/cx88.h
drivers/media/video/em28xx/em28xx-core.c
drivers/media/video/em28xx/em28xx-video.c
drivers/media/video/et61x251/et61x251_core.c
drivers/media/video/ir-kbd-i2c.c
drivers/media/video/ivtv/ivtv-driver.c
drivers/media/video/ivtv/ivtv-driver.h
drivers/media/video/ivtv/ivtv-fileops.c
drivers/media/video/ivtv/ivtv-ioctl.c
drivers/media/video/ivtv/ivtv-streams.c
drivers/media/video/ivtv/ivtv-streams.h
drivers/media/video/ivtv/ivtv-udma.c
drivers/media/video/ivtv/ivtv-yuv.c
drivers/media/video/ivtv/ivtv-yuv.h
drivers/media/video/ivtv/ivtvfb.c
drivers/media/video/meye.c
drivers/media/video/ov511.c
drivers/media/video/planb.c
drivers/media/video/pms.c
drivers/media/video/pvrusb2/pvrusb2-encoder.c
drivers/media/video/pvrusb2/pvrusb2-hdw-internal.h
drivers/media/video/pvrusb2/pvrusb2-hdw.c
drivers/media/video/pvrusb2/pvrusb2-v4l2.c
drivers/media/video/pwc/pwc-if.c
drivers/media/video/saa7134/saa6752hs.c
drivers/media/video/saa7134/saa7134-core.c
drivers/media/video/saa7134/saa7134-empress.c
drivers/media/video/saa7134/saa7134-input.c
drivers/media/video/saa7134/saa7134-tvaudio.c
drivers/media/video/saa7134/saa7134-video.c
drivers/media/video/saa7134/saa7134.h
drivers/media/video/se401.c
drivers/media/video/sn9c102/sn9c102_core.c
drivers/media/video/stradis.c
drivers/media/video/stv680.c
drivers/media/video/tuner-core.c
drivers/media/video/usbvideo/usbvideo.c
drivers/media/video/usbvideo/vicam.c
drivers/media/video/usbvision/usbvision-video.c
drivers/media/video/v4l2-common.c
drivers/media/video/videobuf-core.c
drivers/media/video/videobuf-dma-sg.c
drivers/media/video/videocodec.c
drivers/media/video/videodev.c
drivers/media/video/vivi.c
drivers/media/video/w9966.c
drivers/media/video/w9968cf.c
drivers/media/video/zc0301/zc0301_core.c
drivers/media/video/zoran_card.c
drivers/media/video/zoran_driver.c
drivers/mmc/card/queue.c
drivers/mmc/host/at91_mci.c
drivers/mmc/host/au1xmmc.c
drivers/mmc/host/imxmmc.c
drivers/mmc/host/mmc_spi.c
drivers/mmc/host/mmci.h
drivers/mmc/host/omap.c
drivers/mmc/host/sdhci.c
drivers/mmc/host/tifm_sd.c
drivers/mmc/host/wbsd.c
drivers/mtd/chips/cfi_cmdset_0001.c
drivers/mtd/nand/Kconfig
drivers/mtd/nand/diskonchip.c
drivers/mtd/nand/nand_base.c
drivers/mtd/nand/nand_ecc.c
drivers/mtd/nand/nandsim.c
drivers/mtd/nand/s3c2410.c
drivers/mtd/onenand/onenand_sim.c
drivers/net/Kconfig
drivers/net/Makefile
drivers/net/cpmac.c
drivers/net/fec.c
drivers/net/lguest_net.c [deleted file]
drivers/net/mlx4/fw.c
drivers/net/mlx4/icm.c
drivers/net/niu.c
drivers/net/ppp_mppe.c
drivers/net/r8169.c
drivers/net/tg3.c
drivers/net/tg3.h
drivers/net/virtio_net.c [new file with mode: 0644]
drivers/parisc/ccio-dma.c
drivers/parisc/lba_pci.c
drivers/parisc/pdc_stable.c
drivers/parisc/sba_iommu.c
drivers/parisc/superio.c
drivers/pci/Makefile
drivers/pci/dmar.c [new file with mode: 0644]
drivers/pci/intel-iommu.c [new file with mode: 0644]
drivers/pci/intel-iommu.h [new file with mode: 0644]
drivers/pci/iova.c [new file with mode: 0644]
drivers/pci/iova.h [new file with mode: 0644]
drivers/pci/pci.h
drivers/pci/probe.c
drivers/pci/search.c
drivers/power/apm_power.c
drivers/s390/char/raw3270.c
drivers/s390/char/tape_class.c
drivers/s390/char/tape_class.h
drivers/s390/char/vmlogrdr.c
drivers/s390/cio/chp.c
drivers/s390/cio/css.c
drivers/s390/scsi/zfcp_aux.c
drivers/s390/scsi/zfcp_def.h
drivers/s390/scsi/zfcp_erp.c
drivers/sbus/char/vfc_dev.c
drivers/scsi/3w-9xxx.c
drivers/scsi/3w-xxxx.c
drivers/scsi/NCR5380.c
drivers/scsi/NCR53C9x.c
drivers/scsi/NCR53c406a.c
drivers/scsi/aacraid/aachba.c
drivers/scsi/aha152x.c
drivers/scsi/aha1542.c
drivers/scsi/arcmsr/arcmsr_hba.c
drivers/scsi/atari_NCR5380.c
drivers/scsi/eata_pio.c
drivers/scsi/fd_mcs.c
drivers/scsi/fdomain.c
drivers/scsi/gdth.c
drivers/scsi/ibmmca.c
drivers/scsi/ide-scsi.c
drivers/scsi/imm.c
drivers/scsi/in2000.c
drivers/scsi/ipr.c
drivers/scsi/ips.c
drivers/scsi/iscsi_tcp.c
drivers/scsi/megaraid.c
drivers/scsi/megaraid/megaraid_mbox.c
drivers/scsi/oktagon_esp.c
drivers/scsi/osst.c
drivers/scsi/pcmcia/nsp_cs.h
drivers/scsi/pcmcia/sym53c500_cs.c
drivers/scsi/ppa.c
drivers/scsi/ps3rom.c
drivers/scsi/qlogicfas408.c
drivers/scsi/scsi_debug.c
drivers/scsi/scsi_lib.c
drivers/scsi/seagate.c
drivers/scsi/sg.c
drivers/scsi/st.c
drivers/scsi/sun3_NCR5380.c
drivers/scsi/sym53c416.c
drivers/scsi/tmscsim.c
drivers/scsi/ultrastor.c
drivers/scsi/wd33c93.c
drivers/scsi/wd7000.c
drivers/serial/Kconfig
drivers/serial/mcf.c [new file with mode: 0644]
drivers/usb/core/message.c
drivers/usb/image/microtek.c
drivers/usb/misc/usbtest.c
drivers/usb/storage/protocol.c
drivers/virtio/Kconfig [new file with mode: 0644]
drivers/virtio/Makefile [new file with mode: 0644]
drivers/virtio/config.c [new file with mode: 0644]
drivers/virtio/virtio.c [new file with mode: 0644]
drivers/virtio/virtio_ring.c [new file with mode: 0644]
drivers/watchdog/mpc5200_wdt.c
fs/9p/v9fs.c
fs/9p/vfs_inode.c
fs/buffer.c
fs/cifs/cifsfs.h
fs/cifs/export.c
fs/dcache.c
fs/debugfs/inode.c
fs/ecryptfs/crypto.c
fs/ecryptfs/keystore.c
fs/efs/namei.c
fs/efs/super.c
fs/exportfs/expfs.c
fs/ext2/dir.c
fs/ext2/super.c
fs/ext3/super.c
fs/ext4/super.c
fs/fat/inode.c
fs/gfs2/ops_export.c
fs/gfs2/ops_fstype.h
fs/inotify.c
fs/isofs/export.c
fs/isofs/isofs.h
fs/jffs2/acl.c
fs/jffs2/acl.h
fs/jffs2/dir.c
fs/jffs2/file.c
fs/jffs2/fs.c
fs/jffs2/os-linux.h
fs/jffs2/write.c
fs/jfs/jfs_inode.h
fs/jfs/namei.c
fs/jfs/super.c
fs/libfs.c
fs/namei.c
fs/namespace.c
fs/nfs/proc.c
fs/nfs/unlink.c
fs/nfsd/export.c
fs/nfsd/nfs4recover.c
fs/nfsd/nfsfh.c
fs/ntfs/namei.c
fs/ntfs/ntfs.h
fs/ocfs2/export.c
fs/ocfs2/export.h
fs/open.c
fs/pnode.h
fs/proc/base.c
fs/reiserfs/inode.c
fs/reiserfs/super.c
fs/xattr.c
fs/xfs/linux-2.6/xfs_export.c
fs/xfs/linux-2.6/xfs_export.h
fs/xfs/linux-2.6/xfs_super.h
include/acpi/actbl1.h
include/asm-alpha/scatterlist.h
include/asm-arm/dma-mapping.h
include/asm-arm/scatterlist.h
include/asm-avr32/arch-at32ap/board.h
include/asm-avr32/dma-mapping.h
include/asm-avr32/scatterlist.h
include/asm-blackfin/bf5xx_timers.h [deleted file]
include/asm-blackfin/bfin-global.h
include/asm-blackfin/dma.h
include/asm-blackfin/gpio.h
include/asm-blackfin/gptimers.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/anomaly.h
include/asm-blackfin/mach-bf527/bf527.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/bfin_serial_5xx.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/blackfin.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/cdefBF52x_base.h
include/asm-blackfin/mach-bf527/defBF527.h
include/asm-blackfin/mach-bf527/defBF52x_base.h
include/asm-blackfin/mach-bf527/dma.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/irq.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/mem_init.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/mem_map.h [new file with mode: 0644]
include/asm-blackfin/mach-bf527/portmux.h [new file with mode: 0644]
include/asm-blackfin/mach-bf548/defBF549.h
include/asm-blackfin/mach-bf548/defBF54x_base.h
include/asm-blackfin/mach-bf548/dma.h
include/asm-blackfin/scatterlist.h
include/asm-cris/scatterlist.h
include/asm-frv/scatterlist.h
include/asm-h8300/scatterlist.h
include/asm-ia64/scatterlist.h
include/asm-m32r/scatterlist.h
include/asm-m68k/scatterlist.h
include/asm-m68knommu/module.h
include/asm-m68knommu/scatterlist.h
include/asm-m68knommu/uaccess.h
include/asm-mips/gt64120.h
include/asm-mips/i8253.h
include/asm-mips/scatterlist.h
include/asm-mips/sibyte/sb1250.h
include/asm-parisc/Kbuild
include/asm-parisc/io.h
include/asm-parisc/page.h
include/asm-parisc/pci.h
include/asm-parisc/pdc.h
include/asm-parisc/pgtable.h
include/asm-parisc/prefetch.h
include/asm-parisc/rtc.h
include/asm-parisc/scatterlist.h
include/asm-parisc/semaphore.h
include/asm-parisc/unistd.h
include/asm-powerpc/dma-mapping.h
include/asm-powerpc/mpc52xx.h
include/asm-powerpc/scatterlist.h
include/asm-ppc/system.h
include/asm-s390/cpu.h [new file with mode: 0644]
include/asm-s390/mmu_context.h
include/asm-s390/page.h
include/asm-s390/pgalloc.h
include/asm-s390/pgtable.h
include/asm-s390/processor.h
include/asm-s390/scatterlist.h
include/asm-s390/tlb.h
include/asm-s390/tlbflush.h
include/asm-sh/dma-mapping.h
include/asm-sh/scatterlist.h
include/asm-sh64/dma-mapping.h
include/asm-sh64/scatterlist.h
include/asm-sparc/scatterlist.h
include/asm-sparc64/scatterlist.h
include/asm-v850/scatterlist.h
include/asm-x86/Kbuild
include/asm-x86/bootparam.h
include/asm-x86/cacheflush.h
include/asm-x86/device.h
include/asm-x86/dma-mapping_32.h
include/asm-x86/e820.h
include/asm-x86/e820_32.h
include/asm-x86/e820_64.h
include/asm-x86/ist.h
include/asm-x86/lguest.h [new file with mode: 0644]
include/asm-x86/lguest_hcall.h [new file with mode: 0644]
include/asm-x86/scatterlist_32.h
include/asm-x86/scatterlist_64.h
include/asm-xtensa/dma-mapping.h
include/asm-xtensa/scatterlist.h
include/linux/Kbuild
include/linux/apm_bios.h
include/linux/audit.h
include/linux/capability.h
include/linux/dcache.h
include/linux/dmar.h [new file with mode: 0644]
include/linux/edd.h
include/linux/efi.h
include/linux/efs_fs.h
include/linux/exportfs.h
include/linux/ext2_fs.h
include/linux/fs.h
include/linux/fsnotify.h
include/linux/i8042.h [new file with mode: 0644]
include/linux/ide.h
include/linux/inotify.h
include/linux/lguest.h
include/linux/lguest_bus.h [deleted file]
include/linux/lguest_launcher.h
include/linux/linkage.h
include/linux/memory.h
include/linux/mlx4/doorbell.h
include/linux/mod_devicetable.h
include/linux/net.h
include/linux/netdevice.h
include/linux/pci.h
include/linux/pci_ids.h
include/linux/reiserfs_fs.h
include/linux/scatterlist.h
include/linux/screen_info.h
include/linux/skbuff.h
include/linux/socket.h
include/linux/videodev.h
include/linux/videodev2.h
include/linux/virtio.h [new file with mode: 0644]
include/linux/virtio_9p.h [new file with mode: 0644]
include/linux/virtio_blk.h [new file with mode: 0644]
include/linux/virtio_config.h [new file with mode: 0644]
include/linux/virtio_console.h [new file with mode: 0644]
include/linux/virtio_net.h [new file with mode: 0644]
include/linux/virtio_ring.h [new file with mode: 0644]
include/media/saa7146.h
include/media/v4l2-dev.h
include/net/bluetooth/hci.h
include/net/bluetooth/hci_core.h
include/net/bluetooth/l2cap.h
include/sound/version.h
include/video/Kbuild
include/video/edid.h
init/Kconfig
ipc/mqueue.c
kernel/Makefile
kernel/audit.c
kernel/audit.h
kernel/audit_tree.c [new file with mode: 0644]
kernel/auditfilter.c
kernel/auditsc.c
kernel/irq/manage.c
kernel/sched.c
kernel/sysctl_check.c
lib/Kconfig.debug
lib/reed_solomon/decode_rs.c
lib/reed_solomon/reed_solomon.c
lib/swiotlb.c
mm/memory_hotplug.c
mm/mmap.c
mm/mprotect.c
mm/oom_kill.c
mm/shmem.c
mm/slub.c
net/9p/Kconfig
net/9p/Makefile
net/9p/trans_virtio.c [new file with mode: 0644]
net/bluetooth/hci_conn.c
net/bluetooth/hci_core.c
net/bluetooth/hci_event.c
net/bluetooth/hci_sock.c
net/bluetooth/hci_sysfs.c
net/bluetooth/hidp/core.c
net/bluetooth/l2cap.c
net/bluetooth/rfcomm/core.c
net/bluetooth/rfcomm/tty.c
net/bluetooth/sco.c
net/core/dev.c
net/core/neighbour.c
net/core/netpoll.c
net/core/pktgen.c
net/core/skbuff.c
net/dccp/diag.c
net/dccp/ipv4.c
net/dccp/ipv6.c
net/ieee80211/ieee80211_crypt_tkip.c
net/ieee80211/ieee80211_crypt_wep.c
net/ipv4/inet_diag.c
net/ipv4/tcp_diag.c
net/ipv6/ah6.c
net/ipv6/esp6.c
net/mac80211/wep.c
net/sched/sch_teql.c
net/sctp/auth.c
net/sctp/sm_make_chunk.c
net/sunrpc/auth_gss/gss_krb5_crypto.c
net/sunrpc/xdr.c
net/xfrm/xfrm_algo.c
scripts/checkstack.pl
scripts/kconfig/qconf.cc
scripts/mod/file2alias.c
security/commoncap.c
security/selinux/hooks.c
sound/core/control.c
sound/i2c/other/tea575x-tuner.c
sound/pci/bt87x.c
sound/pci/hda/hda_codec.c
sound/pci/hda/hda_local.h
sound/pci/hda/patch_analog.c
sound/pci/hda/patch_cmedia.c
sound/pci/hda/patch_conexant.c
sound/pci/hda/patch_realtek.c
sound/pci/hda/patch_sigmatel.c
sound/pci/hda/patch_via.c
sound/sh/aica.c
sound/sparc/cs4231.c
sound/usb/usbquirks.h

diff --git a/Documentation/Intel-IOMMU.txt b/Documentation/Intel-IOMMU.txt
new file mode 100644 (file)
index 0000000..c232190
--- /dev/null
@@ -0,0 +1,115 @@
+Linux IOMMU Support
+===================
+
+The architecture spec can be obtained from the below location.
+
+http://www.intel.com/technology/virtualization/
+
+This guide gives a quick cheat sheet for some basic understanding.
+
+Some Keywords
+
+DMAR - DMA remapping
+DRHD - DMA Engine Reporting Structure
+RMRR - Reserved memory Region Reporting Structure
+ZLR  - Zero length reads from PCI devices
+IOVA - IO Virtual address.
+
+Basic stuff
+-----------
+
+ACPI enumerates and lists the different DMA engines in the platform, and
+device scope relationships between PCI devices and which DMA engine  controls
+them.
+
+What is RMRR?
+-------------
+
+There are some devices the BIOS controls, for e.g USB devices to perform
+PS2 emulation. The regions of memory used for these devices are marked
+reserved in the e820 map. When we turn on DMA translation, DMA to those
+regions will fail. Hence BIOS uses RMRR to specify these regions along with
+devices that need to access these regions. OS is expected to setup
+unity mappings for these regions for these devices to access these regions.
+
+How is IOVA generated?
+---------------------
+
+Well behaved drivers call pci_map_*() calls before sending command to device
+that needs to perform DMA. Once DMA is completed and mapping is no longer
+required, device performs a pci_unmap_*() calls to unmap the region.
+
+The Intel IOMMU driver allocates a virtual address per domain. Each PCIE
+device has its own domain (hence protection). Devices under p2p bridges
+share the virtual address with all devices under the p2p bridge due to
+transaction id aliasing for p2p bridges.
+
+IOVA generation is pretty generic. We used the same technique as vmalloc()
+but these are not global address spaces, but separate for each domain.
+Different DMA engines may support different number of domains.
+
+We also allocate gaurd pages with each mapping, so we can attempt to catch
+any overflow that might happen.
+
+
+Graphics Problems?
+------------------
+If you encounter issues with graphics devices, you can try adding
+option intel_iommu=igfx_off to turn off the integrated graphics engine.
+
+If it happens to be a PCI device included in the INCLUDE_ALL Engine,
+then try enabling CONFIG_DMAR_GFX_WA to setup a 1-1 map. We hear
+graphics drivers may be in process of using DMA api's in the near
+future and at that time this option can be yanked out.
+
+Some exceptions to IOVA
+-----------------------
+Interrupt ranges are not address translated, (0xfee00000 - 0xfeefffff).
+The same is true for peer to peer transactions. Hence we reserve the
+address from PCI MMIO ranges so they are not allocated for IOVA addresses.
+
+
+Fault reporting
+---------------
+When errors are reported, the DMA engine signals via an interrupt. The fault
+reason and device that caused it with fault reason is printed on console.
+
+See below for sample.
+
+
+Boot Message Sample
+-------------------
+
+Something like this gets printed indicating presence of DMAR tables
+in ACPI.
+
+ACPI: DMAR (v001 A M I  OEMDMAR  0x00000001 MSFT 0x00000097) @ 0x000000007f5b5ef0
+
+When DMAR is being processed and initialized by ACPI, prints DMAR locations
+and any RMRR's processed.
+
+ACPI DMAR:Host address width 36
+ACPI DMAR:DRHD (flags: 0x00000000)base: 0x00000000fed90000
+ACPI DMAR:DRHD (flags: 0x00000000)base: 0x00000000fed91000
+ACPI DMAR:DRHD (flags: 0x00000001)base: 0x00000000fed93000
+ACPI DMAR:RMRR base: 0x00000000000ed000 end: 0x00000000000effff
+ACPI DMAR:RMRR base: 0x000000007f600000 end: 0x000000007fffffff
+
+When DMAR is enabled for use, you will notice..
+
+PCI-DMA: Using DMAR IOMMU
+
+Fault reporting
+---------------
+
+DMAR:[DMA Write] Request device [00:02.0] fault addr 6df084000
+DMAR:[fault reason 05] PTE Write access is not set
+DMAR:[DMA Write] Request device [00:02.0] fault addr 6df084000
+DMAR:[fault reason 05] PTE Write access is not set
+
+TBD
+----
+
+- For compatibility testing, could use unity map domain for all devices, just
+  provide a 1-1 for all useful memory under a single domain for all devices.
+- API for paravirt ops for abstracting functionlity for VMM folks.
index 6b0f963f5379eb252045f553617cd11c51fc80ac..6bb9be54ab767817557b680407edca2f582e03e9 100644 (file)
@@ -14,18 +14,6 @@ Who: Jiri Slaby <jirislaby@gmail.com>
 
 ---------------------------
 
-What:  V4L2 VIDIOC_G_MPEGCOMP and VIDIOC_S_MPEGCOMP
-When:  October 2007
-Why:   Broken attempt to set MPEG compression parameters. These ioctls are
-       not able to implement the wide variety of parameters that can be set
-       by hardware MPEG encoders. A new MPEG control mechanism was created
-       in kernel 2.6.18 that replaces these ioctls. See the V4L2 specification
-       (section 1.9: Extended controls) for more information on this topic.
-Who:   Hans Verkuil <hverkuil@xs4all.nl> and
-       Mauro Carvalho Chehab <mchehab@infradead.org>
-
----------------------------
-
 What:  dev->power.power_state
 When:  July 2007
 Why:   Broken design for runtime control over driver power states, confusing
@@ -49,10 +37,10 @@ Who:        David Miller <davem@davemloft.net>
 ---------------------------
 
 What:  Video4Linux API 1 ioctls and video_decoder.h from Video devices.
-When:  December 2006
-Files: include/linux/video_decoder.h
-Check: include/linux/video_decoder.h
-Why:   V4L1 AP1 was replaced by V4L2 API. during migration from 2.4 to 2.6
+When:  December 2008
+Files: include/linux/video_decoder.h include/linux/videodev.h
+Check: include/linux/video_decoder.h include/linux/videodev.h
+Why:   V4L1 AP1 was replaced by V4L2 API during migration from 2.4 to 2.6
        series. The old API have lots of drawbacks and don't provide enough
        means to work with all video and audio standards. The newer API is
        already available on the main drivers and should be used instead.
@@ -61,7 +49,9 @@ Why:  V4L1 AP1 was replaced by V4L2 API. during migration from 2.4 to 2.6
        Decoder iocts are using internally to allow video drivers to
        communicate with video decoders. This should also be improved to allow
        V4L2 calls being translated into compatible internal ioctls.
-Who:   Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+       Compatibility ioctls will be provided, for a while, via 
+       v4l1-compat module. 
+Who:   Mauro Carvalho Chehab <mchehab@infradead.org>
 
 ---------------------------
 
index b90f537af35cd13ff135b0900de96c1a95d0b344..bf8080640eba405d01aac5a101623e825b542d90 100644 (file)
@@ -42,10 +42,12 @@ OPTIONS
 
   trans=name   select an alternative transport.  Valid options are
                currently:
-                       unix - specifying a named pipe mount point
-                       tcp  - specifying a normal TCP/IP connection
-                       fd   - used passed file descriptors for connection
+                       unix    - specifying a named pipe mount point
+                       tcp     - specifying a normal TCP/IP connection
+                       fd      - used passed file descriptors for connection
                                 (see rfdno and wfdno)
+                       virtio  - connect to the next virtio channel available
+                               (from lguest or KVM with trans_virtio module)
 
   uname=name   user name to attempt mount as on the remote server.  The
                server may override or ignore this value.  Certain user
index 31047e0fe14bceb82ddda2c3692e38c846d20e40..87019d2b59815eca1accd2c39497c8de43ca8b49 100644 (file)
@@ -2,9 +2,12 @@
 Making Filesystems Exportable
 =============================
 
-Most filesystem operations require a dentry (or two) as a starting
+Overview
+--------
+
+All filesystem operations require a dentry (or two) as a starting
 point.  Local applications have a reference-counted hold on suitable
-dentrys via open file descriptors or cwd/root.  However remote
+dentries via open file descriptors or cwd/root.  However remote
 applications that access a filesystem via a remote filesystem protocol
 such as NFS may not be able to hold such a reference, and so need a
 different way to refer to a particular dentry.  As the alternative
@@ -13,14 +16,14 @@ server-reboot (among other things, though these tend to be the most
 problematic), there is no simple answer like 'filename'.
 
 The mechanism discussed here allows each filesystem implementation to
-specify how to generate an opaque (out side of the filesystem) byte
+specify how to generate an opaque (outside of the filesystem) byte
 string for any dentry, and how to find an appropriate dentry for any
 given opaque byte string.
 This byte string will be called a "filehandle fragment" as it
 corresponds to part of an NFS filehandle.
 
 A filesystem which supports the mapping between filehandle fragments
-and dentrys will be termed "exportable".
+and dentries will be termed "exportable".
 
 
 
@@ -89,11 +92,9 @@ For a filesystem to be exportable it must:
    1/ provide the filehandle fragment routines described below.
    2/ make sure that d_splice_alias is used rather than d_add
       when ->lookup finds an inode for a given parent and name.
-      Typically the ->lookup routine will end:
-               if (inode)
-                       return d_splice(inode, dentry);
-               d_add(dentry, inode);
-               return NULL;
+      Typically the ->lookup routine will end with a:
+
+               return d_splice_alias(inode, dentry);
        }
 
 
@@ -101,67 +102,39 @@ For a filesystem to be exportable it must:
   A file system implementation declares that instances of the filesystem
 are exportable by setting the s_export_op field in the struct
 super_block.  This field must point to a "struct export_operations"
-struct which could potentially be full of NULLs, though normally at
-least get_parent will be set.
-
- The primary operations are decode_fh and encode_fh.  
-decode_fh takes a filehandle fragment and tries to find or create a
-dentry for the object referred to by the filehandle.
-encode_fh takes a dentry and creates a filehandle fragment which can
-later be used to find/create a dentry for the same object.
-
-decode_fh will probably make use of "find_exported_dentry".
-This function lives in the "exportfs" module which a filesystem does
-not need unless it is being exported.  So rather that calling
-find_exported_dentry directly, each filesystem should call it through
-the find_exported_dentry pointer in it's export_operations table.
-This field is set correctly by the exporting agent (e.g. nfsd) when a
-filesystem is exported, and before any export operations are called.
-
-find_exported_dentry needs three support functions from the
-filesystem:
-  get_name.  When given a parent dentry and a child dentry, this
-    should find a name in the directory identified by the parent
-    dentry, which leads to the object identified by the child dentry.
-    If no get_name function is supplied, a default implementation is
-    provided which uses vfs_readdir to find potential names, and
-    matches inode numbers to find the correct match.
-
-  get_parent.  When given a dentry for a directory, this should return 
-    a dentry for the parent.  Quite possibly the parent dentry will
-    have been allocated by d_alloc_anon.  
-    The default get_parent function just returns an error so any
-    filehandle lookup that requires finding a parent will fail.
-    ->lookup("..") is *not* used as a default as it can leave ".."
-    entries in the dcache which are too messy to work with.
-
-  get_dentry.  When given an opaque datum, this should find the
-    implied object and create a dentry for it (possibly with
-    d_alloc_anon). 
-    The opaque datum is whatever is passed down by the decode_fh
-    function, and is often simply a fragment of the filehandle
-    fragment.
-    decode_fh passes two datums through find_exported_dentry.  One that 
-    should be used to identify the target object, and one that can be
-    used to identify the object's parent, should that be necessary.
-    The default get_dentry function assumes that the datum contains an
-    inode number and a generation number, and it attempts to get the
-    inode using "iget" and check it's validity by matching the
-    generation number.  A filesystem should only depend on the default
-    if iget can safely be used this way.
-
-If decode_fh and/or encode_fh are left as NULL, then default
-implementations are used.  These defaults are suitable for ext2 and 
-extremely similar filesystems (like ext3).
-
-The default encode_fh creates a filehandle fragment from the inode
-number and generation number of the target together with the inode
-number and generation number of the parent (if the parent is
-required).
-
-The default decode_fh extract the target and parent datums from the
-filehandle assuming the format used by the default encode_fh and
-passed them to find_exported_dentry.
+struct which has the following members:
+
+ encode_fh  (optional)
+    Takes a dentry and creates a filehandle fragment which can later be used
+    to find or create a dentry for the same object.  The default
+    implementation creates a filehandle fragment that encodes a 32bit inode
+    and generation number for the inode encoded, and if necessary the
+    same information for the parent.
+
+  fh_to_dentry (mandatory)
+    Given a filehandle fragment, this should find the implied object and
+    create a dentry for it (possibly with d_alloc_anon).
+
+  fh_to_parent (optional but strongly recommended)
+    Given a filehandle fragment, this should find the parent of the
+    implied object and create a dentry for it (possibly with d_alloc_anon).
+    May fail if the filehandle fragment is too small.
+
+  get_parent (optional but strongly recommended)
+    When given a dentry for a directory, this should return  a dentry for
+    the parent.  Quite possibly the parent dentry will have been allocated
+    by d_alloc_anon.  The default get_parent function just returns an error
+    so any filehandle lookup that requires finding a parent will fail.
+    ->lookup("..") is *not* used as a default as it can leave ".." entries
+    in the dcache which are too messy to work with.
+
+  get_name (optional)
+    When given a parent dentry and a child dentry, this should find a name
+    in the directory identified by the parent dentry, which leads to the
+    object identified by the child dentry.  If no get_name function is
+    supplied, a default implementation is provided which uses vfs_readdir
+    to find potential names, and matches inode numbers to find the correct
+    match.
 
 
 A filehandle fragment consists of an array of 1 or more 4byte words,
@@ -172,5 +145,3 @@ generated by encode_fh, in which case it will have been padded with
 nuls.  Rather, the encode_fh routine should choose a "type" which
 indicates the decode_fh how much of the filehandle is valid, and how
 it should be interpreted.
-
index 35985b34d5a6cc194e48ce9281bac676a959dcba..2f75e750e4f5c650a89df593ead1a1ff320eee62 100644 (file)
@@ -168,6 +168,8 @@ Offset      Proto   Name            Meaning
 0234/1 2.05+   relocatable_kernel Whether kernel is relocatable or not
 0235/3 N/A     pad2            Unused
 0238/4 2.06+   cmdline_size    Maximum size of the kernel command line
+023C/4 2.07+   hardware_subarch Hardware subarchitecture
+0240/8 2.07+   hardware_subarch_data Subarchitecture-specific data
 
 (1) For backwards compatibility, if the setup_sects field contains 0, the
     real value is 4.
@@ -204,7 +206,7 @@ boot loaders can ignore those fields.
 
 The byte order of all fields is littleendian (this is x86, after all.)
 
-Field name:    setup_secs
+Field name:    setup_sects
 Type:          read
 Offset/size:   0x1f1/1
 Protocol:      ALL
@@ -356,6 +358,13 @@ Protocol:  2.00+
        - If 0, the protected-mode code is loaded at 0x10000.
        - If 1, the protected-mode code is loaded at 0x100000.
 
+  Bit 6 (write): KEEP_SEGMENTS
+       Protocol: 2.07+
+       - if 0, reload the segment registers in the 32bit entry point.
+       - if 1, do not reload the segment registers in the 32bit entry point.
+               Assume that %cs %ds %ss %es are all set to flat segments with
+               a base of 0 (or the equivalent for their environment).
+
   Bit 7 (write): CAN_USE_HEAP
        Set this bit to 1 to indicate that the value entered in the
        heap_end_ptr is valid.  If this field is clear, some setup code
@@ -480,6 +489,29 @@ Protocol:  2.06+
   cmdline_size characters. With protocol version 2.05 and earlier, the
   maximum size was 255.
 
+Field name:    hardware_subarch
+Type:          write
+Offset/size:   0x23c/4
+Protocol:      2.07+
+
+  In a paravirtualized environment the hardware low level architectural
+  pieces such as interrupt handling, page table handling, and
+  accessing process control registers needs to be done differently.
+
+  This field allows the bootloader to inform the kernel we are in one
+  one of those environments.
+
+  0x00000000   The default x86/PC environment
+  0x00000001   lguest
+  0x00000002   Xen
+
+Field name:    hardware_subarch_data
+Type:          write
+Offset/size:   0x240/8
+Protocol:      2.07+
+
+  A pointer to data that is specific to hardware subarch
+
 
 **** THE KERNEL COMMAND LINE
 
index 6166e2d7da76244d628da0543a25ae36f97da4da..7a7753321a263f62c2a00c9d0e348716e701ac2c 100644 (file)
@@ -519,17 +519,17 @@ more details, with real examples.
        to the user why it stops.
 
     cc-cross-prefix
-       cc-cross-prefix is used to check if there exist a $(CC) in path with
+       cc-cross-prefix is used to check if there exists a $(CC) in path with
        one of the listed prefixes. The first prefix where there exist a
        prefix$(CC) in the PATH is returned - and if no prefix$(CC) is found
        then nothing is returned.
        Additional prefixes are separated by a single space in the
        call of cc-cross-prefix.
-       This functionality is usefull for architecture Makefile that try
-       to set CROSS_COMPILE to well know values but may have several
+       This functionality is useful for architecture Makefiles that try
+       to set CROSS_COMPILE to well-known values but may have several
        values to select between.
-       It is recommended only to try to set CROSS_COMPILE is it is a cross
-       build (host arch is different from target arch). And is CROSS_COMPILE
+       It is recommended only to try to set CROSS_COMPILE if it is a cross
+       build (host arch is different from target arch). And if CROSS_COMPILE
        is already set then leave it with the old value.
 
        Example:
index 6accd360da735cce8f9e9adecf0e5938d2e8e590..b2361667839fd8850c385d1ba0a1f5cea1878751 100644 (file)
@@ -772,6 +772,23 @@ and is between 256 and 4096 characters. It is defined in the file
 
        inttest=        [IA64]
 
+       intel_iommu=    [DMAR] Intel IOMMU driver (DMAR) option
+               off
+                       Disable intel iommu driver.
+               igfx_off [Default Off]
+                       By default, gfx is mapped as normal device. If a gfx
+                       device has a dedicated DMAR unit, the DMAR unit is
+                       bypassed by not enabling DMAR with this option. In
+                       this case, gfx device will use physical address for
+                       DMA.
+               forcedac [x86_64]
+                       With this option iommu will not optimize to look
+                       for io virtual address below 32 bit forcing dual
+                       address cycle on pci bus for cards supporting greater
+                       than 32 bit addressing. The default is to look
+                       for translation below 32 bit and if not available
+                       then look in the higher range.
+
        io7=            [HW] IO7 for Marvel based alpha systems
                        See comment before marvel_specify_io7 in
                        arch/alpha/kernel/core_marvel.c.
index c0b7a4556390e7c15e3f088ab1368c5db3cb9cca..bac037eb1cda771905bc9ed22926f8eb6a237481 100644 (file)
@@ -1,28 +1,8 @@
 # This creates the demonstration utility "lguest" which runs a Linux guest.
-
-# For those people that have a separate object dir, look there for .config
-KBUILD_OUTPUT := ../..
-ifdef O
-  ifeq ("$(origin O)", "command line")
-    KBUILD_OUTPUT := $(O)
-  endif
-endif
-# We rely on CONFIG_PAGE_OFFSET to know where to put lguest binary.
-include $(KBUILD_OUTPUT)/.config
-LGUEST_GUEST_TOP := ($(CONFIG_PAGE_OFFSET) - 0x08000000)
-
-CFLAGS:=-Wall -Wmissing-declarations -Wmissing-prototypes -O3 -Wl,-T,lguest.lds
+CFLAGS:=-Wall -Wmissing-declarations -Wmissing-prototypes -O3 -I../../include
 LDLIBS:=-lz
-# Removing this works for some versions of ld.so (eg. Ubuntu Feisty) and
-# not others (eg. FC7).
-LDFLAGS+=-static
-all: lguest.lds lguest
 
-# The linker script on x86 is so complex the only way of creating one
-# which will link our binary in the right place is to mangle the
-# default one.
-lguest.lds:
-       $(LD) --verbose | awk '/^==========/ { PRINT=1; next; } /SIZEOF_HEADERS/ { gsub(/0x[0-9A-F]*/, "$(LGUEST_GUEST_TOP)") } { if (PRINT) print $$0; }' > $@
+all: lguest
 
 clean:
-       rm -f lguest.lds lguest
+       rm -f lguest
index 103e346c8b6adc0f2f584fe491c55a3cefa82756..5bdc37f8184292a57e273f4256d698ef148b68a4 100644 (file)
@@ -1,10 +1,7 @@
 /*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 reads repeatedly from /dev/lguest to run the Guest.
- *
- * The only trick: the Makefile links it at a high address so it will be clear
- * of the guest memory region.  It means that each Guest cannot have more than
- * about 2.5G of memory on a normally configured Host. :*/
+:*/
 #define _LARGEFILE64_SOURCE
 #define _GNU_SOURCE
 #include <stdio.h>
@@ -15,6 +12,7 @@
 #include <stdlib.h>
 #include <elf.h>
 #include <sys/mman.h>
+#include <sys/param.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
@@ -34,7 +32,9 @@
 #include <termios.h>
 #include <getopt.h>
 #include <zlib.h>
-/*L:110 We can ignore the 28 include files we need for this program, but I do
+#include <assert.h>
+#include <sched.h>
+/*L:110 We can ignore the 30 include files we need for this program, but I do
  * want to draw attention to the use of kernel-style types.
  *
  * As Linus said, "C is a Spartan language, and so should your naming be."  I
@@ -45,8 +45,14 @@ typedef unsigned long long u64;
 typedef uint32_t u32;
 typedef uint16_t u16;
 typedef uint8_t u8;
-#include "../../include/linux/lguest_launcher.h"
-#include "../../include/asm-x86/e820_32.h"
+#include "linux/lguest_launcher.h"
+#include "linux/pci_ids.h"
+#include "linux/virtio_config.h"
+#include "linux/virtio_net.h"
+#include "linux/virtio_blk.h"
+#include "linux/virtio_console.h"
+#include "linux/virtio_ring.h"
+#include "asm-x86/bootparam.h"
 /*:*/
 
 #define PAGE_PRESENT 0x7       /* Present, RW, Execute */
@@ -55,6 +61,10 @@ typedef uint8_t u8;
 #ifndef SIOCBRADDIF
 #define SIOCBRADDIF    0x89a2          /* add interface to bridge      */
 #endif
+/* We can have up to 256 pages for devices. */
+#define DEVICE_PAGES 256
+/* This fits nicely in a single 4096-byte page. */
+#define VIRTQUEUE_NUM 127
 
 /*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. */
@@ -65,8 +75,10 @@ static bool verbose;
 
 /* The pipe to send commands to the waker process */
 static int waker_fd;
-/* The top of guest physical memory. */
-static u32 top;
+/* 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;
 
 /* This is our list of devices. */
 struct device_list
@@ -76,8 +88,17 @@ struct device_list
        fd_set infds;
        int max_infd;
 
+       /* Counter to assign interrupt numbers. */
+       unsigned int next_irq;
+
+       /* Counter to print out convenient device numbers. */
+       unsigned int device_num;
+
        /* The descriptor page for the devices. */
-       struct lguest_device_desc *descs;
+       u8 *descpage;
+
+       /* The tail of the last descriptor. */
+       unsigned int desc_used;
 
        /* A single linked list of devices. */
        struct device *dev;
@@ -85,31 +106,111 @@ struct device_list
        struct device **lastdev;
 };
 
+/* The list of Guest devices, based on command line arguments. */
+static struct device_list devices;
+
 /* The device structure describes a single device. */
 struct device
 {
        /* The linked-list pointer. */
        struct device *next;
-       /* The descriptor for this device, as mapped into the Guest. */
+
+       /* The this device's descriptor, as mapped into the Guest. */
        struct lguest_device_desc *desc;
-       /* The memory page(s) of this device, if any.  Also mapped in Guest. */
-       void *mem;
+
+       /* The name of this device, for --verbose. */
+       const char *name;
 
        /* If handle_input is set, it wants to be called when this file
         * descriptor is ready. */
        int fd;
        bool (*handle_input)(int fd, struct device *me);
 
-       /* If handle_output is set, it wants to be called when the Guest sends
-        * DMA to this key. */
-       unsigned long watch_key;
-       u32 (*handle_output)(int fd, const struct iovec *iov,
-                            unsigned int num, struct device *me);
+       /* Any queues attached to this device */
+       struct virtqueue *vq;
 
        /* Device-specific data. */
        void *priv;
 };
 
+/* The virtqueue structure describes a queue attached to a device. */
+struct virtqueue
+{
+       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;
+
+       /* The routine to call when the Guest pings us. */
+       void (*handle_output)(int fd, struct virtqueue *me);
+};
+
+/* Since guest is UP and we don't run at the same time, we don't need barriers.
+ * But I include them in the code in case others copy it. */
+#define wmb()
+
+/* Convert an iovec element to the given type.
+ *
+ * This is a fairly ugly trick: we need to know the size of the type and
+ * alignment requirement to check the pointer is kosher.  It's also nice to
+ * have the name of the type in case we report failure.
+ *
+ * Typing those three things all the time is cumbersome and error prone, so we
+ * have a macro which sets them all up and passes to the real function. */
+#define convert(iov, type) \
+       ((type *)_convert((iov), sizeof(type), __alignof__(type), #type))
+
+static void *_convert(struct iovec *iov, size_t size, size_t align,
+                     const char *name)
+{
+       if (iov->iov_len != size)
+               errx(1, "Bad iovec size %zu for %s", iov->iov_len, name);
+       if ((unsigned long)iov->iov_base % align != 0)
+               errx(1, "Bad alignment %p for %s", iov->iov_base, name);
+       return iov->iov_base;
+}
+
+/* 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. */
+#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)
+#define le64_to_cpu(v32) (v64)
+
+/*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.
+ *
+ * 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
+ * use these trivial conversion functions when the Guest gives us it's
+ * "physical" addresses: */
+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);
+}
+
 /*L:130
  * Loading the Kernel.
  *
@@ -123,43 +224,55 @@ static int open_or_die(const char *name, int flags)
        return fd;
 }
 
-/* map_zeroed_pages() takes a (page-aligned) address and a number of pages. */
-static void *map_zeroed_pages(unsigned long addr, unsigned int num)
+/* map_zeroed_pages() takes a number of pages. */
+static void *map_zeroed_pages(unsigned int num)
 {
-       /* We cache the /dev/zero file-descriptor so we only open it once. */
-       static int fd = -1;
-
-       if (fd == -1)
-               fd = open_or_die("/dev/zero", O_RDONLY);
+       int fd = open_or_die("/dev/zero", O_RDONLY);
+       void *addr;
 
        /* We use a private mapping (ie. if we write to the page, it will be
-        * copied), and obviously we insist that it be mapped where we ask. */
-       if (mmap((void *)addr, getpagesize() * num,
-                PROT_READ|PROT_WRITE|PROT_EXEC, MAP_FIXED|MAP_PRIVATE, fd, 0)
-           != (void *)addr)
-               err(1, "Mmaping %u pages of /dev/zero @%p", num, (void *)addr);
-
-       /* Returning the address is just a courtesy: can simplify callers. */
-       return (void *)addr;
+        * copied). */
+       addr = mmap(NULL, getpagesize() * num,
+                   PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE, fd, 0);
+       if (addr == MAP_FAILED)
+               err(1, "Mmaping %u pages of /dev/zero", num);
+
+       return addr;
 }
 
-/* To find out where to start we look for the magic Guest string, which marks
- * the code we see in lguest_asm.S.  This is a hack which we are currently
- * plotting to replace with the normal Linux entry point. */
-static unsigned long entry_point(void *start, void *end,
-                                unsigned long page_offset)
+/* Get some more pages for a device. */
+static void *get_pages(unsigned int num)
 {
-       void *p;
+       void *addr = from_guest_phys(guest_limit);
 
-       /* The scan gives us the physical starting address.  We want the
-        * virtual address in this case, and fortunately, we already figured
-        * out the physical-virtual difference and passed it here in
-        * "page_offset". */
-       for (p = start; p < end; p++)
-               if (memcmp(p, "GenuineLguest", strlen("GenuineLguest")) == 0)
-                       return (long)p + strlen("GenuineLguest") + page_offset;
+       guest_limit += num * getpagesize();
+       if (guest_limit > guest_max)
+               errx(1, "Not enough memory for devices");
+       return addr;
+}
 
-       err(1, "Is this image a genuine lguest?");
+/* This routine is used to load the kernel or initrd.  It tries mmap, but if
+ * that fails (Plan 9's kernel file isn't nicely aligned on page boundaries),
+ * it falls back to reading the memory in. */
+static void map_at(int fd, void *addr, unsigned long offset, unsigned long len)
+{
+       ssize_t r;
+
+       /* We map writable even though for some segments are marked read-only.
+        * 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
+        * Guests. */
+       if (mmap(addr, len, PROT_READ|PROT_WRITE|PROT_EXEC,
+                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);
 }
 
 /* This routine takes an open vmlinux image, which is in ELF, and maps it into
@@ -167,19 +280,14 @@ static unsigned long entry_point(void *start, void *end,
  * by all modern binaries on Linux including the kernel.
  *
  * The ELF headers give *two* addresses: a physical address, and a virtual
- * address.  The Guest kernel expects to be placed in memory at the physical
- * address, and the page tables set up so it will correspond to that virtual
- * address.  We return the difference between the virtual and physical
- * addresses in the "page_offset" pointer.
+ * address.  We use the physical address; the Guest will map itself to the
+ * virtual address.
  *
  * We return the starting address. */
-static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr,
-                            unsigned long *page_offset)
+static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr)
 {
-       void *addr;
        Elf32_Phdr phdr[ehdr->e_phnum];
        unsigned int i;
-       unsigned long start = -1UL, end = 0;
 
        /* Sanity checks on the main ELF header: an x86 executable with a
         * reasonable number of correctly-sized program headers. */
@@ -199,9 +307,6 @@ static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr,
        if (read(elf_fd, phdr, sizeof(phdr)) != sizeof(phdr))
                err(1, "Reading program headers");
 
-       /* We don't know page_offset yet. */
-       *page_offset = 0;
-
        /* Try all the headers: there are usually only three.  A read-only one,
         * a read-write one, and a "note" section which isn't loadable. */
        for (i = 0; i < ehdr->e_phnum; i++) {
@@ -212,158 +317,53 @@ static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr,
                verbose("Section %i: size %i addr %p\n",
                        i, phdr[i].p_memsz, (void *)phdr[i].p_paddr);
 
-               /* We expect a simple linear address space: every segment must
-                * have the same difference between virtual (p_vaddr) and
-                * physical (p_paddr) address. */
-               if (!*page_offset)
-                       *page_offset = phdr[i].p_vaddr - phdr[i].p_paddr;
-               else if (*page_offset != phdr[i].p_vaddr - phdr[i].p_paddr)
-                       errx(1, "Page offset of section %i different", i);
-
-               /* We track the first and last address we mapped, so we can
-                * tell entry_point() where to scan. */
-               if (phdr[i].p_paddr < start)
-                       start = phdr[i].p_paddr;
-               if (phdr[i].p_paddr + phdr[i].p_filesz > end)
-                       end = phdr[i].p_paddr + phdr[i].p_filesz;
-
-               /* We map this section of the file at its physical address.  We
-                * map it read & write even if the header says this segment is
-                * read-only.  The kernel really wants to be writable: it
-                * patches its own instructions which would normally be
-                * read-only.
-                *
-                * MAP_PRIVATE means that the page won't be copied until a
-                * write is done to it.  This allows us to share much of the
-                * kernel memory between Guests. */
-               addr = mmap((void *)phdr[i].p_paddr,
-                           phdr[i].p_filesz,
-                           PROT_READ|PROT_WRITE|PROT_EXEC,
-                           MAP_FIXED|MAP_PRIVATE,
-                           elf_fd, phdr[i].p_offset);
-               if (addr != (void *)phdr[i].p_paddr)
-                       err(1, "Mmaping vmlinux seg %i gave %p not %p",
-                           i, addr, (void *)phdr[i].p_paddr);
+               /* We map this section of the file at its physical address. */
+               map_at(elf_fd, from_guest_phys(phdr[i].p_paddr),
+                      phdr[i].p_offset, phdr[i].p_filesz);
        }
 
-       return entry_point((void *)start, (void *)end, *page_offset);
+       /* The entry point is given in the ELF header. */
+       return ehdr->e_entry;
 }
 
-/*L:170 Prepare to be SHOCKED and AMAZED.  And possibly a trifle nauseated.
- *
- * We know that CONFIG_PAGE_OFFSET sets what virtual address the kernel expects
- * to be.  We don't know what that option was, but we can figure it out
- * approximately by looking at the addresses in the code.  I chose the common
- * case of reading a memory location into the %eax register:
- *
- *  movl <some-address>, %eax
- *
- * This gets encoded as five bytes: "0xA1 <4-byte-address>".  For example,
- * "0xA1 0x18 0x60 0x47 0xC0" reads the address 0xC0476018 into %eax.
- *
- * In this example can guess that the kernel was compiled with
- * CONFIG_PAGE_OFFSET set to 0xC0000000 (it's always a round number).  If the
- * kernel were larger than 16MB, we might see 0xC1 addresses show up, but our
- * kernel isn't that bloated yet.
- *
- * Unfortunately, x86 has variable-length instructions, so finding this
- * particular instruction properly involves writing a disassembler.  Instead,
- * we rely on statistics.  We look for "0xA1" and tally the different bytes
- * which occur 4 bytes later (the "0xC0" in our example above).  When one of
- * those bytes appears three times, we can be reasonably confident that it
- * forms the start of CONFIG_PAGE_OFFSET.
+/*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.
  *
- * This is amazingly reliable. */
-static unsigned long intuit_page_offset(unsigned char *img, unsigned long len)
+ * 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
+ * the funky header so we know where in the file to load, and away we go! */
+static unsigned long load_bzimage(int fd)
 {
-       unsigned int i, possibilities[256] = { 0 };
+       struct boot_params boot;
+       int r;
+       /* Modern bzImages get loaded at 1M. */
+       void *p = from_guest_phys(0x100000);
 
-       for (i = 0; i + 4 < len; i++) {
-               /* mov 0xXXXXXXXX,%eax */
-               if (img[i] == 0xA1 && ++possibilities[img[i+4]] > 3)
-                       return (unsigned long)img[i+4] << 24;
-       }
-       errx(1, "could not determine page offset");
-}
+       /* Go back to the start of the file and read the header.  It should be
+        * a Linux boot header (see Documentation/i386/boot.txt) */
+       lseek(fd, 0, SEEK_SET);
+       read(fd, &boot, sizeof(boot));
 
-/*L:160 Unfortunately the entire ELF image isn't compressed: the segments
- * which need loading are extracted and compressed raw.  This denies us the
- * information we need to make a fully-general loader. */
-static unsigned long unpack_bzimage(int fd, unsigned long *page_offset)
-{
-       gzFile f;
-       int ret, len = 0;
-       /* A bzImage always gets loaded at physical address 1M.  This is
-        * actually configurable as CONFIG_PHYSICAL_START, but as the comment
-        * there says, "Don't change this unless you know what you are doing".
-        * Indeed. */
-       void *img = (void *)0x100000;
-
-       /* gzdopen takes our file descriptor (carefully placed at the start of
-        * the GZIP header we found) and returns a gzFile. */
-       f = gzdopen(fd, "rb");
-       /* We read it into memory in 64k chunks until we hit the end. */
-       while ((ret = gzread(f, img + len, 65536)) > 0)
-               len += ret;
-       if (ret < 0)
-               err(1, "reading image from bzImage");
-
-       verbose("Unpacked size %i addr %p\n", len, img);
-
-       /* Without the ELF header, we can't tell virtual-physical gap.  This is
-        * CONFIG_PAGE_OFFSET, and people do actually change it.  Fortunately,
-        * I have a clever way of figuring it out from the code itself.  */
-       *page_offset = intuit_page_offset(img, len);
-
-       return entry_point(img, img + len, *page_offset);
-}
+       /* Inside the setup_hdr, we expect the magic "HdrS" */
+       if (memcmp(&boot.hdr.header, "HdrS", 4) != 0)
+               errx(1, "This doesn't look like a bzImage to me");
 
-/*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 can't do that
- * because the Guest can't run the unpacking code, and adding features to
- * lguest kills puppies, so we don't want to.
- *
- * The bzImage is formed by putting the decompressing code in front of the
- * compressed kernel code.  So we can simple scan through it looking for the
- * first "gzip" header, and start decompressing from there. */
-static unsigned long load_bzimage(int fd, unsigned long *page_offset)
-{
-       unsigned char c;
-       int state = 0;
-
-       /* GZIP header is 0x1F 0x8B <method> <flags>... <compressed-by>. */
-       while (read(fd, &c, 1) == 1) {
-               switch (state) {
-               case 0:
-                       if (c == 0x1F)
-                               state++;
-                       break;
-               case 1:
-                       if (c == 0x8B)
-                               state++;
-                       else
-                               state = 0;
-                       break;
-               case 2 ... 8:
-                       state++;
-                       break;
-               case 9:
-                       /* Seek back to the start of the gzip header. */
-                       lseek(fd, -10, SEEK_CUR);
-                       /* One final check: "compressed under UNIX". */
-                       if (c != 0x03)
-                               state = -1;
-                       else
-                               return unpack_bzimage(fd, page_offset);
-               }
-       }
-       errx(1, "Could not find kernel in bzImage");
+       /* Skip over the extra sectors of the header. */
+       lseek(fd, (boot.hdr.setup_sects+1) * 512, SEEK_SET);
+
+       /* Now read everything into memory. in nice big chunks. */
+       while ((r = read(fd, p, 65536)) > 0)
+               p += r;
+
+       /* Finally, code32_start tells us where to enter the kernel. */
+       return boot.hdr.code32_start;
 }
 
 /*L:140 Loading the kernel is easy when it's a "vmlinux", but most kernels
  * come wrapped up in the self-decompressing "bzImage" format.  With some funky
  * coding, we can load those, too. */
-static unsigned long load_kernel(int fd, unsigned long *page_offset)
+static unsigned long load_kernel(int fd)
 {
        Elf32_Ehdr hdr;
 
@@ -373,10 +373,10 @@ static unsigned long load_kernel(int fd, unsigned long *page_offset)
 
        /* If it's an ELF file, it starts with "\177ELF" */
        if (memcmp(hdr.e_ident, ELFMAG, SELFMAG) == 0)
-               return map_elf(fd, &hdr, page_offset);
+               return map_elf(fd, &hdr);
 
        /* Otherwise we assume it's a bzImage, and try to unpack it */
-       return load_bzimage(fd, page_offset);
+       return load_bzimage(fd);
 }
 
 /* This is a trivial little helper to align pages.  Andi Kleen hated it because
@@ -402,59 +402,45 @@ static unsigned long load_initrd(const char *name, unsigned long mem)
        int ifd;
        struct stat st;
        unsigned long len;
-       void *iaddr;
 
        ifd = open_or_die(name, O_RDONLY);
        /* fstat() is needed to get the file size. */
        if (fstat(ifd, &st) < 0)
                err(1, "fstat() on initrd '%s'", name);
 
-       /* The length needs to be rounded up to a page size: mmap needs the
-        * address to be page aligned. */
+       /* 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. */
        len = page_align(st.st_size);
-       /* We map the initrd at the top of memory. */
-       iaddr = mmap((void *)mem - len, st.st_size,
-                    PROT_READ|PROT_EXEC|PROT_WRITE,
-                    MAP_FIXED|MAP_PRIVATE, ifd, 0);
-       if (iaddr != (void *)mem - len)
-               err(1, "Mmaping initrd '%s' returned %p not %p",
-                   name, iaddr, (void *)mem - len);
+       map_at(ifd, from_guest_phys(mem - len), 0, st.st_size);
        /* Once a file is mapped, you can close the file descriptor.  It's a
         * little odd, but quite useful. */
        close(ifd);
-       verbose("mapped initrd %s size=%lu @ %p\n", name, st.st_size, iaddr);
+       verbose("mapped initrd %s size=%lu @ %p\n", name, len, (void*)mem-len);
 
        /* We return the initrd size. */
        return len;
 }
 
-/* Once we know how much memory we have, and the address the Guest kernel
- * expects, we can construct simple linear page tables which will get the Guest
- * far enough into the boot to create its own.
+/* Once we know how much memory we have, we can construct simple linear page
+ * tables which set virtual == physical which will get the Guest far enough
+ * into the boot to create its own.
  *
  * We lay them out of the way, just below the initrd (which is why we need to
  * know its size). */
 static unsigned long setup_pagetables(unsigned long mem,
-                                     unsigned long initrd_size,
-                                     unsigned long page_offset)
+                                     unsigned long initrd_size)
 {
-       u32 *pgdir, *linear;
+       unsigned long *pgdir, *linear;
        unsigned int mapped_pages, i, linear_pages;
-       unsigned int ptes_per_page = getpagesize()/sizeof(u32);
+       unsigned int ptes_per_page = getpagesize()/sizeof(void *);
 
-       /* Ideally we map all physical memory starting at page_offset.
-        * However, if page_offset is 0xC0000000 we can only map 1G of physical
-        * (0xC0000000 + 1G overflows). */
-       if (mem <= -page_offset)
-               mapped_pages = mem/getpagesize();
-       else
-               mapped_pages = -page_offset/getpagesize();
+       mapped_pages = mem/getpagesize();
 
        /* Each PTE page can map ptes_per_page pages: how many do we need? */
        linear_pages = (mapped_pages + ptes_per_page-1)/ptes_per_page;
 
        /* We put the toplevel page directory page at the top of memory. */
-       pgdir = (void *)mem - initrd_size - getpagesize();
+       pgdir = from_guest_phys(mem) - initrd_size - getpagesize();
 
        /* Now we use the next linear_pages pages as pte pages */
        linear = (void *)pgdir - linear_pages*getpagesize();
@@ -465,20 +451,19 @@ static unsigned long setup_pagetables(unsigned long mem,
        for (i = 0; i < mapped_pages; i++)
                linear[i] = ((i * getpagesize()) | PAGE_PRESENT);
 
-       /* The top level points to the linear page table pages above.  The
-        * entry representing page_offset points to the first one, and they
-        * continue from there. */
+       /* The top level points to the linear page table pages above. */
        for (i = 0; i < mapped_pages; i += ptes_per_page) {
-               pgdir[(i + page_offset/getpagesize())/ptes_per_page]
-                       = (((u32)linear + i*sizeof(u32)) | PAGE_PRESENT);
+               pgdir[i/ptes_per_page]
+                       = ((to_guest_phys(linear) + i*sizeof(void *))
+                          | PAGE_PRESENT);
        }
 
-       verbose("Linear mapping of %u pages in %u pte pages at %p\n",
-               mapped_pages, linear_pages, linear);
+       verbose("Linear mapping of %u pages in %u pte pages at %#lx\n",
+               mapped_pages, linear_pages, to_guest_phys(linear));
 
        /* We return the top level (guest-physical) address: the kernel needs
         * to know where it is. */
-       return (unsigned long)pgdir;
+       return to_guest_phys(pgdir);
 }
 
 /* Simple routine to roll all the commandline arguments together with spaces
@@ -498,14 +483,17 @@ static void concat(char *dst, char *args[])
 
 /* This is where we actually tell the kernel to initialize the Guest.  We saw
  * the arguments it expects when we looked at initialize() in lguest_user.c:
- * the top physical page to allow, the top level pagetable, the entry point and
- * the page_offset constant for the Guest. */
-static int tell_kernel(u32 pgdir, u32 start, u32 page_offset)
+ * the base of guest "physical" memory, the top physical page to allow, the
+ * top level pagetable and the entry point for the Guest. */
+static int tell_kernel(unsigned long pgdir, unsigned long start)
 {
-       u32 args[] = { LHREQ_INITIALIZE,
-                      top/getpagesize(), pgdir, start, page_offset };
+       unsigned long args[] = { LHREQ_INITIALIZE,
+                                (unsigned long)guest_base,
+                                guest_limit / getpagesize(), pgdir, start };
        int fd;
 
+       verbose("Guest: %p - %p (%#lx)\n",
+               guest_base, guest_base + guest_limit, guest_limit);
        fd = open_or_die("/dev/lguest", O_RDWR);
        if (write(fd, args, sizeof(args)) < 0)
                err(1, "Writing to /dev/lguest");
@@ -515,11 +503,11 @@ static int tell_kernel(u32 pgdir, u32 start, u32 page_offset)
 }
 /*:*/
 
-static void set_fd(int fd, struct device_list *devices)
+static void add_device_fd(int fd)
 {
-       FD_SET(fd, &devices->infds);
-       if (fd > devices->max_infd)
-               devices->max_infd = fd;
+       FD_SET(fd, &devices.infds);
+       if (fd > devices.max_infd)
+               devices.max_infd = fd;
 }
 
 /*L:200
@@ -537,36 +525,38 @@ static void set_fd(int fd, struct device_list *devices)
  *
  * This, of course, is merely a different *kind* of icky.
  */
-static void wake_parent(int pipefd, int lguest_fd, struct device_list *devices)
+static void wake_parent(int pipefd, int lguest_fd)
 {
        /* Add the pipe from the Launcher to the fdset in the device_list, so
         * we watch it, too. */
-       set_fd(pipefd, devices);
+       add_device_fd(pipefd);
 
        for (;;) {
-               fd_set rfds = devices->infds;
-               u32 args[] = { LHREQ_BREAK, 1 };
+               fd_set rfds = devices.infds;
+               unsigned long args[] = { LHREQ_BREAK, 1 };
 
                /* Wait until input is ready from one of the devices. */
-               select(devices->max_infd+1, &rfds, NULL, NULL, NULL);
+               select(devices.max_infd+1, &rfds, NULL, NULL, NULL);
                /* Is it a message from the Launcher? */
                if (FD_ISSET(pipefd, &rfds)) {
-                       int ignorefd;
+                       int fd;
                        /* If read() returns 0, it means the Launcher has
                         * exited.  We silently follow. */
-                       if (read(pipefd, &ignorefd, sizeof(ignorefd)) == 0)
+                       if (read(pipefd, &fd, sizeof(fd)) == 0)
                                exit(0);
-                       /* Otherwise it's telling us there's a problem with one
-                        * of the devices, and we should ignore that file
-                        * descriptor from now on. */
-                       FD_CLR(ignorefd, &devices->infds);
+                       /* Otherwise it's telling us to change what file
+                        * descriptors we're to listen to. */
+                       if (fd >= 0)
+                               FD_SET(fd, &devices.infds);
+                       else
+                               FD_CLR(-fd - 1, &devices.infds);
                } else /* Send LHREQ_BREAK command. */
                        write(lguest_fd, args, sizeof(args));
        }
 }
 
 /* This routine just sets up a pipe to the Waker process. */
-static int setup_waker(int lguest_fd, struct device_list *device_list)
+static int setup_waker(int lguest_fd)
 {
        int pipefd[2], child;
 
@@ -580,7 +570,7 @@ static int setup_waker(int lguest_fd, struct device_list *device_list)
        if (child == 0) {
                /* Close the "writing" end of our copy of the pipe */
                close(pipefd[1]);
-               wake_parent(pipefd[0], lguest_fd, device_list);
+               wake_parent(pipefd[0], lguest_fd);
        }
        /* Close the reading end of our copy of the pipe. */
        close(pipefd[0]);
@@ -602,83 +592,128 @@ static void *_check_pointer(unsigned long addr, unsigned int size,
 {
        /* We have to separately check addr and addr+size, because size could
         * be huge and addr + size might wrap around. */
-       if (addr >= top || addr + size >= top)
-               errx(1, "%s:%i: Invalid address %li", __FILE__, line, addr);
+       if (addr >= guest_limit || addr + size >= guest_limit)
+               errx(1, "%s:%i: Invalid address %#lx", __FILE__, line, addr);
        /* We return a pointer for the caller's convenience, now we know it's
         * safe to use. */
-       return (void *)addr;
+       return from_guest_phys(addr);
 }
 /* A macro which transparently hands the line number to the real function. */
 #define check_pointer(addr,size) _check_pointer(addr, size, __LINE__)
 
-/* The Guest has given us the address of a "struct lguest_dma".  We check it's
- * OK and convert it to an iovec (which is a simple array of ptr/size
- * pairs). */
-static u32 *dma2iov(unsigned long dma, struct iovec iov[], unsigned *num)
+/* This function returns the next descriptor in the chain, or vq->vring.num. */
+static unsigned next_desc(struct virtqueue *vq, unsigned int i)
 {
-       unsigned int i;
-       struct lguest_dma *udma;
-
-       /* First we make sure that the array memory itself is valid. */
-       udma = check_pointer(dma, sizeof(*udma));
-       /* Now we check each element */
-       for (i = 0; i < LGUEST_MAX_DMA_SECTIONS; i++) {
-               /* A zero length ends the array. */
-               if (!udma->len[i])
-                       break;
+       unsigned int next;
 
-               iov[i].iov_base = check_pointer(udma->addr[i], udma->len[i]);
-               iov[i].iov_len = udma->len[i];
-       }
-       *num = i;
+       /* If this descriptor says it doesn't chain, we're done. */
+       if (!(vq->vring.desc[i].flags & VRING_DESC_F_NEXT))
+               return vq->vring.num;
+
+       /* Check they're not leading us off end of descriptors. */
+       next = vq->vring.desc[i].next;
+       /* Make sure compiler knows to grab that: we don't want it changing! */
+       wmb();
 
-       /* We return the pointer to where the caller should write the amount of
-        * the buffer used. */
-       return &udma->used_len;
+       if (next >= vq->vring.num)
+               errx(1, "Desc next is %u", next);
+
+       return next;
+}
+
+/* This looks in the virtqueue and for the first available buffer, and converts
+ * 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.
+ *
+ * This function returns the descriptor number found, or vq->vring.num (which
+ * is never a valid descriptor number) if none was found. */
+static unsigned get_vq_desc(struct virtqueue *vq,
+                           struct iovec iov[],
+                           unsigned int *out_num, unsigned int *in_num)
+{
+       unsigned int i, head;
+
+       /* Check it isn't doing very strange things with descriptor numbers. */
+       if ((u16)(vq->vring.avail->idx - vq->last_avail_idx) > vq->vring.num)
+               errx(1, "Guest moved used index from %u to %u",
+                    vq->last_avail_idx, vq->vring.avail->idx);
+
+       /* If there's nothing new since last we looked, return invalid. */
+       if (vq->vring.avail->idx == vq->last_avail_idx)
+               return vq->vring.num;
+
+       /* Grab the next descriptor number they're advertising, and increment
+        * the index we've seen. */
+       head = vq->vring.avail->ring[vq->last_avail_idx++ % vq->vring.num];
+
+       /* 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;
+
+       i = head;
+       do {
+               /* Grab the first descriptor, and check it's OK. */
+               iov[*out_num + *in_num].iov_len = vq->vring.desc[i].len;
+               iov[*out_num + *in_num].iov_base
+                       = check_pointer(vq->vring.desc[i].addr,
+                                       vq->vring.desc[i].len);
+               /* If this is an input descriptor, increment that count. */
+               if (vq->vring.desc[i].flags & VRING_DESC_F_WRITE)
+                       (*in_num)++;
+               else {
+                       /* If it's an output descriptor, they're all supposed
+                        * to come before any input descriptors. */
+                       if (*in_num)
+                               errx(1, "Descriptor has out after in");
+                       (*out_num)++;
+               }
+
+               /* If we've got too many, that implies a descriptor loop. */
+               if (*out_num + *in_num > vq->vring.num)
+                       errx(1, "Looped descriptor");
+       } while ((i = next_desc(vq, i)) != vq->vring.num);
+
+       return head;
 }
 
-/* This routine gets a DMA buffer from the Guest for a given key, and converts
- * it to an iovec array.  It returns the interrupt the Guest wants when we're
- * finished, and a pointer to the "used_len" field to fill in. */
-static u32 *get_dma_buffer(int fd, void *key,
-                          struct iovec iov[], unsigned int *num, u32 *irq)
+/* Once we've used one of their buffers, we tell them about it.  We'll then
+ * want to send them an interrupt, using trigger_irq(). */
+static void add_used(struct virtqueue *vq, unsigned int head, int len)
 {
-       u32 buf[] = { LHREQ_GETDMA, (u32)key };
-       unsigned long udma;
-       u32 *res;
-
-       /* Ask the kernel for a DMA buffer corresponding to this key. */
-       udma = write(fd, buf, sizeof(buf));
-       /* They haven't registered any, or they're all used? */
-       if (udma == (unsigned long)-1)
-               return NULL;
-
-       /* Convert it into our iovec array */
-       res = dma2iov(udma, iov, num);
-       /* The kernel stashes irq in ->used_len to get it out to us. */
-       *irq = *res;
-       /* Return a pointer to ((struct lguest_dma *)udma)->used_len. */
-       return res;
+       struct vring_used_elem *used;
+
+       /* Get a pointer to the next entry in the used ring. */
+       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++;
 }
 
-/* This is a convenient routine to send the Guest an interrupt. */
-static void trigger_irq(int fd, u32 irq)
+/* This actually sends the interrupt for this virtqueue */
+static void trigger_irq(int fd, struct virtqueue *vq)
 {
-       u32 buf[] = { LHREQ_IRQ, irq };
+       unsigned long buf[] = { LHREQ_IRQ, vq->config.irq };
+
+       if (vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)
+               return;
+
+       /* Send the Guest an interrupt tell them we used something up. */
        if (write(fd, buf, sizeof(buf)) != 0)
-               err(1, "Triggering irq %i", irq);
+               err(1, "Triggering irq %i", vq->config.irq);
 }
 
-/* This simply sets up an iovec array where we can put data to be discarded.
- * This happens when the Guest doesn't want or can't handle the input: we have
- * to get rid of it somewhere, and if we bury it in the ceiling space it will
- * start to smell after a week. */
-static void discard_iovec(struct iovec *iov, unsigned int *num)
+/* And here's the combo meal deal.  Supersize me! */
+static void add_used_and_trigger(int fd, struct virtqueue *vq,
+                                unsigned int head, int len)
 {
-       static char discard_buf[1024];
-       *num = 1;
-       iov->iov_base = discard_buf;
-       iov->iov_len = sizeof(discard_buf);
+       add_used(vq, head, len);
+       trigger_irq(fd, vq);
 }
 
 /* Here is the input terminal setting we save, and the routine to restore them
@@ -701,38 +736,39 @@ struct console_abort
 /* This is the routine which handles console input (ie. stdin). */
 static bool handle_console_input(int fd, struct device *dev)
 {
-       u32 irq = 0, *lenp;
        int len;
-       unsigned int num;
-       struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
+       unsigned int head, in_num, out_num;
+       struct iovec iov[dev->vq->vring.num];
        struct console_abort *abort = dev->priv;
 
-       /* First we get the console buffer from the Guest.  The key is dev->mem
-        * which was set to 0 in setup_console(). */
-       lenp = get_dma_buffer(fd, dev->mem, iov, &num, &irq);
-       if (!lenp) {
-               /* If it's not ready for input, warn and set up to discard. */
-               warn("console: no dma buffer!");
-               discard_iovec(iov, &num);
-       }
+       /* First we need a console buffer from the Guests's input virtqueue. */
+       head = get_vq_desc(dev->vq, iov, &out_num, &in_num);
+
+       /* If they're not ready for input, stop listening to this file
+        * descriptor.  We'll start again once they add an input buffer. */
+       if (head == dev->vq->vring.num)
+               return false;
+
+       if (out_num)
+               errx(1, "Output buffers in console in queue?");
 
        /* This is why we convert to iovecs: the readv() call uses them, and so
         * it reads straight into the Guest's buffer. */
-       len = readv(dev->fd, iov, num);
+       len = readv(dev->fd, iov, in_num);
        if (len <= 0) {
                /* This implies that the console is closed, is /dev/null, or
-                * something went terribly wrong.  We still go through the rest
-                * of the logic, though, especially the exit handling below. */
+                * something went terribly wrong. */
                warnx("Failed to get console input, ignoring console.");
-               len = 0;
+               /* Put the input terminal back. */
+               restore_term();
+               /* Remove callback from input vq, so it doesn't restart us. */
+               dev->vq->handle_output = NULL;
+               /* Stop listening to this fd: don't call us again. */
+               return false;
        }
 
-       /* If we read the data into the Guest, fill in the length and send the
-        * interrupt. */
-       if (lenp) {
-               *lenp = len;
-               trigger_irq(fd, irq);
-       }
+       /* Tell the Guest about the new input. */
+       add_used_and_trigger(fd, dev->vq, head, len);
 
        /* Three ^C within one second?  Exit.
         *
@@ -746,7 +782,7 @@ static bool handle_console_input(int fd, struct device *dev)
                        struct timeval now;
                        gettimeofday(&now, NULL);
                        if (now.tv_sec <= abort->start.tv_sec+1) {
-                               u32 args[] = { LHREQ_BREAK, 0 };
+                               unsigned long args[] = { LHREQ_BREAK, 0 };
                                /* Close the fd so Waker will know it has to
                                 * exit. */
                                close(waker_fd);
@@ -761,214 +797,163 @@ static bool handle_console_input(int fd, struct device *dev)
                /* Any other key resets the abort counter. */
                abort->count = 0;
 
-       /* Now, if we didn't read anything, put the input terminal back and
-        * return failure (meaning, don't call us again). */
-       if (!len) {
-               restore_term();
-               return false;
-       }
        /* Everything went OK! */
        return true;
 }
 
-/* Handling console output is much simpler than input. */
-static u32 handle_console_output(int fd, const struct iovec *iov,
-                                unsigned num, struct device*dev)
+/* Handling output for console is simple: we just get all the output buffers
+ * and write them to stdout. */
+static void handle_console_output(int fd, struct virtqueue *vq)
 {
-       /* Whatever the Guest sends, write it to standard output.  Return the
-        * number of bytes written. */
-       return writev(STDOUT_FILENO, iov, num);
-}
-
-/* Guest->Host network output is also pretty easy. */
-static u32 handle_tun_output(int fd, const struct iovec *iov,
-                            unsigned num, struct device *dev)
-{
-       /* We put a flag in the "priv" pointer of the network device, and set
-        * it as soon as we see output.  We'll see why in handle_tun_input() */
-       *(bool *)dev->priv = true;
-       /* Whatever packet the Guest sent us, write it out to the tun
-        * device. */
-       return writev(dev->fd, iov, num);
+       unsigned int head, out, in;
+       int len;
+       struct iovec iov[vq->vring.num];
+
+       /* Keep getting output buffers from the Guest until we run out. */
+       while ((head = get_vq_desc(vq, iov, &out, &in)) != vq->vring.num) {
+               if (in)
+                       errx(1, "Input buffers in output queue?");
+               len = writev(STDOUT_FILENO, iov, out);
+               add_used_and_trigger(fd, vq, head, len);
+       }
 }
 
-/* This matches the peer_key() in lguest_net.c.  The key for any given slot
- * is the address of the network device's page plus 4 * the slot number. */
-static unsigned long peer_offset(unsigned int peernum)
+/* Handling output for network is also simple: we get all the output buffers
+ * and write them (ignoring the first element) to this device's file descriptor
+ * (stdout). */
+static void handle_net_output(int fd, struct virtqueue *vq)
 {
-       return 4 * peernum;
+       unsigned int head, out, in;
+       int len;
+       struct iovec iov[vq->vring.num];
+
+       /* Keep getting output buffers from the Guest until we run out. */
+       while ((head = get_vq_desc(vq, iov, &out, &in)) != vq->vring.num) {
+               if (in)
+                       errx(1, "Input buffers in output queue?");
+               /* Check header, but otherwise ignore it (we said we supported
+                * no features). */
+               (void)convert(&iov[0], struct virtio_net_hdr);
+               len = writev(vq->dev->fd, iov+1, out-1);
+               add_used_and_trigger(fd, vq, head, len);
+       }
 }
 
-/* This is where we handle a packet coming in from the tun device */
+/* This is where we handle a packet coming in from the tun device to our
+ * Guest. */
 static bool handle_tun_input(int fd, struct device *dev)
 {
-       u32 irq = 0, *lenp;
+       unsigned int head, in_num, out_num;
        int len;
-       unsigned num;
-       struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
+       struct iovec iov[dev->vq->vring.num];
+       struct virtio_net_hdr *hdr;
 
-       /* First we get a buffer the Guest has bound to its key. */
-       lenp = get_dma_buffer(fd, dev->mem+peer_offset(NET_PEERNUM), iov, &num,
-                             &irq);
-       if (!lenp) {
+       /* First we need a network buffer from the Guests's recv virtqueue. */
+       head = get_vq_desc(dev->vq, iov, &out_num, &in_num);
+       if (head == dev->vq->vring.num) {
                /* Now, it's expected that if we try to send a packet too
-                * early, the Guest won't be ready yet.  This is why we set a
-                * flag when the Guest sends its first packet.  If it's sent a
-                * packet we assume it should be ready to receive them.
-                *
-                * Actually, this is what the status bits in the descriptor are
-                * for: we should *use* them.  FIXME! */
-               if (*(bool *)dev->priv)
+                * early, the Guest won't be ready yet.  Wait until the device
+                * status says it's ready. */
+               /* FIXME: Actually want DRIVER_ACTIVE here. */
+               if (dev->desc->status & VIRTIO_CONFIG_S_DRIVER_OK)
                        warn("network: no dma buffer!");
-               discard_iovec(iov, &num);
-       }
+               /* We'll turn this back on if input buffers are registered. */
+               return false;
+       } else if (out_num)
+               errx(1, "Output buffers in network recv queue?");
+
+       /* First element is the header: we set it to 0 (no features). */
+       hdr = convert(&iov[0], struct virtio_net_hdr);
+       hdr->flags = 0;
+       hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
 
        /* Read the packet from the device directly into the Guest's buffer. */
-       len = readv(dev->fd, iov, num);
+       len = readv(dev->fd, iov+1, in_num-1);
        if (len <= 0)
                err(1, "reading network");
 
-       /* Write the used_len, and trigger the interrupt for the Guest */
-       if (lenp) {
-               *lenp = len;
-               trigger_irq(fd, irq);
-       }
+       /* Tell the Guest about the new packet. */
+       add_used_and_trigger(fd, dev->vq, head, sizeof(*hdr) + len);
+
        verbose("tun input packet len %i [%02x %02x] (%s)\n", len,
-               ((u8 *)iov[0].iov_base)[0], ((u8 *)iov[0].iov_base)[1],
-               lenp ? "sent" : "discarded");
+               ((u8 *)iov[1].iov_base)[0], ((u8 *)iov[1].iov_base)[1],
+               head != dev->vq->vring.num ? "sent" : "discarded");
+
        /* All good. */
        return true;
 }
 
-/* The last device handling routine is block output: the Guest has sent a DMA
- * to the block device.  It will have placed the command it wants in the
- * "struct lguest_block_page". */
-static u32 handle_block_output(int fd, const struct iovec *iov,
-                              unsigned num, struct device *dev)
+/* This callback ensures we try again, in case we stopped console or net
+ * delivery because Guest didn't have any buffers. */
+static void enable_fd(int fd, struct virtqueue *vq)
 {
-       struct lguest_block_page *p = dev->mem;
-       u32 irq, *lenp;
-       unsigned int len, reply_num;
-       struct iovec reply[LGUEST_MAX_DMA_SECTIONS];
-       off64_t device_len, off = (off64_t)p->sector * 512;
-
-       /* First we extract the device length from the dev->priv pointer. */
-       device_len = *(off64_t *)dev->priv;
-
-       /* We first check that the read or write is within the length of the
-        * block file. */
-       if (off >= device_len)
-               err(1, "Bad offset %llu vs %llu", off, device_len);
-       /* Move to the right location in the block file.  This shouldn't fail,
-        * but best to check. */
-       if (lseek64(dev->fd, off, SEEK_SET) != off)
-               err(1, "Bad seek to sector %i", p->sector);
-
-       verbose("Block: %s at offset %llu\n", p->type ? "WRITE" : "READ", off);
-
-       /* They were supposed to bind a reply buffer at key equal to the start
-        * of the block device memory.  We need this to tell them when the
-        * request is finished. */
-       lenp = get_dma_buffer(fd, dev->mem, reply, &reply_num, &irq);
-       if (!lenp)
-               err(1, "Block request didn't give us a dma buffer");
-
-       if (p->type) {
-               /* A write request.  The DMA they sent contained the data, so
-                * write it out. */
-               len = writev(dev->fd, iov, num);
-               /* Grr... Now we know how long the "struct lguest_dma" they
-                * sent was, we make sure they didn't try to write over the end
-                * of the block file (possibly extending it). */
-               if (off + len > device_len) {
-                       /* Trim it back to the correct length */
-                       ftruncate64(dev->fd, device_len);
-                       /* Die, bad Guest, die. */
-                       errx(1, "Write past end %llu+%u", off, len);
-               }
-               /* The reply length is 0: we just send back an empty DMA to
-                * interrupt them and tell them the write is finished. */
-               *lenp = 0;
-       } else {
-               /* A read request.  They sent an empty DMA to start the
-                * request, and we put the read contents into the reply
-                * buffer. */
-               len = readv(dev->fd, reply, reply_num);
-               *lenp = len;
-       }
-
-       /* The result is 1 (done), 2 if there was an error (short read or
-        * write). */
-       p->result = 1 + (p->bytes != len);
-       /* Now tell them we've used their reply buffer. */
-       trigger_irq(fd, irq);
-
-       /* We're supposed to return the number of bytes of the output buffer we
-        * used.  But the block device uses the "result" field instead, so we
-        * don't bother. */
-       return 0;
+       add_device_fd(vq->dev->fd);
+       /* Tell waker to listen to it again */
+       write(waker_fd, &vq->dev->fd, sizeof(vq->dev->fd));
 }
 
-/* This is the generic routine we call when the Guest sends some DMA out. */
-static void handle_output(int fd, unsigned long dma, unsigned long key,
-                         struct device_list *devices)
+/* This is the generic routine we call when the Guest uses LHCALL_NOTIFY. */
+static void handle_output(int fd, unsigned long addr)
 {
        struct device *i;
-       u32 *lenp;
-       struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
-       unsigned num = 0;
-
-       /* Convert the "struct lguest_dma" they're sending to a "struct
-        * iovec". */
-       lenp = dma2iov(dma, iov, &num);
-
-       /* Check each device: if they expect output to this key, tell them to
-        * handle it. */
-       for (i = devices->dev; i; i = i->next) {
-               if (i->handle_output && key == i->watch_key) {
-                       /* We write the result straight into the used_len field
-                        * for them. */
-                       *lenp = i->handle_output(fd, iov, num, i);
-                       return;
+       struct virtqueue *vq;
+
+       /* Check each virtqueue. */
+       for (i = devices.dev; i; i = i->next) {
+               for (vq = i->vq; vq; vq = vq->next) {
+                       if (vq->config.pfn == addr/getpagesize()
+                           && vq->handle_output) {
+                               verbose("Output to %s\n", vq->dev->name);
+                               vq->handle_output(fd, vq);
+                               return;
+                       }
                }
        }
 
-       /* This can happen: the kernel sends any SEND_DMA which doesn't match
-        * another Guest to us.  It could be that another Guest just left a
-        * network, for example.  But it's unusual. */
-       warnx("Pending dma %p, key %p", (void *)dma, (void *)key);
+       /* Early console write is done using notify on a nul-terminated string
+        * in Guest memory. */
+       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));
 }
 
 /* This is called when the waker wakes us up: check for incoming file
  * descriptors. */
-static void handle_input(int fd, struct device_list *devices)
+static void handle_input(int fd)
 {
        /* select() wants a zeroed timeval to mean "don't wait". */
        struct timeval poll = { .tv_sec = 0, .tv_usec = 0 };
 
        for (;;) {
                struct device *i;
-               fd_set fds = devices->infds;
+               fd_set fds = devices.infds;
 
                /* If nothing is ready, we're done. */
-               if (select(devices->max_infd+1, &fds, NULL, NULL, &poll) == 0)
+               if (select(devices.max_infd+1, &fds, NULL, NULL, &poll) == 0)
                        break;
 
                /* Otherwise, call the device(s) which have readable
                 * file descriptors and a method of handling them.  */
-               for (i = devices->dev; i; i = i->next) {
+               for (i = devices.dev; i; i = i->next) {
                        if (i->handle_input && FD_ISSET(i->fd, &fds)) {
+                               int dev_fd;
+                               if (i->handle_input(fd, i))
+                                       continue;
+
                                /* If handle_input() returns false, it means we
-                                * should no longer service it.
-                                * handle_console_input() does this. */
-                               if (!i->handle_input(fd, i)) {
-                                       /* Clear it from the set of input file
-                                        * descriptors kept at the head of the
-                                        * device list. */
-                                       FD_CLR(i->fd, &devices->infds);
-                                       /* Tell waker to ignore it too... */
-                                       write(waker_fd, &i->fd, sizeof(i->fd));
-                               }
+                                * should no longer service it.  Networking and
+                                * console do this when there's no input
+                                * buffers to deliver into.  Console also uses
+                                * it when it discovers that stdin is
+                                * closed. */
+                               FD_CLR(i->fd, &devices.infds);
+                               /* Tell waker to ignore it too, by sending a
+                                * negative fd number (-1, since 0 is a valid
+                                * FD number). */
+                               dev_fd = -i->fd - 1;
+                               write(waker_fd, &dev_fd, sizeof(dev_fd));
                        }
                }
        }
@@ -982,43 +967,93 @@ static void handle_input(int fd, struct device_list *devices)
  * routines to allocate them.
  *
  * This routine allocates a new "struct lguest_device_desc" from descriptor
- * table in the devices array just above the Guest's normal memory. */
-static struct lguest_device_desc *
-new_dev_desc(struct lguest_device_desc *descs,
-            u16 type, u16 features, u16 num_pages)
+ * table just above the Guest's normal memory.  It returns a pointer to that
+ * descriptor. */
+static struct lguest_device_desc *new_dev_desc(u16 type)
 {
-       unsigned int i;
+       struct lguest_device_desc *d;
 
-       for (i = 0; i < LGUEST_MAX_DEVICES; i++) {
-               if (!descs[i].type) {
-                       descs[i].type = type;
-                       descs[i].features = features;
-                       descs[i].num_pages = num_pages;
-                       /* If they said the device needs memory, we allocate
-                        * that now, bumping up the top of Guest memory. */
-                       if (num_pages) {
-                               map_zeroed_pages(top, num_pages);
-                               descs[i].pfn = top/getpagesize();
-                               top += num_pages*getpagesize();
-                       }
-                       return &descs[i];
-               }
-       }
-       errx(1, "too many devices");
+       /* We only have one page for all the descriptors. */
+       if (devices.desc_used + sizeof(*d) > getpagesize())
+               errx(1, "Too many devices");
+
+       /* We don't need to set config_len or status: page is 0 already. */
+       d = (void *)devices.descpage + devices.desc_used;
+       d->type = type;
+       devices.desc_used += sizeof(*d);
+
+       return d;
 }
 
-/* This monster routine does all the creation and setup of a new device,
- * including caling new_dev_desc() to allocate the descriptor and device
- * memory. */
-static struct device *new_device(struct device_list *devices,
-                                u16 type, u16 num_pages, u16 features,
-                                int fd,
-                                bool (*handle_input)(int, struct device *),
-                                unsigned long watch_off,
-                                u32 (*handle_output)(int,
-                                                     const struct iovec *,
-                                                     unsigned,
-                                                     struct device *))
+/* Each device descriptor is followed by some configuration information.
+ * The first byte is a "status" byte for the Guest to report what's happening.
+ * After that are fields: u8 type, u8 len, [... len bytes...].
+ *
+ * This routine adds a new field to an existing device's descriptor.  It only
+ * works for the last device, but that's OK because that's how we use it. */
+static void add_desc_field(struct device *dev, u8 type, u8 len, const void *c)
+{
+       /* This is the last descriptor, right? */
+       assert(devices.descpage + devices.desc_used
+              == (u8 *)(dev->desc + 1) + dev->desc->config_len);
+
+       /* We only have one page of device descriptions. */
+       if (devices.desc_used + 2 + len > getpagesize())
+               errx(1, "Too many devices");
+
+       /* Copy in the new config header: type then length. */
+       devices.descpage[devices.desc_used++] = type;
+       devices.descpage[devices.desc_used++] = len;
+       memcpy(devices.descpage + devices.desc_used, c, len);
+       devices.desc_used += len;
+
+       /* Update the device descriptor length: two byte head then data. */
+       dev->desc->config_len += 2 + len;
+}
+
+/* This routine adds a virtqueue to a device.  We specify how many descriptors
+ * the virtqueue is to have. */
+static void add_virtqueue(struct device *dev, unsigned int num_descs,
+                         void (*handle_output)(int fd, struct virtqueue *me))
+{
+       unsigned int pages;
+       struct virtqueue **i, *vq = malloc(sizeof(*vq));
+       void *p;
+
+       /* First we need some pages for this virtqueue. */
+       pages = (vring_size(num_descs) + getpagesize() - 1) / getpagesize();
+       p = get_pages(pages);
+
+       /* 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. */
+       vring_init(&vq->vring, num_descs, p);
+
+       /* Add the configuration information to this device's descriptor. */
+       add_desc_field(dev, VIRTIO_CONFIG_F_VIRTQUEUE,
+                      sizeof(vq->config), &vq->config);
+
+       /* Add to tail of list, so dev->vq is first vq, dev->vq->next is
+        * second.  */
+       for (i = &dev->vq; *i; i = &(*i)->next);
+       *i = vq;
+
+       /* Link virtqueue back to device. */
+       vq->dev = dev;
+
+       /* Set up handler. */
+       vq->handle_output = handle_output;
+       if (!handle_output)
+               vq->vring.used->flags = VRING_USED_F_NO_NOTIFY;
+}
+
+/* This routine does all the creation and setup of a new device, including
+ * caling new_dev_desc() to allocate the descriptor and device memory. */
+static struct device *new_device(const char *name, u16 type, int fd,
+                                bool (*handle_input)(int, struct device *))
 {
        struct device *dev = malloc(sizeof(*dev));
 
@@ -1026,27 +1061,25 @@ static struct device *new_device(struct device_list *devices,
         * 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
         * is eth0, the first block device /dev/lgba, etc. */
-       *devices->lastdev = dev;
+       *devices.lastdev = dev;
        dev->next = NULL;
-       devices->lastdev = &dev->next;
+       devices.lastdev = &dev->next;
 
        /* Now we populate the fields one at a time. */
        dev->fd = fd;
        /* If we have an input handler for this file descriptor, then we add it
         * to the device_list's fdset and maxfd. */
        if (handle_input)
-               set_fd(dev->fd, devices);
-       dev->desc = new_dev_desc(devices->descs, type, features, num_pages);
-       dev->mem = (void *)(dev->desc->pfn * getpagesize());
+               add_device_fd(dev->fd);
+       dev->desc = new_dev_desc(type);
        dev->handle_input = handle_input;
-       dev->watch_key = (unsigned long)dev->mem + watch_off;
-       dev->handle_output = handle_output;
+       dev->name = name;
        return dev;
 }
 
 /* Our first setup routine is the console.  It's a fairly simple device, but
  * UNIX tty handling makes it uglier than it could be. */
-static void setup_console(struct device_list *devices)
+static void setup_console(void)
 {
        struct device *dev;
 
@@ -1062,127 +1095,38 @@ static void setup_console(struct device_list *devices)
                atexit(restore_term);
        }
 
-       /* We don't currently require any memory for the console, so we ask for
-        * 0 pages. */
-       dev = new_device(devices, LGUEST_DEVICE_T_CONSOLE, 0, 0,
-                        STDIN_FILENO, handle_console_input,
-                        LGUEST_CONSOLE_DMA_KEY, handle_console_output);
+       dev = new_device("console", VIRTIO_ID_CONSOLE,
+                        STDIN_FILENO, handle_console_input);
        /* We store the console state in dev->priv, and initialize it. */
        dev->priv = malloc(sizeof(struct console_abort));
        ((struct console_abort *)dev->priv)->count = 0;
-       verbose("device %p: console\n",
-               (void *)(dev->desc->pfn * getpagesize()));
-}
 
-/* Setting up a block file is also fairly straightforward. */
-static void setup_block_file(const char *filename, struct device_list *devices)
-{
-       int fd;
-       struct device *dev;
-       off64_t *device_len;
-       struct lguest_block_page *p;
-
-       /* We open with O_LARGEFILE because otherwise we get stuck at 2G.  We
-        * open with O_DIRECT because otherwise our benchmarks go much too
-        * fast. */
-       fd = open_or_die(filename, O_RDWR|O_LARGEFILE|O_DIRECT);
-
-       /* We want one page, and have no input handler (the block file never
-        * has anything interesting to say to us).  Our timing will be quite
-        * random, so it should be a reasonable randomness source. */
-       dev = new_device(devices, LGUEST_DEVICE_T_BLOCK, 1,
-                        LGUEST_DEVICE_F_RANDOMNESS,
-                        fd, NULL, 0, handle_block_output);
-
-       /* We store the device size in the private area */
-       device_len = dev->priv = malloc(sizeof(*device_len));
-       /* This is the safe way of establishing the size of our device: it
-        * might be a normal file or an actual block device like /dev/hdb. */
-       *device_len = lseek64(fd, 0, SEEK_END);
-
-       /* The device memory is a "struct lguest_block_page".  It's zeroed
-        * already, we just need to put in the device size.  Block devices
-        * think in sectors (ie. 512 byte chunks), so we translate here. */
-       p = dev->mem;
-       p->num_sectors = *device_len/512;
-       verbose("device %p: block %i sectors\n",
-               (void *)(dev->desc->pfn * getpagesize()), p->num_sectors);
+       /* The console needs two virtqueues: the input then the output.  When
+        * 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
+        * stdout.  */
+       add_virtqueue(dev, VIRTQUEUE_NUM, enable_fd);
+       add_virtqueue(dev, VIRTQUEUE_NUM, handle_console_output);
+
+       verbose("device %u: console\n", devices.device_num++);
 }
+/*:*/
 
-/*
- * Network Devices.
+/*M:010 Inter-guest networking is an interesting area.  Simplest is to have a
+ * --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.
  *
- * Setting up network devices is quite a pain, because we have three types.
- * First, we have the inter-Guest network.  This is a file which is mapped into
- * the address space of the Guests who are on the network.  Because it is a
- * shared mapping, the same page underlies all the devices, and they can send
- * DMA to each other.
+ * More sopisticated is to use one of the tools developed for project like UML
+ * to do networking.
  *
- * Remember from our network driver, the Guest is told what slot in the page it
- * is to use.  We use exclusive fnctl locks to reserve a slot.  If another
- * Guest is using a slot, the lock will fail and we try another.  Because fnctl
- * locks are cleaned up automatically when we die, this cleverly means that our
- * reservation on the slot will vanish if we crash. */
-static unsigned int find_slot(int netfd, const char *filename)
-{
-       struct flock fl;
-
-       fl.l_type = F_WRLCK;
-       fl.l_whence = SEEK_SET;
-       fl.l_len = 1;
-       /* Try a 1 byte lock in each possible position number */
-       for (fl.l_start = 0;
-            fl.l_start < getpagesize()/sizeof(struct lguest_net);
-            fl.l_start++) {
-               /* If we succeed, return the slot number. */
-               if (fcntl(netfd, F_SETLK, &fl) == 0)
-                       return fl.l_start;
-       }
-       errx(1, "No free slots in network file %s", filename);
-}
-
-/* This function sets up the network file */
-static void setup_net_file(const char *filename,
-                          struct device_list *devices)
-{
-       int netfd;
-       struct device *dev;
-
-       /* We don't use open_or_die() here: for friendliness we create the file
-        * if it doesn't already exist. */
-       netfd = open(filename, O_RDWR, 0);
-       if (netfd < 0) {
-               if (errno == ENOENT) {
-                       netfd = open(filename, O_RDWR|O_CREAT, 0600);
-                       if (netfd >= 0) {
-                               /* If we succeeded, initialize the file with a
-                                * blank page. */
-                               char page[getpagesize()];
-                               memset(page, 0, sizeof(page));
-                               write(netfd, page, sizeof(page));
-                       }
-               }
-               if (netfd < 0)
-                       err(1, "cannot open net file '%s'", filename);
-       }
-
-       /* We need 1 page, and the features indicate the slot to use and that
-        * no checksum is needed.  We never touch this device again; it's
-        * between the Guests on the network, so we don't register input or
-        * output handlers. */
-       dev = new_device(devices, LGUEST_DEVICE_T_NET, 1,
-                        find_slot(netfd, filename)|LGUEST_NET_F_NOCSUM,
-                        -1, NULL, 0, NULL);
-
-       /* Map the shared file. */
-       if (mmap(dev->mem, getpagesize(), PROT_READ|PROT_WRITE,
-                        MAP_FIXED|MAP_SHARED, netfd, 0) != dev->mem)
-                       err(1, "could not mmap '%s'", filename);
-       verbose("device %p: shared net %s, peer %i\n",
-               (void *)(dev->desc->pfn * getpagesize()), filename,
-               dev->desc->features & ~LGUEST_NET_F_NOCSUM);
-}
-/*:*/
+ * 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.
+ *
+ * Finally, we could implement a virtio network switch in the kernel. :*/
 
 static u32 str2ip(const char *ipaddr)
 {
@@ -1217,7 +1161,7 @@ static void add_to_bridge(int fd, const char *if_name, const char *br_name)
 
 /* This sets up the Host end of the network device with an IP address, brings
  * it up so packets will flow, the copies the MAC address into the hwaddr
- * pointer (in practice, the Host's slot in the network device's memory). */
+ * pointer. */
 static void configure_device(int fd, const char *devname, u32 ipaddr,
                             unsigned char hwaddr[6])
 {
@@ -1243,18 +1187,18 @@ static void configure_device(int fd, const char *devname, u32 ipaddr,
        memcpy(hwaddr, ifr.ifr_hwaddr.sa_data, 6);
 }
 
-/*L:195 The other kind of network is a Host<->Guest network.  This can either
- * use briding or 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 just shunt packets between the Guest and the tun
- * device. */
-static void setup_tun_net(const char *arg, struct device_list *devices)
+/*L:195 Our network is a Host<->Guest network.  This can either use bridging or
+ * 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
+ * just shunt packets between the Guest and the tun device. */
+static void setup_tun_net(const char *arg)
 {
        struct device *dev;
        struct ifreq ifr;
        int netfd, ipfd;
        u32 ip;
        const char *br_name = NULL;
+       u8 hwaddr[6];
 
        /* We open the /dev/net/tun device and tell it we want a tap device.  A
         * tap device is like a tun device, only somehow different.  To tell
@@ -1270,21 +1214,13 @@ static void setup_tun_net(const char *arg, struct device_list *devices)
         * device: trust us! */
        ioctl(netfd, TUNSETNOCSUM, 1);
 
-       /* We create the net device with 1 page, using the features field of
-        * the descriptor to tell the Guest it is in slot 1 (NET_PEERNUM), and
-        * that the device has fairly random timing.  We do *not* specify
-        * LGUEST_NET_F_NOCSUM: these packets can reach the real world.
-        *
-        * We will put our MAC address is slot 0 for the Guest to see, so
-        * it will send packets to us using the key "peer_offset(0)": */
-       dev = new_device(devices, LGUEST_DEVICE_T_NET, 1,
-                        NET_PEERNUM|LGUEST_DEVICE_F_RANDOMNESS, netfd,
-                        handle_tun_input, peer_offset(0), handle_tun_output);
+       /* First we create a new network device. */
+       dev = new_device("net", VIRTIO_ID_NET, netfd, handle_tun_input);
 
-       /* We keep a flag which says whether we've seen packets come out from
-        * this network device. */
-       dev->priv = malloc(sizeof(bool));
-       *(bool *)dev->priv = false;
+       /* Network devices need a receive and a send queue, just like
+        * console. */
+       add_virtqueue(dev, VIRTQUEUE_NUM, enable_fd);
+       add_virtqueue(dev, VIRTQUEUE_NUM, handle_net_output);
 
        /* 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! */
@@ -1300,44 +1236,251 @@ static void setup_tun_net(const char *arg, struct device_list *devices)
        } else /* It is an IP address to set up the device with */
                ip = str2ip(arg);
 
-       /* We are peer 0, ie. first slot, so we hand dev->mem to this routine
-        * to write the MAC address at the start of the device memory.  */
-       configure_device(ipfd, ifr.ifr_name, ip, dev->mem);
+       /* Set up the tun device, and get the mac address for the interface. */
+       configure_device(ipfd, ifr.ifr_name, ip, hwaddr);
 
-       /* Set "promisc" bit: we want every single packet if we're going to
-        * bridge to other machines (and otherwise it doesn't matter). */
-       *((u8 *)dev->mem) |= 0x1;
+       /* Tell Guest what MAC address to use. */
+       add_desc_field(dev, VIRTIO_CONFIG_NET_MAC_F, sizeof(hwaddr), hwaddr);
 
+       /* We don't seed the socket any more; setup is done. */
        close(ipfd);
 
-       verbose("device %p: tun net %u.%u.%u.%u\n",
-               (void *)(dev->desc->pfn * getpagesize()),
-               (u8)(ip>>24), (u8)(ip>>16), (u8)(ip>>8), (u8)ip);
+       verbose("device %u: tun net %u.%u.%u.%u\n",
+               devices.device_num++,
+               (u8)(ip>>24),(u8)(ip>>16),(u8)(ip>>8),(u8)ip);
        if (br_name)
                verbose("attached to bridge: %s\n", br_name);
 }
+
+
+/*
+ * Block device.
+ *
+ * Serving a block device is really easy: the Guest asks for a block number and
+ * we read or write that position in the file.
+ *
+ * Unfortunately, this is amazingly slow: the Guest waits until the read is
+ * finished before running anything else, even if it could be doing useful
+ * work.  We could use 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.
+ *
+ * So we farm the I/O out to thread, and communicate with it via a pipe. */
+
+/* This hangs off device->priv, with the data. */
+struct vblk_info
+{
+       /* The size of the file. */
+       off64_t len;
+
+       /* The file descriptor for the file. */
+       int fd;
+
+       /* IO thread listens on this file descriptor [0]. */
+       int workpipe[2];
+
+       /* IO thread writes to this file descriptor to mark it done, then
+        * Launcher triggers interrupt to Guest. */
+       int done_fd;
+};
+
+/* This is the core of the I/O thread.  It returns true if it did something. */
+static bool service_io(struct device *dev)
+{
+       struct vblk_info *vblk = dev->priv;
+       unsigned int head, out_num, in_num, wlen;
+       int ret;
+       struct virtio_blk_inhdr *in;
+       struct virtio_blk_outhdr *out;
+       struct iovec iov[dev->vq->vring.num];
+       off64_t off;
+
+       head = get_vq_desc(dev->vq, iov, &out_num, &in_num);
+       if (head == dev->vq->vring.num)
+               return false;
+
+       if (out_num == 0 || in_num == 0)
+               errx(1, "Bad virtblk cmd %u out=%u in=%u",
+                    head, out_num, in_num);
+
+       out = convert(&iov[0], struct virtio_blk_outhdr);
+       in = convert(&iov[out_num+in_num-1], struct virtio_blk_inhdr);
+       off = out->sector * 512;
+
+       /* This is how we implement barriers.  Pretty poor, no? */
+       if (out->type & VIRTIO_BLK_T_BARRIER)
+               fdatasync(vblk->fd);
+
+       if (out->type & VIRTIO_BLK_T_SCSI_CMD) {
+               fprintf(stderr, "Scsi commands unsupported\n");
+               in->status = VIRTIO_BLK_S_UNSUPP;
+               wlen = sizeof(in);
+       } else if (out->type & VIRTIO_BLK_T_OUT) {
+               /* Write */
+
+               /* Move to the right location in the block file.  This can fail
+                * if they try to write past end. */
+               if (lseek64(vblk->fd, off, SEEK_SET) != off)
+                       err(1, "Bad seek to sector %llu", out->sector);
+
+               ret = writev(vblk->fd, iov+1, out_num-1);
+               verbose("WRITE to sector %llu: %i\n", out->sector, ret);
+
+               /* Grr... Now we know how long the descriptor they sent was, we
+                * make sure they didn't try to write over the end of the block
+                * file (possibly extending it). */
+               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);
+               }
+               wlen = sizeof(in);
+               in->status = (ret >= 0 ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR);
+       } else {
+               /* Read */
+
+               /* Move to the right location in the block file.  This can fail
+                * if they try to read past end. */
+               if (lseek64(vblk->fd, off, SEEK_SET) != off)
+                       err(1, "Bad seek to sector %llu", out->sector);
+
+               ret = readv(vblk->fd, iov+1, in_num-1);
+               verbose("READ from sector %llu: %i\n", out->sector, ret);
+               if (ret >= 0) {
+                       wlen = sizeof(in) + ret;
+                       in->status = VIRTIO_BLK_S_OK;
+               } else {
+                       wlen = sizeof(in);
+                       in->status = VIRTIO_BLK_S_IOERR;
+               }
+       }
+
+       /* We can't trigger an IRQ, because we're not the Launcher.  It does
+        * that when we tell it we're done. */
+       add_used(dev->vq, head, wlen);
+       return true;
+}
+
+/* This is the thread which actually services the I/O. */
+static int io_thread(void *_dev)
+{
+       struct device *dev = _dev;
+       struct vblk_info *vblk = dev->priv;
+       char c;
+
+       /* Close other side of workpipe so we get 0 read when main dies. */
+       close(vblk->workpipe[1]);
+       /* Close the other side of the done_fd pipe. */
+       close(dev->fd);
+
+       /* When this read fails, it means Launcher died, so we follow. */
+       while (read(vblk->workpipe[0], &c, 1) == 1) {
+               /* We acknowledge each request immediately, to reduce latency,
+                * rather than waiting until we've done them all.  I haven't
+                * measured to see if it makes any difference. */
+               while (service_io(dev))
+                       write(vblk->done_fd, &c, 1);
+       }
+       return 0;
+}
+
+/* When the thread says some I/O is done, we interrupt the Guest. */
+static bool handle_io_finish(int fd, struct device *dev)
+{
+       char c;
+
+       /* If child died, presumably it printed message. */
+       if (read(dev->fd, &c, 1) != 1)
+               exit(1);
+
+       /* It did some work, so trigger the irq. */
+       trigger_irq(fd, dev->vq);
+       return true;
+}
+
+/* When the Guest submits some I/O, we wake the I/O thread. */
+static void handle_virtblk_output(int fd, struct virtqueue *vq)
+{
+       struct vblk_info *vblk = vq->dev->priv;
+       char c = 0;
+
+       /* Wake up I/O thread and tell it to go to work! */
+       if (write(vblk->workpipe[1], &c, 1) != 1)
+               /* Presumably it indicated why it died. */
+               exit(1);
+}
+
+/* This creates a virtual block device. */
+static void setup_block_file(const char *filename)
+{
+       int p[2];
+       struct device *dev;
+       struct vblk_info *vblk;
+       void *stack;
+       u64 cap;
+       unsigned int val;
+
+       /* This is the pipe the I/O thread will use to tell us I/O is done. */
+       pipe(p);
+
+       /* The device responds to return from I/O thread. */
+       dev = new_device("block", VIRTIO_ID_BLOCK, p[0], handle_io_finish);
+
+       /* The device has a virtqueue. */
+       add_virtqueue(dev, VIRTQUEUE_NUM, handle_virtblk_output);
+
+       /* 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);
+
+       /* Tell Guest how many sectors this device has. */
+       cap = cpu_to_le64(vblk->len / 512);
+       add_desc_field(dev, VIRTIO_CONFIG_BLK_F_CAPACITY, sizeof(cap), &cap);
+
+       /* Tell Guest not to put in too many descriptors at once: two are used
+        * for the in and out elements. */
+       val = cpu_to_le32(VIRTQUEUE_NUM - 2);
+       add_desc_field(dev, VIRTIO_CONFIG_BLK_F_SEG_MAX, sizeof(val), &val);
+
+       /* The I/O thread writes to this end of the pipe when done. */
+       vblk->done_fd = p[1];
+
+       /* This is how we tell the I/O thread about more work. */
+       pipe(vblk->workpipe);
+
+       /* Create stack for thread and run it */
+       stack = malloc(32768);
+       if (clone(io_thread, stack + 32768, CLONE_VM, dev) == -1)
+               err(1, "Creating clone");
+
+       /* We don't need to keep the I/O thread's end of the pipes open. */
+       close(vblk->done_fd);
+       close(vblk->workpipe[0]);
+
+       verbose("device %u: virtblock %llu sectors\n",
+               devices.device_num, cap);
+}
 /* That's the end of device setup. */
 
 /*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. */
-static void __attribute__((noreturn))
-run_guest(int lguest_fd, struct device_list *device_list)
+static void __attribute__((noreturn)) run_guest(int lguest_fd)
 {
        for (;;) {
-               u32 args[] = { LHREQ_BREAK, 0 };
-               unsigned long arr[2];
+               unsigned long args[] = { LHREQ_BREAK, 0 };
+               unsigned long notify_addr;
                int readval;
 
                /* We read from the /dev/lguest device to run the Guest. */
-               readval = read(lguest_fd, arr, sizeof(arr));
-
-               /* The read can only really return sizeof(arr) (the Guest did a
-                * SEND_DMA to us), or an error. */
+               readval = read(lguest_fd, &notify_addr, sizeof(notify_addr));
 
-               /* For a successful read, arr[0] is the address of the "struct
-                * lguest_dma", and arr[1] is the key the Guest sent to. */
-               if (readval == sizeof(arr)) {
-                       handle_output(lguest_fd, arr[0], arr[1], device_list);
+               /* One unsigned long means the Guest did HCALL_NOTIFY */
+               if (readval == sizeof(notify_addr)) {
+                       verbose("Notify on address %#lx\n", notify_addr);
+                       handle_output(lguest_fd, notify_addr);
                        continue;
                /* ENOENT means the Guest died.  Reading tells us why. */
                } else if (errno == ENOENT) {
@@ -1351,7 +1494,7 @@ run_guest(int lguest_fd, struct device_list *device_list)
 
                /* Service input, then unset the BREAK which releases
                 * the Waker. */
-               handle_input(lguest_fd, device_list);
+               handle_input(lguest_fd);
                if (write(lguest_fd, args, sizeof(args)) < 0)
                        err(1, "Resetting break");
        }
@@ -1365,7 +1508,6 @@ run_guest(int lguest_fd, struct device_list *device_list)
 
 static struct option opts[] = {
        { "verbose", 0, NULL, 'v' },
-       { "sharenet", 1, NULL, 's' },
        { "tunnet", 1, NULL, 't' },
        { "block", 1, NULL, 'b' },
        { "initrd", 1, NULL, 'i' },
@@ -1374,37 +1516,21 @@ static struct option opts[] = {
 static void usage(void)
 {
        errx(1, "Usage: lguest [--verbose] "
-            "[--sharenet=<filename>|--tunnet=(<ipaddr>|bridge:<bridgename>)\n"
+            "[--tunnet=(<ipaddr>|bridge:<bridgename>)\n"
             "|--block=<filename>|--initrd=<filename>]...\n"
             "<mem-in-mb> vmlinux [args...]");
 }
 
-/*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 like 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.
- *
- * The Launcher binary sits up high, usually starting at address 0xB8000000.
- * Everything below this is the "physical" memory for the Guest.  For example,
- * if the Guest were to write a "1" at physical address 0, we would see a "1"
- * in the Launcher at "(int *)0".  Guest physical == Launcher virtual.
- *
- * This can be tough to get your head around, but usually it just means that we
- * don't need to do any conversion when the Guest gives us it's "physical"
- * addresses.
- */
+/*L:105 The main routine is where the real work begins: */
 int main(int argc, char *argv[])
 {
-       /* Memory, top-level pagetable, code startpoint, PAGE_OFFSET and size
-        * of the (optional) initrd. */
-       unsigned long mem = 0, pgdir, start, page_offset, initrd_size = 0;
+       /* Memory, top-level pagetable, code startpoint and size of the
+        * (optional) initrd. */
+       unsigned long mem = 0, pgdir, start, initrd_size = 0;
        /* A temporary and the /dev/lguest file descriptor. */
        int i, c, lguest_fd;
-       /* The list of Guest devices, based on command line arguments. */
-       struct device_list device_list;
-       /* The boot information for the Guest: at guest-physical address 0. */
-       void *boot = (void *)0;
+       /* The boot information for the Guest. */
+       struct boot_params *boot;
        /* If they specify an initrd file to load. */
        const char *initrd_name = NULL;
 
@@ -1412,11 +1538,12 @@ int main(int argc, char *argv[])
         * device receive input from a file descriptor, we keep an fdset
         * (infds) and the maximum fd number (max_infd) with the head of the
         * list.  We also keep a pointer to the last device, for easy appending
-        * to the list. */
-       device_list.max_infd = -1;
-       device_list.dev = NULL;
-       device_list.lastdev = &device_list.dev;
-       FD_ZERO(&device_list.infds);
+        * to the list.  Finally, we keep the next interrupt number to hand out
+        * (1: remember that 0 is used by the timer). */
+       FD_ZERO(&devices.infds);
+       devices.max_infd = -1;
+       devices.lastdev = &devices.dev;
+       devices.next_irq = 1;
 
        /* We need to know how much memory so we can set up the device
         * descriptor and memory pages for the devices as we parse the command
@@ -1424,9 +1551,16 @@ int main(int argc, char *argv[])
         * of memory now. */
        for (i = 1; i < argc; i++) {
                if (argv[i][0] != '-') {
-                       mem = top = atoi(argv[i]) * 1024 * 1024;
-                       device_list.descs = map_zeroed_pages(top, 1);
-                       top += getpagesize();
+                       mem = atoi(argv[i]) * 1024 * 1024;
+                       /* We start by mapping anonymous pages over all of
+                        * guest-physical memory range.  This fills it with 0,
+                        * and ensures that the Guest won't be killed when it
+                        * tries to access it. */
+                       guest_base = map_zeroed_pages(mem / getpagesize()
+                                                     + DEVICE_PAGES);
+                       guest_limit = mem;
+                       guest_max = mem + DEVICE_PAGES*getpagesize();
+                       devices.descpage = get_pages(1);
                        break;
                }
        }
@@ -1437,14 +1571,11 @@ int main(int argc, char *argv[])
                case 'v':
                        verbose = true;
                        break;
-               case 's':
-                       setup_net_file(optarg, &device_list);
-                       break;
                case 't':
-                       setup_tun_net(optarg, &device_list);
+                       setup_tun_net(optarg);
                        break;
                case 'b':
-                       setup_block_file(optarg, &device_list);
+                       setup_block_file(optarg);
                        break;
                case 'i':
                        initrd_name = optarg;
@@ -1459,56 +1590,60 @@ int main(int argc, char *argv[])
        if (optind + 2 > argc)
                usage();
 
-       /* We always have a console device */
-       setup_console(&device_list);
+       verbose("Guest base is at %p\n", guest_base);
 
-       /* We start by mapping anonymous pages over all of guest-physical
-        * memory range.  This fills it with 0, and ensures that the Guest
-        * won't be killed when it tries to access it. */
-       map_zeroed_pages(0, mem / getpagesize());
+       /* We always have a console device */
+       setup_console();
 
        /* Now we load the kernel */
-       start = load_kernel(open_or_die(argv[optind+1], O_RDONLY),
-                           &page_offset);
+       start = load_kernel(open_or_die(argv[optind+1], O_RDONLY));
+
+       /* Boot information is stashed at physical address 0 */
+       boot = from_guest_phys(0);
 
        /* Map the initrd image if requested (at top of physical memory) */
        if (initrd_name) {
                initrd_size = load_initrd(initrd_name, mem);
                /* These are the location in the Linux boot header where the
                 * start and size of the initrd are expected to be found. */
-               *(unsigned long *)(boot+0x218) = mem - initrd_size;
-               *(unsigned long *)(boot+0x21c) = initrd_size;
+               boot->hdr.ramdisk_image = mem - initrd_size;
+               boot->hdr.ramdisk_size = initrd_size;
                /* The bootloader type 0xFF means "unknown"; that's OK. */
-               *(unsigned char *)(boot+0x210) = 0xFF;
+               boot->hdr.type_of_loader = 0xFF;
        }
 
        /* Set up the initial linear pagetables, starting below the initrd. */
-       pgdir = setup_pagetables(mem, initrd_size, page_offset);
+       pgdir = setup_pagetables(mem, initrd_size);
 
        /* The Linux boot header contains an "E820" memory map: ours is a
         * simple, single region. */
-       *(char*)(boot+E820NR) = 1;
-       *((struct e820entry *)(boot+E820MAP))
-               = ((struct e820entry) { 0, mem, E820_RAM });
+       boot->e820_entries = 1;
+       boot->e820_map[0] = ((struct e820entry) { 0, mem, E820_RAM });
        /* The boot header contains a command line pointer: we put the command
-        * line after the boot header (at address 4096) */
-       *(void **)(boot + 0x228) = boot + 4096;
-       concat(boot + 4096, argv+optind+2);
+        * line after the boot header. */
+       boot->hdr.cmd_line_ptr = to_guest_phys(boot + 1);
+       concat((char *)(boot + 1), argv+optind+2);
+
+       /* Boot protocol version: 2.07 supports the fields for lguest. */
+       boot->hdr.version = 0x207;
+
+       /* The hardware_subarch value of "1" tells the Guest it's an lguest. */
+       boot->hdr.hardware_subarch = 1;
 
-       /* The guest type value of "1" tells the Guest it's under lguest. */
-       *(int *)(boot + 0x23c) = 1;
+       /* Tell the entry path not to try to reload segment registers. */
+       boot->hdr.loadflags |= KEEP_SEGMENTS;
 
        /* We tell the kernel to initialize the Guest: this returns the open
         * /dev/lguest file descriptor. */
-       lguest_fd = tell_kernel(pgdir, start, page_offset);
+       lguest_fd = tell_kernel(pgdir, start);
 
        /* We fork off a child process, which wakes the Launcher whenever one
         * of the input file descriptors needs attention.  Otherwise we would
         * run the Guest until it tries to output something. */
-       waker_fd = setup_waker(lguest_fd, &device_list);
+       waker_fd = setup_waker(lguest_fd);
 
        /* Finally, run the Guest.  This doesn't return. */
-       run_guest(lguest_fd, &device_list);
+       run_guest(lguest_fd);
 }
 /*:*/
 
index 821617bd6c048351fcd84e7ad125fe95fbd539e4..7885ab2d5f53710d54676c1e8df6be8f224c36ca 100644 (file)
@@ -6,7 +6,7 @@ Lguest is designed to be a minimal hypervisor for the Linux kernel, for
 Linux developers and users to experiment with virtualization with the
 minimum of complexity.  Nonetheless, it should have sufficient
 features to make it useful for specific tasks, and, of course, you are
-encouraged to fork and enhance it.
+encouraged to fork and enhance it (see drivers/lguest/README).
 
 Features:
 
@@ -23,19 +23,30 @@ Developer features:
 
 Running Lguest:
 
-- Lguest runs the same kernel as guest and host.  You can configure
-  them differently, but usually it's easiest not to.
+- The easiest way to run lguest is to use same kernel as guest and host.
+  You can configure them differently, but usually it's easiest not to.
 
   You will need to configure your kernel with the following options:
 
-  CONFIG_HIGHMEM64G=n ("High Memory Support" "64GB")[1]
-  CONFIG_TUN=y/m ("Universal TUN/TAP device driver support")
-  CONFIG_EXPERIMENTAL=y ("Prompt for development and/or incomplete code/drivers")
-  CONFIG_PARAVIRT=y ("Paravirtualization support (EXPERIMENTAL)")
-  CONFIG_LGUEST=y/m ("Linux hypervisor example code")
-
-  and I recommend:
-  CONFIG_HZ=100 ("Timer frequency")[2]
+  "General setup":
+     "Prompt for development and/or incomplete code/drivers" = Y
+        (CONFIG_EXPERIMENTAL=y)
+
+  "Processor type and features":
+     "Paravirtualized guest support" = Y
+        "Lguest guest support" = Y
+     "High Memory Support" = off/4GB
+     "Alignment value to which kernel should be aligned" = 0x100000
+        (CONFIG_PARAVIRT=y, CONFIG_LGUEST_GUEST=y, CONFIG_HIGHMEM64G=n and
+         CONFIG_PHYSICAL_ALIGN=0x100000)
+
+  "Device Drivers":
+     "Network device support"
+        "Universal TUN/TAP device driver support" = M/Y
+           (CONFIG_TUN=m)
+     "Virtualization"
+        "Linux hypervisor example code" = M/Y
+           (CONFIG_LGUEST=m)
 
 - A tool called "lguest" is available in this directory: type "make"
   to build it.  If you didn't build your kernel in-tree, use "make
@@ -51,14 +62,17 @@ Running Lguest:
          dd if=/dev/zero of=rootfile bs=1M count=2048
          qemu -cdrom image.iso -hda rootfile -net user -net nic -boot d
 
+  Make sure that you install a getty on /dev/hvc0 if you want to log in on the
+  console!
+
 - "modprobe lg" if you built it as a module.
 
 - Run an lguest as root:
 
-      Documentation/lguest/lguest 64m vmlinux --tunnet=192.168.19.1 --block=rootfile root=/dev/lgba
+      Documentation/lguest/lguest 64 vmlinux --tunnet=192.168.19.1 --block=rootfile root=/dev/vda
 
    Explanation:
-    64m: the amount of memory to use.
+    64: the amount of memory to use, in MB.
 
     vmlinux: the kernel image found in the top of your build directory.  You
        can also use a standard bzImage.
@@ -66,10 +80,10 @@ Running Lguest:
     --tunnet=192.168.19.1: configures a "tap" device for networking with this
        IP address.
 
-    --block=rootfile: a file or block device which becomes /dev/lgba
+    --block=rootfile: a file or block device which becomes /dev/vda
        inside the guest.
 
-    root=/dev/lgba: this (and anything else on the command line) are
+    root=/dev/vda: this (and anything else on the command line) are
        kernel boot parameters.
 
 - Configuring networking.  I usually have the host masquerade, using
@@ -99,31 +113,7 @@ Running Lguest:
   "--sharenet=<filename>": any two guests using the same file are on
   the same network.  This file is created if it does not exist.
 
-Lguest I/O model:
-
-Lguest uses a simplified DMA model plus shared memory for I/O.  Guests
-can communicate with each other if they share underlying memory
-(usually by the lguest program mmaping the same file), but they can
-use any non-shared memory to communicate with the lguest process.
-
-Guests can register DMA buffers at any key (must be a valid physical
-address) using the LHCALL_BIND_DMA(key, dmabufs, num<<8|irq)
-hypercall.  "dmabufs" is the physical address of an array of "num"
-"struct lguest_dma": each contains a used_len, and an array of
-physical addresses and lengths.  When a transfer occurs, the
-"used_len" field of one of the buffers which has used_len 0 will be
-set to the length transferred and the irq will fire.
+There is a helpful mailing list at http://ozlabs.org/mailman/listinfo/lguest
 
-Using an irq value of 0 unbinds the dma buffers.
-
-To send DMA, the LHCALL_SEND_DMA(key, dma_physaddr) hypercall is used,
-and the bytes used is written to the used_len field.  This can be 0 if
-noone else has bound a DMA buffer to that key or some other error.
-DMA buffers bound by the same guest are ignored.
-
-Cheers!
+Good luck!
 Rusty Russell rusty@rustcorp.com.au.
-
-[1] These are on various places on the TODO list, waiting for you to
-    get annoyed enough at the limitation to fix it.
-[2] Lguest is not yet tickless when idle.  See [1].
index 5fbcc22c98e944c1ec628bca656ec1eae73cec5e..168117bd6ee8b8d7eafbb72c626a2434556f4cc9 100644 (file)
@@ -2,7 +2,8 @@
 Memory Hotplug
 ==============
 
-Last Updated: Jul 28 2007
+Created:                                       Jul 28 2007
+Add description of notifier of memory hotplug  Oct 11 2007
 
 This document is about memory hotplug including how-to-use and current status.
 Because Memory Hotplug is still under development, contents of this text will
@@ -24,7 +25,8 @@ be changed often.
   6.1 Memory offline and ZONE_MOVABLE
   6.2. How to offline memory
 7. Physical memory remove
-8. Future Work List
+8. Memory hotplug event notifier
+9. Future Work List
 
 Note(1): x86_64's has special implementation for memory hotplug.
          This text does not describe it.
@@ -307,8 +309,58 @@ Need more implementation yet....
  - Notification completion of remove works by OS to firmware.
  - Guard from remove if not yet.
 
+--------------------------------
+8. Memory hotplug event notifier
+--------------------------------
+Memory hotplug has event notifer. There are 6 types of notification.
+
+MEMORY_GOING_ONLINE
+  Generated before new memory becomes available in order to be able to
+  prepare subsystems to handle memory. The page allocator is still unable
+  to allocate from the new memory.
+
+MEMORY_CANCEL_ONLINE
+  Generated if MEMORY_GOING_ONLINE fails.
+
+MEMORY_ONLINE
+  Generated when memory has succesfully brought online. The callback may
+  allocate pages from the new memory.
+
+MEMORY_GOING_OFFLINE
+  Generated to begin the process of offlining memory. Allocations are no
+  longer possible from the memory but some of the memory to be offlined
+  is still in use. The callback can be used to free memory known to a
+  subsystem from the indicated memory section.
+
+MEMORY_CANCEL_OFFLINE
+  Generated if MEMORY_GOING_OFFLINE fails. Memory is available again from
+  the section that we attempted to offline.
+
+MEMORY_OFFLINE
+  Generated after offlining memory is complete.
+
+A callback routine can be registered by
+  hotplug_memory_notifier(callback_func, priority)
+
+The second argument of callback function (action) is event types of above.
+The third argument is passed by pointer of struct memory_notify.
+
+struct memory_notify {
+       unsigned long start_pfn;
+       unsigned long nr_pages;
+       int status_cahnge_nid;
+}
+
+start_pfn is start_pfn of online/offline memory.
+nr_pages is # of pages of online/offline memory.
+status_change_nid is set node id when N_HIGH_MEMORY of nodemask is (will be)
+set/clear. It means a new(memoryless) node gets new memory by online and a
+node loses all memory. If this is -1, then nodemask status is not changed.
+If status_changed_nid >= 0, callback should create/discard structures for the
+node if necessary.
+
 --------------
-8. Future Work
+9. Future Work
 --------------
   - allowing memory hot-add to ZONE_MOVABLE. maybe we need some switch like
     sysctl or new control file.
index 5f7d536cb0c60351eae676c1fe5dd81407ae55ef..5e03610e186f986c5cc3a21a5e4f9bbac3ee4332 100644 (file)
@@ -185,7 +185,7 @@ bestcomm@<addr>     dma-controller          mpc5200-bestcomm 5200 pic also requires
 Recommended soc5200 child nodes; populate as needed for your board
 name           device_type     compatible        Description
 ----           -----------     ----------        -----------
-gpt@<addr>     gpt             mpc5200-gpt       General purpose timers
+gpt@<addr>     gpt             fsl,mpc5200-gpt   General purpose timers
 rtc@<addr>     rtc             mpc5200-rtc       Real time clock
 mscan@<addr>   mscan           mpc5200-mscan     CAN bus controller
 pci@<addr>     pci             mpc5200-pci       PCI bridge
@@ -213,7 +213,7 @@ cell-index  int             When multiple devices are present, is the
 5) General Purpose Timer nodes (child of soc5200 node)
 On the mpc5200 and 5200b, GPT0 has a watchdog timer function.  If the board
 design supports the internal wdt, then the device node for GPT0 should
-include the empty property 'has-wdt'.
+include the empty property 'fsl,has-wdt'.
 
 6) PSC nodes (child of soc5200 node)
 PSC nodes can define the optional 'port-number' property to force assignment
index 4ed41394e492423220afc320856913f4cc45aba1..40245af2d0e3611df6b0f18365910ab1d7798d9e 100644 (file)
@@ -1963,11 +1963,6 @@ M:       adaplas@gmail.com
 L:     linux-fbdev-devel@lists.sourceforge.net (subscribers-only)
 S:     Maintained
 
-INTEL APIC/IOAPIC, LOWLEVEL X86 SMP SUPPORT
-P:     Ingo Molnar
-M:     mingo@redhat.com
-S:     Maintained
-
 INTEL I8XX RANDOM NUMBER GENERATOR SUPPORT
 P:     Jeff Garzik
 M:     jgarzik@pobox.com
@@ -2343,6 +2338,8 @@ L:        linuxppc-dev@ozlabs.org
 S:     Maintained
 
 LINUX FOR POWERPC EMBEDDED PPC8XX
+P:     Vitaly Bordug
+M:     vitb@kernel.crashing.org
 P:     Marcelo Tosatti
 M:     marcelo@kvack.org
 W:     http://www.penguinppc.org/
@@ -4269,9 +4266,15 @@ M:       jacmet@sunsite.dk
 L:     linux-serial@vger.kernel.org
 S:     Maintained
 
-X86 3-LEVEL PAGING (PAE) SUPPORT
+X86 ARCHITECTURE (32-BIT AND 64-BIT)
+P:     Thomas Gleixner
+M:     tglx@linutronix.de
 P:     Ingo Molnar
 M:     mingo@redhat.com
+P:     H. Peter Anvin
+M:     hpa@zytor.com
+L:     linux-kernel@vger.kernel.org
+T:     git://git.kernel.org/pub/scm/linux/kernel/git/x86/linux-2.6-x86.git
 S:     Maintained
 
 YAM DRIVER FOR AX.25
index f9c264e243a2a01e78cd85d209b8cdae8102a6ab..264f37b8b263b9968936a2d88942112165086753 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1505,15 +1505,16 @@ quiet_cmd_rmfiles = $(if $(wildcard $(rm-files)),CLEAN   $(wildcard $(rm-files))
 # and we build for the host arch
 quiet_cmd_depmod = DEPMOD  $(KERNELRELEASE)
       cmd_depmod = \
-       if [ -r System.map -a -x $(DEPMOD) -a "$(SUBARCH)" == "$(ARCH)" ]; then \
+       if [ -r System.map -a -x $(DEPMOD) ]; then                              \
                $(DEPMOD) -ae -F System.map                                     \
                $(if $(strip $(INSTALL_MOD_PATH)), -b $(INSTALL_MOD_PATH) -r)   \
                $(KERNELRELEASE);                                               \
        fi
 
 # Create temporary dir for module support files
-cmd_crmodverdir = $(Q)mkdir -p $(MODVERDIR); rm -f $(MODVERDIR)/*
-
+# clean it up only when building all modules
+cmd_crmodverdir = $(Q)mkdir -p $(MODVERDIR) \
+                  $(if $(KBUILD_MODULES),; rm -f $(MODVERDIR)/*)
 
 a_flags = -Wp,-MD,$(depfile) $(KBUILD_AFLAGS) $(AFLAGS_KERNEL) \
          $(NOSTDINC_FLAGS) $(KBUILD_CPPFLAGS) \
index e1c470752ebc0db7e146c2d544da50496f3076af..2d00a08d3f0811d0f7b819475d6f858828d88496 100644 (file)
@@ -7,6 +7,7 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/bootmem.h>
+#include <linux/scatterlist.h>
 #include <linux/log2.h>
 
 #include <asm/io.h>
@@ -465,7 +466,7 @@ EXPORT_SYMBOL(pci_free_consistent);
    Write dma_length of each leader with the combined lengths of
    the mergable followers.  */
 
-#define SG_ENT_VIRT_ADDRESS(SG) (page_address((SG)->page) + (SG)->offset)
+#define SG_ENT_VIRT_ADDRESS(SG) (sg_virt((SG)))
 #define SG_ENT_PHYS_ADDRESS(SG) __pa(SG_ENT_VIRT_ADDRESS(SG))
 
 static void
index 44ab0dad40357dc83a5bafd305b93589cd71aa67..52fc6a883281120f7c80e2d332247971658b1ffa 100644 (file)
@@ -29,6 +29,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
 #include <linux/list.h>
+#include <linux/scatterlist.h>
 
 #include <asm/cacheflush.h>
 
@@ -442,7 +443,7 @@ dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
        BUG_ON(dir == DMA_NONE);
 
        for (i = 0; i < nents; i++, sg++) {
-               struct page *page = sg->page;
+               struct page *page = sg_page(sg);
                unsigned int offset = sg->offset;
                unsigned int length = sg->length;
                void *ptr = page_address(page) + offset;
index 6b9e466104ad04d8c5be831774a937931eb298e3..5be0d13f4b03c53d8d843d9a698b885361d98bc0 100644 (file)
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/spi/spi.h>
+#include <linux/spi/at73c213.h>
 
 #include <video/atmel_lcdc.h>
 
@@ -48,8 +49,27 @@ static struct eth_platform_data __initdata eth_data[2] = {
        },
 };
 
+#ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM
+#ifndef CONFIG_BOARD_ATSTK1002_SW3_CUSTOM
+static struct at73c213_board_info at73c213_data = {
+       .ssc_id         = 0,
+       .shortname      = "AVR32 STK1000 external DAC",
+};
+#endif
+#endif
+
 #ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM
 static struct spi_board_info spi0_board_info[] __initdata = {
+#ifndef CONFIG_BOARD_ATSTK1002_SW3_CUSTOM
+       {
+               /* AT73C213 */
+               .modalias       = "at73c213",
+               .max_speed_hz   = 200000,
+               .chip_select    = 0,
+               .mode           = SPI_MODE_1,
+               .platform_data  = &at73c213_data,
+       },
+#endif
        {
                /* QVGA display */
                .modalias       = "ltv350qv",
@@ -180,6 +200,38 @@ static void setup_j2_leds(void)
 }
 #endif
 
+#ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM
+#ifndef CONFIG_BOARD_ATSTK1002_SW3_CUSTOM
+static void __init at73c213_set_clk(struct at73c213_board_info *info)
+{
+       struct clk *gclk;
+       struct clk *pll;
+
+       gclk = clk_get(NULL, "gclk0");
+       if (IS_ERR(gclk))
+               goto err_gclk;
+       pll = clk_get(NULL, "pll0");
+       if (IS_ERR(pll))
+               goto err_pll;
+
+       if (clk_set_parent(gclk, pll)) {
+               pr_debug("STK1000: failed to set pll0 as parent for DAC clock\n");
+               goto err_set_clk;
+       }
+
+       at32_select_periph(GPIO_PIN_PA(30), GPIO_PERIPH_A, 0);
+       info->dac_clk = gclk;
+
+err_set_clk:
+       clk_put(pll);
+err_pll:
+       clk_put(gclk);
+err_gclk:
+       return;
+}
+#endif
+#endif
+
 void __init setup_board(void)
 {
 #ifdef CONFIG_BOARD_ATSTK1002_SW2_CUSTOM
@@ -248,6 +300,12 @@ static int __init atstk1002_init(void)
 
        setup_j2_leds();
 
+#ifndef CONFIG_BOARD_ATSTK1002_SW3_CUSTOM
+#ifndef CONFIG_BOARD_ATSTK1002_SW1_CUSTOM
+       at73c213_set_clk(&at73c213_data);
+#endif
+#endif
+
        return 0;
 }
 postcore_initcall(atstk1002_init);
index f6d154ca4d24ebdd91c2fa1fef37d15a25184777..a9d9ec081e3d7b8c729dfff3100ca3f2bc5f2b45 100644 (file)
@@ -556,6 +556,17 @@ static struct clk pico_clk = {
        .users          = 1,
 };
 
+static struct resource dmaca0_resource[] = {
+       {
+               .start  = 0xff200000,
+               .end    = 0xff20ffff,
+               .flags  = IORESOURCE_MEM,
+       },
+       IRQ(2),
+};
+DEFINE_DEV(dmaca, 0);
+DEV_CLK(hclk, dmaca0, hsb, 10);
+
 /* --------------------------------------------------------------------
  * HMATRIX
  * -------------------------------------------------------------------- */
@@ -655,6 +666,7 @@ void __init at32_add_system_devices(void)
        platform_device_register(&at32_eic0_device);
        platform_device_register(&smc0_device);
        platform_device_register(&pdc_device);
+       platform_device_register(&dmaca0_device);
 
        platform_device_register(&at32_systc0_device);
 
@@ -959,6 +971,96 @@ at32_add_device_spi(unsigned int id, struct spi_board_info *b, unsigned int n)
        return pdev;
 }
 
+/* --------------------------------------------------------------------
+ *  TWI
+ * -------------------------------------------------------------------- */
+static struct resource atmel_twi0_resource[] __initdata = {
+       PBMEM(0xffe00800),
+       IRQ(5),
+};
+static struct clk atmel_twi0_pclk = {
+       .name           = "twi_pclk",
+       .parent         = &pba_clk,
+       .mode           = pba_clk_mode,
+       .get_rate       = pba_clk_get_rate,
+       .index          = 2,
+};
+
+struct platform_device *__init at32_add_device_twi(unsigned int id)
+{
+       struct platform_device *pdev;
+
+       if (id != 0)
+               return NULL;
+
+       pdev = platform_device_alloc("atmel_twi", id);
+       if (!pdev)
+               return NULL;
+
+       if (platform_device_add_resources(pdev, atmel_twi0_resource,
+                               ARRAY_SIZE(atmel_twi0_resource)))
+               goto err_add_resources;
+
+       select_peripheral(PA(6),  PERIPH_A, 0); /* SDA  */
+       select_peripheral(PA(7),  PERIPH_A, 0); /* SDL  */
+
+       atmel_twi0_pclk.dev = &pdev->dev;
+
+       platform_device_add(pdev);
+       return pdev;
+
+err_add_resources:
+       platform_device_put(pdev);
+       return NULL;
+}
+
+/* --------------------------------------------------------------------
+ * MMC
+ * -------------------------------------------------------------------- */
+static struct resource atmel_mci0_resource[] __initdata = {
+       PBMEM(0xfff02400),
+       IRQ(28),
+};
+static struct clk atmel_mci0_pclk = {
+       .name           = "mci_clk",
+       .parent         = &pbb_clk,
+       .mode           = pbb_clk_mode,
+       .get_rate       = pbb_clk_get_rate,
+       .index          = 9,
+};
+
+struct platform_device *__init at32_add_device_mci(unsigned int id)
+{
+       struct platform_device *pdev;
+
+       if (id != 0)
+               return NULL;
+
+       pdev = platform_device_alloc("atmel_mci", id);
+       if (!pdev)
+               return NULL;
+
+       if (platform_device_add_resources(pdev, atmel_mci0_resource,
+                               ARRAY_SIZE(atmel_mci0_resource)))
+               goto err_add_resources;
+
+       select_peripheral(PA(10), PERIPH_A, 0); /* CLK   */
+       select_peripheral(PA(11), PERIPH_A, 0); /* CMD   */
+       select_peripheral(PA(12), PERIPH_A, 0); /* DATA0 */
+       select_peripheral(PA(13), PERIPH_A, 0); /* DATA1 */
+       select_peripheral(PA(14), PERIPH_A, 0); /* DATA2 */
+       select_peripheral(PA(15), PERIPH_A, 0); /* DATA3 */
+
+       atmel_mci0_pclk.dev = &pdev->dev;
+
+       platform_device_add(pdev);
+       return pdev;
+
+err_add_resources:
+       platform_device_put(pdev);
+       return NULL;
+}
+
 /* --------------------------------------------------------------------
  *  LCDC
  * -------------------------------------------------------------------- */
@@ -1227,6 +1329,241 @@ out_free_pdev:
        return NULL;
 }
 
+/* --------------------------------------------------------------------
+ * IDE / CompactFlash
+ * -------------------------------------------------------------------- */
+static struct resource at32_smc_cs4_resource[] __initdata = {
+       {
+               .start  = 0x04000000,
+               .end    = 0x07ffffff,
+               .flags  = IORESOURCE_MEM,
+       },
+       IRQ(~0UL), /* Magic IRQ will be overridden */
+};
+static struct resource at32_smc_cs5_resource[] __initdata = {
+       {
+               .start  = 0x20000000,
+               .end    = 0x23ffffff,
+               .flags  = IORESOURCE_MEM,
+       },
+       IRQ(~0UL), /* Magic IRQ will be overridden */
+};
+
+static int __init at32_init_ide_or_cf(struct platform_device *pdev,
+               unsigned int cs, unsigned int extint)
+{
+       static unsigned int extint_pin_map[4] __initdata = {
+               GPIO_PIN_PB(25),
+               GPIO_PIN_PB(26),
+               GPIO_PIN_PB(27),
+               GPIO_PIN_PB(28),
+       };
+       static bool common_pins_initialized __initdata = false;
+       unsigned int extint_pin;
+       int ret;
+
+       if (extint >= ARRAY_SIZE(extint_pin_map))
+               return -EINVAL;
+       extint_pin = extint_pin_map[extint];
+
+       switch (cs) {
+       case 4:
+               ret = platform_device_add_resources(pdev,
+                               at32_smc_cs4_resource,
+                               ARRAY_SIZE(at32_smc_cs4_resource));
+               if (ret)
+                       return ret;
+
+               select_peripheral(PE(21), PERIPH_A, 0); /* NCS4   -> OE_N  */
+               set_ebi_sfr_bits(HMATRIX_BIT(CS4A));
+               break;
+       case 5:
+               ret = platform_device_add_resources(pdev,
+                               at32_smc_cs5_resource,
+                               ARRAY_SIZE(at32_smc_cs5_resource));
+               if (ret)
+                       return ret;
+
+               select_peripheral(PE(22), PERIPH_A, 0); /* NCS5   -> OE_N  */
+               set_ebi_sfr_bits(HMATRIX_BIT(CS5A));
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       if (!common_pins_initialized) {
+               select_peripheral(PE(19), PERIPH_A, 0); /* CFCE1  -> CS0_N */
+               select_peripheral(PE(20), PERIPH_A, 0); /* CFCE2  -> CS1_N */
+               select_peripheral(PE(23), PERIPH_A, 0); /* CFRNW  -> DIR   */
+               select_peripheral(PE(24), PERIPH_A, 0); /* NWAIT  <- IORDY */
+               common_pins_initialized = true;
+       }
+
+       at32_select_periph(extint_pin, GPIO_PERIPH_A, AT32_GPIOF_DEGLITCH);
+
+       pdev->resource[1].start = EIM_IRQ_BASE + extint;
+       pdev->resource[1].end = pdev->resource[1].start;
+
+       return 0;
+}
+
+struct platform_device *__init
+at32_add_device_ide(unsigned int id, unsigned int extint,
+                   struct ide_platform_data *data)
+{
+       struct platform_device *pdev;
+
+       pdev = platform_device_alloc("at32_ide", id);
+       if (!pdev)
+               goto fail;
+
+       if (platform_device_add_data(pdev, data,
+                               sizeof(struct ide_platform_data)))
+               goto fail;
+
+       if (at32_init_ide_or_cf(pdev, data->cs, extint))
+               goto fail;
+
+       platform_device_add(pdev);
+       return pdev;
+
+fail:
+       platform_device_put(pdev);
+       return NULL;
+}
+
+struct platform_device *__init
+at32_add_device_cf(unsigned int id, unsigned int extint,
+                   struct cf_platform_data *data)
+{
+       struct platform_device *pdev;
+
+       pdev = platform_device_alloc("at32_cf", id);
+       if (!pdev)
+               goto fail;
+
+       if (platform_device_add_data(pdev, data,
+                               sizeof(struct cf_platform_data)))
+               goto fail;
+
+       if (at32_init_ide_or_cf(pdev, data->cs, extint))
+               goto fail;
+
+       if (data->detect_pin != GPIO_PIN_NONE)
+               at32_select_gpio(data->detect_pin, AT32_GPIOF_DEGLITCH);
+       if (data->reset_pin != GPIO_PIN_NONE)
+               at32_select_gpio(data->reset_pin, 0);
+       if (data->vcc_pin != GPIO_PIN_NONE)
+               at32_select_gpio(data->vcc_pin, 0);
+       /* READY is used as extint, so we can't select it as gpio */
+
+       platform_device_add(pdev);
+       return pdev;
+
+fail:
+       platform_device_put(pdev);
+       return NULL;
+}
+
+/* --------------------------------------------------------------------
+ * AC97C
+ * -------------------------------------------------------------------- */
+static struct resource atmel_ac97c0_resource[] __initdata = {
+       PBMEM(0xfff02800),
+       IRQ(29),
+};
+static struct clk atmel_ac97c0_pclk = {
+       .name           = "pclk",
+       .parent         = &pbb_clk,
+       .mode           = pbb_clk_mode,
+       .get_rate       = pbb_clk_get_rate,
+       .index          = 10,
+};
+
+struct platform_device *__init at32_add_device_ac97c(unsigned int id)
+{
+       struct platform_device *pdev;
+
+       if (id != 0)
+               return NULL;
+
+       pdev = platform_device_alloc("atmel_ac97c", id);
+       if (!pdev)
+               return NULL;
+
+       if (platform_device_add_resources(pdev, atmel_ac97c0_resource,
+                               ARRAY_SIZE(atmel_ac97c0_resource)))
+               goto err_add_resources;
+
+  &n