Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6
Linus Torvalds [Mon, 30 Jul 2007 00:22:03 +0000 (17:22 -0700)]
* master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6: (28 commits)
  [SCSI] mpt fusion: Changes in mptctl.c for logging support
  [SCSI] mpt fusion: Changes in mptfc.c mptlan.c mptsas.c and mptspi.c for logging support
  [SCSI] mpt fusion: Changes in mptscsih.c for logging support
  [SCSI] mpt fusion: Changes in mptbase.c for logging support
  [SCSI] mpt fusion: logging support in Kconfig, Makefile, mptbase.h and addition of mptdebug.h
  [SCSI] libsas: Fix potential NULL dereference in sas_smp_get_phy_events()
  [SCSI] bsg: Fix build for CONFIG_BLOCK=n
  [SCSI] aacraid: fix Sunrise Lake reset handling
  [SCSI] aacraid: add SCSI SYNCHONIZE_CACHE range checking
  [SCSI] add easyRAID to the no report luns blacklist
  [SCSI] advansys: lindent and other large, uninteresting changes
  [SCSI] aic79xx, aic7xxx: Fix incorrect width setting
  [SCSI] qla2xxx: fix to honor ignored parameters in sysfs attributes
  [SCSI] aacraid: draw line in sand, sundry cleanup and version update
  [SCSI] iscsi_tcp: Turn off bounce buffers
  [SCSI] libiscsi: fix cmd seqeunce number checking
  [SCSI] iscsi_tcp, ib_iser Enable module refcounting for iscsi host template
  [SCSI] libiscsi: make sure session is not blocked when removing host
  [SCSI] libsas: Remove PCI dependencies
  [SCSI] simscsi: convert to use the data buffer accessors
  ...

674 files changed:
CREDITS
Documentation/DocBook/kernel-api.tmpl
Documentation/block/barrier.txt
Documentation/block/biodoc.txt
Documentation/block/request.txt
Documentation/feature-removal-schedule.txt
Documentation/gpio.txt
Documentation/iostats.txt
Documentation/kernel-parameters.txt
Documentation/lguest/Makefile
Documentation/lguest/extract [new file with mode: 0644]
Documentation/lguest/lguest.c
Documentation/sched-stats.txt
MAINTAINERS
Makefile
arch/alpha/kernel/head.S
arch/alpha/kernel/pci.c
arch/alpha/kernel/pci_iommu.c
arch/alpha/kernel/smp.c
arch/alpha/kernel/vmlinux.lds.S
arch/arm/Kconfig
arch/arm/kernel/setup.c
arch/arm/kernel/smp.c
arch/arm/kernel/traps.c
arch/arm/mach-sa1100/jornada720.c
arch/arm/mach-sa1100/jornada720_ssp.c
arch/arm/plat-omap/mailbox.c
arch/blackfin/Makefile
arch/blackfin/kernel/dma-mapping.c
arch/blackfin/kernel/setup.c
arch/blackfin/kernel/traps.c
arch/blackfin/kernel/vmlinux.lds.S
arch/blackfin/mach-bf561/head.S
arch/blackfin/mach-common/cacheinit.S
arch/blackfin/mach-common/ints-priority-dc.c
arch/blackfin/mach-common/ints-priority-sc.c
arch/frv/kernel/sys_frv.c
arch/i386/Kconfig.debug
arch/i386/boot/apm.c
arch/i386/boot/main.c
arch/i386/kernel/alternative.c
arch/i386/kernel/cpu/cpufreq/Kconfig
arch/i386/kernel/e820.c
arch/i386/kernel/microcode.c
arch/i386/kernel/sys_i386.c
arch/i386/kernel/sysenter.c
arch/i386/mm/init.c
arch/i386/power/Makefile
arch/ia64/Kconfig
arch/ia64/hp/common/sba_iommu.c
arch/ia64/hp/sim/simscsi.c
arch/ia64/ia32/ia32_support.c
arch/ia64/ia32/ia32priv.h
arch/ia64/ia32/sys_ia32.c
arch/ia64/kernel/acpi.c
arch/ia64/kernel/cyclone.c
arch/ia64/kernel/head.S
arch/ia64/kernel/init_task.c
arch/ia64/kernel/irq_ia64.c
arch/ia64/kernel/machvec.c
arch/ia64/kernel/process.c
arch/ia64/kernel/setup.c
arch/ia64/kernel/smp.c
arch/ia64/kernel/smpboot.c
arch/ia64/kernel/time.c
arch/ia64/kernel/vmlinux.lds.S
arch/ia64/pci/pci.c
arch/m32r/kernel/setup_mappi.c
arch/m68k/kernel/process.c
arch/m68k/kernel/sys_m68k.c
arch/m68knommu/Kconfig
arch/m68knommu/Makefile
arch/m68knommu/kernel/dma.c
arch/m68knommu/kernel/setup.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/m68knommu/platform/68328/timers.c
arch/m68knommu/platform/68360/config.c
arch/m68knommu/platform/68VZ328/config.c
arch/mips/Makefile
arch/mips/arc/console.c [deleted file]
arch/mips/jazz/io.c [deleted file]
arch/mips/jazz/reset.c
arch/mips/jazz/setup.c
arch/mips/jmr3927/rbhma3100/setup.c
arch/mips/kernel/gdb-stub.c
arch/mips/kernel/head.S
arch/mips/kernel/linux32.c
arch/mips/kernel/rtlx.c
arch/mips/kernel/smp.c
arch/mips/kernel/syscall.c
arch/mips/kernel/vpe.c
arch/mips/mm/c-sb1.c
arch/mips/mm/init.c
arch/mips/sni/sniprom.c
arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c
arch/parisc/hpux/fs.c
arch/parisc/kernel/init_task.c
arch/parisc/kernel/process.c
arch/parisc/kernel/smp.c
arch/powerpc/Kconfig
arch/powerpc/Kconfig.debug
arch/powerpc/boot/dts/kuroboxHD.dts
arch/powerpc/boot/dts/kuroboxHG.dts
arch/powerpc/boot/dts/mpc7448hpc2.dts
arch/powerpc/boot/dts/mpc8313erdb.dts
arch/powerpc/boot/dts/mpc832x_mds.dts
arch/powerpc/boot/dts/mpc832x_rdb.dts
arch/powerpc/boot/dts/mpc8349emitx.dts
arch/powerpc/boot/dts/mpc8349emitxgp.dts
arch/powerpc/boot/dts/mpc834x_mds.dts
arch/powerpc/boot/dts/mpc836x_mds.dts
arch/powerpc/boot/dts/mpc8540ads.dts
arch/powerpc/boot/dts/mpc8541cds.dts
arch/powerpc/boot/dts/mpc8544ds.dts
arch/powerpc/boot/dts/mpc8548cds.dts
arch/powerpc/boot/dts/mpc8555cds.dts
arch/powerpc/boot/dts/mpc8560ads.dts
arch/powerpc/boot/dts/mpc8568mds.dts
arch/powerpc/boot/dts/mpc8641_hpcn.dts
arch/powerpc/configs/lite5200_defconfig
arch/powerpc/configs/mpc8544_ds_defconfig
arch/powerpc/configs/mpc8568mds_defconfig
arch/powerpc/configs/pmac32_defconfig
arch/powerpc/kernel/Makefile
arch/powerpc/kernel/head_64.S
arch/powerpc/kernel/iomap.c
arch/powerpc/kernel/irq.c
arch/powerpc/kernel/pci-common.c
arch/powerpc/kernel/pci_32.c
arch/powerpc/kernel/process.c
arch/powerpc/kernel/prom_parse.c
arch/powerpc/kernel/setup-common.c
arch/powerpc/kernel/syscalls.c
arch/powerpc/kernel/udbg.c
arch/powerpc/lib/rheap.c
arch/powerpc/mm/lmb.c
arch/powerpc/oprofile/cell/spu_task_sync.c
arch/powerpc/platforms/82xx/mpc82xx_ads.c
arch/powerpc/platforms/83xx/pci.c
arch/powerpc/platforms/85xx/Kconfig
arch/powerpc/platforms/85xx/Makefile
arch/powerpc/platforms/85xx/mpc8544_ds.c
arch/powerpc/platforms/85xx/mpc85xx.h
arch/powerpc/platforms/85xx/mpc85xx_ads.c
arch/powerpc/platforms/85xx/mpc85xx_cds.c
arch/powerpc/platforms/85xx/mpc85xx_mds.c
arch/powerpc/platforms/85xx/pci.c [deleted file]
arch/powerpc/platforms/86xx/Kconfig
arch/powerpc/platforms/86xx/Makefile
arch/powerpc/platforms/86xx/mpc86xx.h
arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
arch/powerpc/platforms/86xx/pci.c [deleted file]
arch/powerpc/platforms/cell/spufs/context.c
arch/powerpc/platforms/cell/spufs/run.c
arch/powerpc/platforms/cell/spufs/sched.c
arch/powerpc/platforms/cell/spufs/spufs.h
arch/powerpc/platforms/chrp/pci.c
arch/powerpc/platforms/embedded6xx/linkstation.c
arch/powerpc/platforms/iseries/lpevents.c
arch/powerpc/platforms/maple/pci.c
arch/powerpc/sysdev/Makefile
arch/powerpc/sysdev/fsl_pci.c [new file with mode: 0644]
arch/powerpc/sysdev/fsl_pci.h [new file with mode: 0644]
arch/powerpc/sysdev/fsl_pcie.h [deleted file]
arch/powerpc/sysdev/fsl_soc.c
arch/powerpc/sysdev/grackle.c
arch/powerpc/sysdev/indirect_pci.c
arch/powerpc/sysdev/mv64x60_pci.c
arch/ppc/configs/TQM8540_defconfig
arch/ppc/configs/TQM8541_defconfig
arch/ppc/configs/TQM8555_defconfig
arch/ppc/configs/TQM8560_defconfig
arch/ppc/configs/ev64360_defconfig
arch/ppc/configs/ml300_defconfig
arch/ppc/configs/ml403_defconfig
arch/ppc/configs/mpc834x_sys_defconfig
arch/ppc/configs/prep_defconfig
arch/s390/appldata/appldata_base.c
arch/s390/kernel/compat_wrapper.S
arch/s390/kernel/entry.S
arch/s390/kernel/entry64.S
arch/s390/kernel/head.S
arch/s390/kernel/init_task.c
arch/s390/kernel/process.c
arch/s390/kernel/smp.c
arch/s390/kernel/sys_s390.c
arch/s390/kernel/syscalls.S
arch/s390/kernel/vmlinux.lds.S
arch/s390/kernel/vtime.c
arch/s390/mm/vmem.c
arch/sparc/defconfig
arch/sparc/kernel/init_task.c
arch/sparc/kernel/sparc_ksyms.c
arch/sparc/kernel/vmlinux.lds.S
arch/sparc/lib/memset.S
arch/sparc/prom/printf.c
arch/sparc64/Kconfig.debug
arch/sparc64/defconfig
arch/sparc64/kernel/head.S
arch/sparc64/kernel/init_task.c
arch/sparc64/kernel/process.c
arch/sparc64/kernel/viohs.c
arch/sparc64/kernel/vmlinux.lds.S
arch/um/drivers/mconsole_kern.c
arch/um/drivers/mmapper_kern.c
arch/um/drivers/net_kern.c
arch/um/drivers/ubd_kern.c
arch/um/kernel/exec.c
arch/um/kernel/init_task.c
arch/um/kernel/mem.c
arch/um/kernel/physmem.c
arch/um/kernel/skas/process.c
arch/um/kernel/syscall.c
arch/um/os-Linux/aio.c
arch/um/os-Linux/process.c
arch/um/os-Linux/user_syms.c
arch/um/sys-i386/Makefile
arch/x86_64/Kconfig
arch/x86_64/defconfig
arch/x86_64/ia32/ia32_binfmt.c
arch/x86_64/ia32/ptrace32.c
arch/x86_64/ia32/syscall32.c
arch/x86_64/kernel/Makefile
arch/x86_64/kernel/acpi/sleep.c
arch/x86_64/kernel/process.c
arch/x86_64/kernel/suspend.c
arch/x86_64/kernel/sys_x86_64.c
arch/x86_64/kernel/tce.c
arch/x86_64/kernel/tsc.c
arch/x86_64/mm/init.c
arch/x86_64/vdso/vma.c
block/as-iosched.c
block/blktrace.c
block/bsg.c
block/cfq-iosched.c
block/deadline-iosched.c
block/elevator.c
block/ll_rw_blk.c
block/noop-iosched.c
block/scsi_ioctl.c
drivers/acorn/block/fd1772.c
drivers/acorn/block/mfmhd.c
drivers/acpi/Kconfig
drivers/acpi/ac.c
drivers/acpi/acpi_memhotplug.c
drivers/acpi/asus_acpi.c
drivers/acpi/battery.c
drivers/acpi/button.c
drivers/acpi/container.c
drivers/acpi/ec.c
drivers/acpi/events/evrgnini.c
drivers/acpi/fan.c
drivers/acpi/namespace/nsxfeval.c
drivers/acpi/pci_link.c
drivers/acpi/pci_root.c
drivers/acpi/power.c
drivers/acpi/processor_core.c
drivers/acpi/processor_throttling.c
drivers/acpi/sbs.c
drivers/acpi/scan.c
drivers/acpi/sleep/Makefile
drivers/acpi/sleep/main.c
drivers/acpi/sleep/proc.c
drivers/acpi/sleep/sleep.h
drivers/acpi/sleep/wakeup.c
drivers/acpi/thermal.c
drivers/acpi/utilities/uteval.c
drivers/acpi/video.c
drivers/ata/ata_piix.c
drivers/ata/libata-scsi.c
drivers/ata/pata_ali.c
drivers/ata/pata_hpt37x.c
drivers/base/power/Makefile
drivers/base/power/power.h
drivers/base/power/shutdown.c
drivers/block/amiflop.c
drivers/block/aoe/aoe.h
drivers/block/aoe/aoeblk.c
drivers/block/ataflop.c
drivers/block/cciss.c
drivers/block/cpqarray.c
drivers/block/floppy.c
drivers/block/lguest_blk.c
drivers/block/loop.c
drivers/block/nbd.c
drivers/block/paride/pcd.c
drivers/block/paride/pd.c
drivers/block/paride/pf.c
drivers/block/pktcdvd.c
drivers/block/ps2esdi.c
drivers/block/ps3disk.c
drivers/block/rd.c
drivers/block/sunvdc.c
drivers/block/swim3.c
drivers/block/sx8.c
drivers/block/ub.c
drivers/block/umem.c
drivers/block/viodasd.c
drivers/block/xd.c
drivers/block/xd.h
drivers/block/xen-blkfront.c
drivers/block/xsysace.c
drivers/block/z2ram.c
drivers/cdrom/cdrom.c
drivers/cdrom/viocd.c
drivers/char/Kconfig
drivers/char/Makefile
drivers/char/agp/Kconfig
drivers/char/agp/ati-agp.c
drivers/char/agp/compat_ioctl.c
drivers/char/agp/frontend.c
drivers/char/agp/generic.c
drivers/char/agp/intel-agp.c
drivers/char/agp/sgi-agp.c
drivers/char/hpet.c
drivers/char/hvc_lguest.c
drivers/char/mmtimer.c
drivers/char/mspec.c
drivers/edac/Kconfig
drivers/edac/edac_mc.c
drivers/edac/edac_mc_sysfs.c
drivers/edac/edac_module.h
drivers/edac/edac_pci.c
drivers/edac/edac_pci_sysfs.c
drivers/edac/i3000_edac.c
drivers/i2c/busses/Kconfig
drivers/i2c/chips/ds1682.c
drivers/i2c/chips/tps65010.c
drivers/ide/ide-cd.c
drivers/ide/ide-disk.c
drivers/ide/ide-io.c
drivers/ide/ide-probe.c
drivers/ide/legacy/hd.c
drivers/ide/pci/scc_pata.c
drivers/ieee1394/raw1394.c
drivers/infiniband/hw/ipath/ipath_diag.c
drivers/input/misc/atlas_btns.c
drivers/input/serio/Kconfig
drivers/kvm/kvm_main.c
drivers/kvm/x86_emulate.c
drivers/lguest/Makefile
drivers/lguest/README [new file with mode: 0644]
drivers/lguest/core.c
drivers/lguest/hypercalls.c
drivers/lguest/interrupts_and_traps.c
drivers/lguest/io.c
drivers/lguest/lg.h
drivers/lguest/lguest.c
drivers/lguest/lguest_asm.S
drivers/lguest/lguest_bus.c
drivers/lguest/lguest_user.c
drivers/lguest/page_tables.c
drivers/lguest/segments.c
drivers/lguest/switcher.S
drivers/md/dm-table.c
drivers/md/dm.c
drivers/md/faulty.c
drivers/md/linear.c
drivers/md/md.c
drivers/md/multipath.c
drivers/md/raid0.c
drivers/md/raid1.c
drivers/md/raid10.c
drivers/md/raid5.c
drivers/media/video/Kconfig
drivers/message/i2o/i2o_block.c
drivers/misc/asus-laptop.c
drivers/misc/sony-laptop.c
drivers/misc/thinkpad_acpi.c
drivers/misc/thinkpad_acpi.h
drivers/mmc/card/queue.c
drivers/mmc/core/bus.c
drivers/mmc/core/core.c
drivers/mmc/core/core.h
drivers/mmc/core/host.c
drivers/mmc/core/mmc.c
drivers/mmc/core/mmc_ops.c
drivers/mmc/core/mmc_ops.h
drivers/mmc/core/sd.c
drivers/mmc/core/sd_ops.c
drivers/mmc/core/sd_ops.h
drivers/mmc/host/at91_mci.c
drivers/mmc/host/au1xmmc.c
drivers/mmc/host/imxmmc.c
drivers/mmc/host/mmci.c
drivers/mmc/host/mmci.h
drivers/mmc/host/omap.c
drivers/mmc/host/pxamci.c
drivers/mmc/host/sdhci.c
drivers/mmc/host/sdhci.h
drivers/mmc/host/wbsd.c
drivers/mmc/host/wbsd.h
drivers/mtd/maps/Kconfig
drivers/net/82596.c
drivers/net/Makefile
drivers/net/acenic.c
drivers/net/atl1/atl1_hw.h
drivers/net/atl1/atl1_main.c
drivers/net/ax88796.c
drivers/net/bfin_mac.c
drivers/net/cxgb3/cxgb3_offload.c
drivers/net/defxx.c
drivers/net/ehea/ehea.h
drivers/net/ehea/ehea_main.c
drivers/net/forcedeth.c
drivers/net/lguest_net.c
drivers/net/lib8390.c
drivers/net/netxen/netxen_nic.h
drivers/net/netxen/netxen_nic_main.c
drivers/net/phy/vitesse.c
drivers/net/pppol2tp.c
drivers/net/ps3_gelic_net.c
drivers/net/ps3_gelic_net.h
drivers/net/ucc_geth.c
drivers/net/ucc_geth.h
drivers/net/ucc_geth_ethtool.c [new file with mode: 0644]
drivers/net/ucc_geth_mii.c
drivers/pci/pci-acpi.c
drivers/pci/pci.c
drivers/pci/pci.h
drivers/pnp/card.c
drivers/pnp/core.c
drivers/pnp/driver.c
drivers/pnp/interface.c
drivers/pnp/isapnp/compat.c
drivers/pnp/isapnp/core.c
drivers/pnp/isapnp/proc.c
drivers/pnp/manager.c
drivers/pnp/pnpacpi/core.c
drivers/pnp/pnpacpi/rsparser.c
drivers/pnp/pnpbios/bioscalls.c
drivers/pnp/pnpbios/core.c
drivers/pnp/pnpbios/proc.c
drivers/pnp/pnpbios/rsparser.c
drivers/pnp/quirks.c
drivers/pnp/resource.c
drivers/pnp/support.c
drivers/pnp/system.c
drivers/rtc/Makefile
drivers/rtc/class.c
drivers/rtc/rtc-bfin.c
drivers/rtc/rtc-ds1307.c
drivers/rtc/rtc-stk17ta8.c
drivers/s390/block/dasd.c
drivers/s390/block/dasd_int.h
drivers/s390/block/dcssblk.c
drivers/s390/block/xpram.c
drivers/s390/char/Kconfig
drivers/s390/char/raw3270.c
drivers/s390/char/sclp_vt220.c
drivers/s390/char/tape.h
drivers/s390/char/tape_block.c
drivers/s390/char/vmur.c
drivers/s390/cio/blacklist.c
drivers/s390/cio/ccwgroup.c
drivers/s390/cio/chp.c
drivers/s390/cio/chsc.c
drivers/s390/cio/chsc.h
drivers/s390/cio/cio.c
drivers/s390/cio/cio_debug.h
drivers/s390/cio/cmf.c
drivers/s390/cio/css.c
drivers/s390/cio/css.h
drivers/s390/cio/device.c
drivers/s390/cio/device_fsm.c
drivers/s390/cio/device_ops.c
drivers/s390/net/ctcmain.c
drivers/s390/net/netiucv.c
drivers/sbus/char/Kconfig
drivers/sbus/char/jsflash.c
drivers/scsi/scsi_lib.c
drivers/scsi/sd.c
drivers/scsi/sr.c
drivers/serial/68328serial.c
drivers/serial/8250.c
drivers/serial/8250_early.c
drivers/serial/serial_core.c
drivers/spi/spi_s3c24xx.c
drivers/video/Kconfig
drivers/video/chipsfb.c
drivers/video/tgafb.c
drivers/w1/masters/ds1wm.c
drivers/xen/xenbus/xenbus_xs.c
fs/bio.c
fs/dcookies.c
fs/ext2/super.c
fs/ext3/super.c
fs/ext4/super.c
fs/lockd/svclock.c
fs/nfsd/nfs4xdr.c
fs/ocfs2/file.c
fs/open.c
fs/pipe.c
fs/proc/inode.c
fs/quota.c
fs/reiserfs/stree.c
fs/signalfd.c
fs/splice.c
fs/timerfd.c
fs/xfs/linux-2.6/xfs_ioctl32.c
include/acpi/acpi_bus.h
include/acpi/acpi_drivers.h
include/acpi/actypes.h
include/acpi/acutils.h
include/asm-alpha/bitops.h
include/asm-arm/arch-mxc/uncompress.h
include/asm-arm/arch-omap/mailbox.h
include/asm-arm/unaligned.h
include/asm-blackfin/bfin-global.h
include/asm-blackfin/mach-bf548/cdefBF54x_base.h
include/asm-blackfin/mach-bf548/irq.h
include/asm-blackfin/mach-bf561/cdefBF561.h
include/asm-blackfin/mach-bf561/defBF561.h
include/asm-blackfin/thread_info.h
include/asm-i386/acpi.h
include/asm-i386/bootparam.h
include/asm-i386/e820.h
include/asm-i386/ist.h
include/asm-i386/suspend.h
include/asm-ia64/acpi.h
include/asm-ia64/ia32.h
include/asm-ia64/machvec.h
include/asm-ia64/processor.h
include/asm-ia64/smp.h
include/asm-m68k/raw_io.h
include/asm-m68k/system.h
include/asm-m68knommu/hardirq.h
include/asm-m68knommu/hw_irq.h [new file with mode: 0644]
include/asm-m68knommu/machdep.h
include/asm-m68knommu/mcfdma.h
include/asm-m68knommu/system.h
include/asm-m68knommu/timex.h
include/asm-mips/edac.h [new file with mode: 0644]
include/asm-mips/war.h
include/asm-powerpc/bug.h
include/asm-powerpc/page.h
include/asm-powerpc/pci-bridge.h
include/asm-powerpc/ppc_asm.h
include/asm-powerpc/vio.h
include/asm-s390/ccwdev.h
include/asm-s390/s390_ext.h
include/asm-s390/smp.h
include/asm-s390/unistd.h
include/asm-x86_64/acpi.h
include/asm-x86_64/ist.h [new file with mode: 0644]
include/asm-x86_64/suspend.h
include/asm-x86_64/uaccess.h
include/asm-xtensa/io.h
include/linux/acpi.h
include/linux/apm_bios.h
include/linux/blkdev.h
include/linux/blktrace_api.h
include/linux/compiler.h
include/linux/device.h
include/linux/elevator.h
include/linux/freezer.h
include/linux/hugetlb.h
include/linux/ide.h
include/linux/interrupt.h
include/linux/lguest.h
include/linux/lguest_bus.h
include/linux/lguest_launcher.h
include/linux/libata.h
include/linux/loop.h
include/linux/mm.h
include/linux/mmc/core.h
include/linux/mod_devicetable.h
include/linux/netfilter/xt_connlimit.h
include/linux/pci.h
include/linux/pci_ids.h
include/linux/pm.h
include/linux/pnp.h
include/linux/pnpbios.h
include/linux/preempt.h
include/linux/raid/md_k.h
include/linux/reiserfs_fs.h
include/linux/sched.h
include/linux/serial_8250.h
include/linux/serial_core.h
include/linux/suspend.h
include/linux/time.h
include/net/netfilter/nf_conntrack_tuple.h
include/scsi/sd.h
include/xen/page.h
init/initramfs.c
kernel/Kconfig.preempt
kernel/acct.c
kernel/auditsc.c
kernel/hrtimer.c
kernel/irq/devres.c
kernel/kmod.c
kernel/power/Kconfig
kernel/power/Makefile
kernel/power/disk.c
kernel/power/main.c
kernel/power/power.h
kernel/sched.c
kernel/sched_debug.c
kernel/sys.c
kernel/sysctl.c
kernel/time.c
kernel/time/timekeeping.c
kernel/tsacct.c
lib/fault-inject.c
mm/Kconfig
mm/bounce.c
mm/hugetlb.c
mm/migrate.c
mm/mmap.c
mm/oom_kill.c
mm/page_alloc.c
mm/slab.c
mm/swapfile.c
mm/vmstat.c
net/8021q/vlan.c
net/bridge/br_input.c
net/bridge/netfilter/ebt_log.c
net/bridge/netfilter/ebt_ulog.c
net/ipv4/netfilter/ipt_LOG.c
net/ipv4/netfilter/nf_nat_core.c
net/ipv4/netfilter/nf_nat_rule.c
net/ipv6/ip6_tunnel.c
net/ipv6/netfilter/ip6t_LOG.c
net/ipv6/tcp_ipv6.c
net/iucv/iucv.c
net/key/af_key.c
net/netfilter/nf_conntrack_core.c
net/netfilter/nf_conntrack_expect.c
net/netfilter/nf_conntrack_helper.c
net/netfilter/nf_conntrack_proto_tcp.c
net/netfilter/nf_conntrack_proto_udp.c
net/netfilter/nf_conntrack_proto_udplite.c
net/netfilter/xt_connlimit.c
net/netfilter/xt_physdev.c
net/netfilter/xt_u32.c
net/netlink/genetlink.c
net/rxrpc/af_rxrpc.c
net/rxrpc/ar-connection.c
net/rxrpc/ar-transport.c
net/rxrpc/rxkad.c
net/sunrpc/auth_gss/svcauth_gss.c
net/sunrpc/svcsock.c
net/tipc/msg.h
scripts/Makefile.build
scripts/Makefile.modpost
scripts/kconfig/conf.c
scripts/kconfig/expr.h
scripts/kconfig/gconf.c
scripts/kconfig/kxgettext.c
scripts/kconfig/lkc_proto.h
scripts/kconfig/mconf.c
scripts/kconfig/menu.c
scripts/kconfig/qconf.cc
scripts/kconfig/zconf.tab.c_shipped
scripts/kconfig/zconf.y
scripts/mod/file2alias.c
scripts/mod/modpost.c
scripts/ver_linux
security/selinux/ss/services.c
security/selinux/xfrm.c
sound/soc/pxa/pxa2xx-ac97.c

diff --git a/CREDITS b/CREDITS
index 10c214d..832436e 100644 (file)
--- a/CREDITS
+++ b/CREDITS
@@ -966,6 +966,7 @@ N: Pekka Enberg
 E: penberg@cs.helsinki.fi
 W: http://www.cs.helsinki.fi/u/penberg/
 D: Various kernel hacks, fixes, and cleanups.
+D: Slab allocators
 S: Finland
 
 N: David Engebretsen
@@ -1939,8 +1940,8 @@ D: for Menuconfig's lxdialog.
 N: Christoph Lameter
 E: christoph@lameter.com
 D: Digiboard PC/Xe and PC/Xi, Digiboard EPCA
-D: Early protocol filter for bridging code
-D: Bug fixes
+D: NUMA support, Slab allocators, Page migration
+D: Scalability, Time subsystem
 
 N: Paul Laufer
 E: paul@laufernet.com
index eb42bf9..ec7c498 100644 (file)
@@ -704,14 +704,23 @@ X!Idrivers/video/console/fonts.c
 
   <chapter id="splice">
       <title>splice API</title>
-  <para>)
+  <para>
        splice is a method for moving blocks of data around inside the
-       kernel, without continually transferring it between the kernel
+       kernel, without continually transferring them between the kernel
        and user space.
   </para>
 !Iinclude/linux/splice.h
 !Ffs/splice.c
   </chapter>
 
+  <chapter id="pipes">
+      <title>pipes API</title>
+  <para>
+       Pipe interfaces are all for in-kernel (builtin image) use.
+       They are not exported for use by modules.
+  </para>
+!Iinclude/linux/pipe_fs_i.h
+!Ffs/pipe.c
+  </chapter>
 
 </book>
index 7d279f2..2c2f24f 100644 (file)
@@ -79,9 +79,9 @@ and how to prepare flush requests.  Note that the term 'ordered' is
 used to indicate the whole sequence of performing barrier requests
 including draining and flushing.
 
-typedef void (prepare_flush_fn)(request_queue_t *q, struct request *rq);
+typedef void (prepare_flush_fn)(struct request_queue *q, struct request *rq);
 
-int blk_queue_ordered(request_queue_t *q, unsigned ordered,
+int blk_queue_ordered(struct request_queue *q, unsigned ordered,
                      prepare_flush_fn *prepare_flush_fn);
 
 @q                     : the queue in question
@@ -92,7 +92,7 @@ int blk_queue_ordered(request_queue_t *q, unsigned ordered,
 For example, SCSI disk driver's prepare_flush_fn looks like the
 following.
 
-static void sd_prepare_flush(request_queue_t *q, struct request *rq)
+static void sd_prepare_flush(struct request_queue *q, struct request *rq)
 {
        memset(rq->cmd, 0, sizeof(rq->cmd));
        rq->cmd_type = REQ_TYPE_BLOCK_PC;
index 3adaace..8af392f 100644 (file)
@@ -740,12 +740,12 @@ Block now offers some simple generic functionality to help support command
 queueing (typically known as tagged command queueing), ie manage more than
 one outstanding command on a queue at any given time.
 
-       blk_queue_init_tags(request_queue_t *q, int depth)
+       blk_queue_init_tags(struct request_queue *q, int depth)
 
        Initialize internal command tagging structures for a maximum
        depth of 'depth'.
 
-       blk_queue_free_tags((request_queue_t *q)
+       blk_queue_free_tags((struct request_queue *q)
 
        Teardown tag info associated with the queue. This will be done
        automatically by block if blk_queue_cleanup() is called on a queue
@@ -754,7 +754,7 @@ one outstanding command on a queue at any given time.
 The above are initialization and exit management, the main helpers during
 normal operations are:
 
-       blk_queue_start_tag(request_queue_t *q, struct request *rq)
+       blk_queue_start_tag(struct request_queue *q, struct request *rq)
 
        Start tagged operation for this request. A free tag number between
        0 and 'depth' is assigned to the request (rq->tag holds this number),
@@ -762,7 +762,7 @@ normal operations are:
        for this queue is already achieved (or if the tag wasn't started for
        some other reason), 1 is returned. Otherwise 0 is returned.
 
-       blk_queue_end_tag(request_queue_t *q, struct request *rq)
+       blk_queue_end_tag(struct request_queue *q, struct request *rq)
 
        End tagged operation on this request. 'rq' is removed from the internal
        book keeping structures.
@@ -781,7 +781,7 @@ queue. For instance, on IDE any tagged request error needs to clear both
 the hardware and software block queue and enable the driver to sanely restart
 all the outstanding requests. There's a third helper to do that:
 
-       blk_queue_invalidate_tags(request_queue_t *q)
+       blk_queue_invalidate_tags(struct request_queue *q)
 
        Clear the internal block tag queue and re-add all the pending requests
        to the request queue. The driver will receive them again on the
index 75924e2..fff58ac 100644 (file)
@@ -83,6 +83,6 @@ struct bio *bio                       DBI     First bio in request
 
 struct bio *biotail            DBI     Last bio in request
 
-request_queue_t *q             DB      Request queue this request belongs to
+struct request_queue *q                DB      Request queue this request belongs to
 
 struct request_list *rl                B       Request list this request came from
index c175eed..a43d287 100644 (file)
@@ -211,22 +211,6 @@ Who:       Richard Purdie <rpurdie@rpsys.net>
 
 ---------------------------
 
-What:  read_dev_chars(), read_conf_data{,_lpm}() (s390 common I/O layer)
-When:  December 2007
-Why:   These functions are a leftover from 2.4 times. They have several
-       problems:
-       - Duplication of checks that are done in the device driver's
-         interrupt handler
-       - common I/O layer can't do device specific error recovery
-       - device driver can't be notified for conditions happening during
-         execution of the function
-       Device drivers should issue the read device characteristics and read
-       configuration data ccws and do the appropriate error handling
-       themselves.
-Who:   Cornelia Huck <cornelia.huck@de.ibm.com>
-
----------------------------
-
 What:  i2c-ixp2000, i2c-ixp4xx and scx200_i2c drivers
 When:  September 2007
 Why:   Obsolete. The new i2c-gpio driver replaces all hardware-specific
index 218a865..6bc2ba2 100644 (file)
@@ -148,7 +148,7 @@ pin ... that won't always match the specified output value, because of
 issues including wire-OR and output latencies.
 
 The get/set calls have no error returns because "invalid GPIO" should have
-been reported earlier in gpio_set_direction().  However, note that not all
+been reported earlier from gpio_direction_*().  However, note that not all
 platforms can read the value of output pins; those that can't should always
 return zero.  Also, using these calls for GPIOs that can't safely be accessed
 without sleeping (see below) is an error.
@@ -239,7 +239,7 @@ map between them using calls like:
 Those return either the corresponding number in the other namespace, or
 else a negative errno code if the mapping can't be done.  (For example,
 some GPIOs can't used as IRQs.)  It is an unchecked error to use a GPIO
-number that hasn't been marked as an input using gpio_set_direction(), or
+number that wasn't set up as an input using gpio_direction_input(), or
 to use an IRQ number that didn't originally come from gpio_to_irq().
 
 These two mapping calls are expected to cost on the order of a single
index 09a1baf..b963c3b 100644 (file)
@@ -79,7 +79,7 @@ Field  8 -- # of milliseconds spent writing
     measured from __make_request() to end_that_request_last()).
 Field  9 -- # of I/Os currently in progress
     The only field that should go to zero. Incremented as requests are
-    given to appropriate request_queue_t and decremented as they finish.
+    given to appropriate struct request_queue and decremented as they finish.
 Field 10 -- # of milliseconds spent doing I/Os
     This field is increases so long as field 9 is nonzero.
 Field 11 -- weighted # of milliseconds spent doing I/Os
index fb80e9f..1156653 100644 (file)
@@ -30,6 +30,7 @@ the beginning of each description states the restrictions within which a
 parameter is applicable:
 
        ACPI    ACPI support is enabled.
+       AGP     AGP (Accelerated Graphics Port) is enabled.
        ALSA    ALSA sound support is enabled.
        APIC    APIC support is enabled.
        APM     Advanced Power Management support is enabled.
@@ -227,6 +228,12 @@ and is between 256 and 4096 characters. It is defined in the file
                        to assume that this machine's pmtimer latches its value
                        and always returns good values.
 
+       agp=            [AGP]
+                       { off | try_unsupported }
+                       off: disable AGP support
+                       try_unsupported: try to drive unsupported chipsets
+                               (may crash computer or cause data corruption)
+
        enable_timer_pin_1 [i386,x86-64]
                        Enable PIN 1 of APIC timer
                        Can be useful to work around chipset bugs
index b9b9427..31e794e 100644 (file)
@@ -11,8 +11,7 @@ endif
 include $(KBUILD_OUTPUT)/.config
 LGUEST_GUEST_TOP := ($(CONFIG_PAGE_OFFSET) - 0x08000000)
 
-CFLAGS:=-Wall -Wmissing-declarations -Wmissing-prototypes -O3 \
-       -static -DLGUEST_GUEST_TOP="$(LGUEST_GUEST_TOP)" -Wl,-T,lguest.lds
+CFLAGS:=-Wall -Wmissing-declarations -Wmissing-prototypes -O3 -Wl,-T,lguest.lds
 LDLIBS:=-lz
 
 all: lguest.lds lguest
diff --git a/Documentation/lguest/extract b/Documentation/lguest/extract
new file mode 100644 (file)
index 0000000..7730bb6
--- /dev/null
@@ -0,0 +1,58 @@
+#! /bin/sh
+
+set -e
+
+PREFIX=$1
+shift
+
+trap 'rm -r $TMPDIR' 0
+TMPDIR=`mktemp -d`
+
+exec 3>/dev/null
+for f; do
+    while IFS="
+" read -r LINE; do
+       case "$LINE" in
+           *$PREFIX:[0-9]*:\**)
+               NUM=`echo "$LINE" | sed "s/.*$PREFIX:\([0-9]*\).*/\1/"`
+               if [ -f $TMPDIR/$NUM ]; then
+                   echo "$TMPDIR/$NUM already exits prior to $f"
+                   exit 1
+               fi
+               exec 3>>$TMPDIR/$NUM
+               echo $f | sed 's,\.\./,,g' > $TMPDIR/.$NUM
+               /bin/echo "$LINE" | sed -e "s/$PREFIX:[0-9]*//" -e "s/:\*/*/" >&3
+               ;;
+           *$PREFIX:[0-9]*)
+               NUM=`echo "$LINE" | sed "s/.*$PREFIX:\([0-9]*\).*/\1/"`
+               if [ -f $TMPDIR/$NUM ]; then
+                   echo "$TMPDIR/$NUM already exits prior to $f"
+                   exit 1
+               fi
+               exec 3>>$TMPDIR/$NUM
+               echo $f | sed 's,\.\./,,g' > $TMPDIR/.$NUM
+               /bin/echo "$LINE" | sed "s/$PREFIX:[0-9]*//" >&3
+               ;;
+           *:\**)
+               /bin/echo "$LINE" | sed -e "s/:\*/*/" -e "s,/\*\*/,," >&3
+               echo >&3
+               exec 3>/dev/null
+               ;;
+           *)
+               /bin/echo "$LINE" >&3
+               ;;
+       esac
+    done < $f
+    echo >&3
+    exec 3>/dev/null
+done
+
+LASTFILE=""
+for f in $TMPDIR/*; do
+    if [ "$LASTFILE" != $(cat $TMPDIR/.$(basename $f) ) ]; then
+       LASTFILE=$(cat $TMPDIR/.$(basename $f) )
+       echo "[ $LASTFILE ]"
+    fi
+    cat $f
+done
+
index 1432b50..f791840 100644 (file)
@@ -1,5 +1,10 @@
-/* Simple program to layout "physical" memory for new lguest guest.
- * Linked high to avoid likely physical memory.  */
+/*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>
 #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
+ * 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
+ * like these abbreviations and the header we need uses them, so we define them
+ * here.
+ */
 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-i386/e820.h"
+/*:*/
 
 #define PAGE_PRESENT 0x7       /* Present, RW, Execute */
 #define NET_PEERNUM 1
@@ -43,31 +56,52 @@ typedef uint8_t u8;
 #define SIOCBRADDIF    0x89a2          /* add interface to bridge      */
 #endif
 
+/*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. */
 static bool verbose;
 #define verbose(args...) \
        do { if (verbose) printf(args); } while(0)
+/*:*/
+
+/* The pipe to send commands to the waker process */
 static int waker_fd;
+/* The top of guest physical memory. */
+static u32 top;
 
+/* This is our list of devices. */
 struct device_list
 {
+       /* Summary information about the devices in our list: ready to pass to
+        * select() to ask which need servicing.*/
        fd_set infds;
        int max_infd;
 
+       /* The descriptor page for the devices. */
+       struct lguest_device_desc *descs;
+
+       /* A single linked list of devices. */
        struct device *dev;
+       /* ... And an end pointer so we can easily append new devices */
        struct device **lastdev;
 };
 
+/* 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. */
        struct lguest_device_desc *desc;
+       /* The memory page(s) of this device, if any.  Also mapped in Guest. */
        void *mem;
 
-       /* Watch this fd if handle_input non-NULL. */
+       /* 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);
 
-       /* Watch DMA to this key if handle_input non-NULL. */
+       /* 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);
@@ -76,6 +110,11 @@ struct device
        void *priv;
 };
 
+/*L:130
+ * Loading the Kernel.
+ *
+ * We start with couple of simple helper routines.  open_or_die() avoids
+ * error-checking code cluttering the callers: */
 static int open_or_die(const char *name, int flags)
 {
        int fd = open(name, flags);
@@ -84,26 +123,38 @@ 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)
 {
+       /* 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);
 
+       /* 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;
 }
 
-/* Find magic string marking entry point, return entry point. */
+/* 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)
 {
        void *p;
 
+       /* 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;
@@ -111,7 +162,17 @@ static unsigned long entry_point(void *start, void *end,
        err(1, "Is this image a genuine lguest?");
 }
 
-/* Returns the entry point */
+/* This routine takes an open vmlinux image, which is in ELF, and maps it into
+ * the Guest memory.  ELF = Embedded Linking Format, which is the format used
+ * by all modern binaries on Linux including the kernel.
+ *
+ * The ELF headers give *two* addresses: a physical address, and a virtual
+ * 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.
+ *
+ * We return the starting address. */
 static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr,
                             unsigned long *page_offset)
 {
@@ -120,40 +181,61 @@ static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr,
        unsigned int i;
        unsigned long start = -1UL, end = 0;
 
-       /* Sanity checks. */
+       /* Sanity checks on the main ELF header: an x86 executable with a
+        * reasonable number of correctly-sized program headers. */
        if (ehdr->e_type != ET_EXEC
            || ehdr->e_machine != EM_386
            || ehdr->e_phentsize != sizeof(Elf32_Phdr)
            || ehdr->e_phnum < 1 || ehdr->e_phnum > 65536U/sizeof(Elf32_Phdr))
                errx(1, "Malformed elf header");
 
+       /* An ELF executable contains an ELF header and a number of "program"
+        * headers which indicate which parts ("segments") of the program to
+        * load where. */
+
+       /* We read in all the program headers at once: */
        if (lseek(elf_fd, ehdr->e_phoff, SEEK_SET) < 0)
                err(1, "Seeking to program headers");
        if (read(elf_fd, phdr, sizeof(phdr)) != sizeof(phdr))
                err(1, "Reading program headers");
 
+       /* We don't know page_offset yet. */
        *page_offset = 0;
-       /* We map the loadable segments at virtual addresses corresponding
-        * to their physical addresses (our virtual == guest physical). */
+
+       /* 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++) {
+               /* If this isn't a loadable segment, we ignore it */
                if (phdr[i].p_type != PT_LOAD)
                        continue;
 
                verbose("Section %i: size %i addr %p\n",
                        i, phdr[i].p_memsz, (void *)phdr[i].p_paddr);
 
-               /* We expect linear address space. */
+               /* 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 everything private, writable. */
+               /* 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,
@@ -167,7 +249,31 @@ static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr,
        return entry_point((void *)start, (void *)end, *page_offset);
 }
 
-/* This is amazingly reliable. */
+/*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.
+ *
+ * This is amazingly reliable. */
 static unsigned long intuit_page_offset(unsigned char *img, unsigned long len)
 {
        unsigned int i, possibilities[256] = { 0 };
@@ -180,30 +286,52 @@ static unsigned long intuit_page_offset(unsigned char *img, unsigned long len)
        errx(1, "could not determine page offset");
 }
 
+/*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);
 }
 
+/*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;
 
-       /* Ugly brute force search for gzip header. */
+       /* GZIP header is 0x1F 0x8B <method> <flags>... <compressed-by>. */
        while (read(fd, &c, 1) == 1) {
                switch (state) {
                case 0:
@@ -220,8 +348,10 @@ static unsigned long load_bzimage(int fd, unsigned long *page_offset)
                        state++;
                        break;
                case 9:
+                       /* Seek back to the start of the gzip header. */
                        lseek(fd, -10, SEEK_CUR);
-                       if (c != 0x03) /* Compressed under UNIX. */
+                       /* One final check: "compressed under UNIX". */
+                       if (c != 0x03)
                                state = -1;
                        else
                                return unpack_bzimage(fd, page_offset);
@@ -230,25 +360,43 @@ static unsigned long load_bzimage(int fd, unsigned long *page_offset)
        errx(1, "Could not find kernel in bzImage");
 }
 
+/*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)
 {
        Elf32_Ehdr hdr;
 
+       /* Read in the first few bytes. */
        if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr))
                err(1, "Reading kernel");
 
+       /* 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);
 
+       /* Otherwise we assume it's a bzImage, and try to unpack it */
        return load_bzimage(fd, page_offset);
 }
 
+/* This is a trivial little helper to align pages.  Andi Kleen hated it because
+ * it calls getpagesize() twice: "it's dumb code."
+ *
+ * Kernel guys get really het up about optimization, even when it's not
+ * necessary.  I leave this code as a reaction against that. */
 static inline unsigned long page_align(unsigned long addr)
 {
+       /* Add upwards and truncate downwards. */
        return ((addr + getpagesize()-1) & ~(getpagesize()-1));
 }
 
-/* initrd gets loaded at top of memory: return length. */
+/*L:180 An "initial ram disk" is a disk image loaded into memory along with
+ * the kernel which the kernel can use to boot from without needing any
+ * drivers.  Most distributions now use this as standard: the initrd contains
+ * the code to load the appropriate driver modules for the current machine.
+ *
+ * Importantly, James Morris works for RedHat, and Fedora uses initrds for its
+ * kernels.  He sent me this (and tells me when I break it). */
 static unsigned long load_initrd(const char *name, unsigned long mem)
 {
        int ifd;
@@ -257,21 +405,35 @@ static unsigned long load_initrd(const char *name, unsigned long mem)
        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. */
        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);
+       /* 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);
+
+       /* 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.
+ *
+ * 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)
@@ -280,23 +442,32 @@ static unsigned long setup_pagetables(unsigned long mem,
        unsigned int mapped_pages, i, linear_pages;
        unsigned int ptes_per_page = getpagesize()/sizeof(u32);
 
-       /* If we can map all of memory above page_offset, we do so. */
+       /* 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();
 
-       /* Each linear PTE page can map ptes_per_page pages. */
+       /* 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 lay out top-level then linear mapping immediately below initrd */
+       /* We put the toplevel page directory page at the top of memory. */
        pgdir = (void *)mem - initrd_size - getpagesize();
+
+       /* Now we use the next linear_pages pages as pte pages */
        linear = (void *)pgdir - linear_pages*getpagesize();
 
+       /* Linear mapping is easy: put every page's address into the mapping in
+        * order.  PAGE_PRESENT contains the flags Present, Writable and
+        * Executable. */
        for (i = 0; i < mapped_pages; i++)
                linear[i] = ((i * getpagesize()) | PAGE_PRESENT);
 
-       /* Now set up pgd so that this memory is at page_offset */
+       /* 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. */
        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);
@@ -305,9 +476,13 @@ static unsigned long setup_pagetables(unsigned long mem,
        verbose("Linear mapping of %u pages in %u pte pages at %p\n",
                mapped_pages, linear_pages, linear);
 
+       /* We return the top level (guest-physical) address: the kernel needs
+        * to know where it is. */
        return (unsigned long)pgdir;
 }
 
+/* Simple routine to roll all the commandline arguments together with spaces
+ * between them. */
 static void concat(char *dst, char *args[])
 {
        unsigned int i, len = 0;
@@ -321,18 +496,24 @@ static void concat(char *dst, char *args[])
        dst[len] = '\0';
 }
 
+/* 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)
 {
        u32 args[] = { LHREQ_INITIALIZE,
-                      LGUEST_GUEST_TOP/getpagesize(), /* Just below us */
-                      pgdir, start, page_offset };
+                      top/getpagesize(), pgdir, start, page_offset };
        int fd;
 
        fd = open_or_die("/dev/lguest", O_RDWR);
        if (write(fd, args, sizeof(args)) < 0)
                err(1, "Writing to /dev/lguest");
+
+       /* We return the /dev/lguest file descriptor to control this Guest */
        return fd;
 }
+/*:*/
 
 static void set_fd(int fd, struct device_list *devices)
 {
@@ -341,61 +522,108 @@ static void set_fd(int fd, struct device_list *devices)
                devices->max_infd = fd;
 }
 
-/* When input arrives, we tell the kernel to kick lguest out with -EAGAIN. */
+/*L:200
+ * The Waker.
+ *
+ * With a console and network devices, we can have lots of input which we need
+ * to process.  We could try to tell the kernel what file descriptors to watch,
+ * but handing a file descriptor mask through to the kernel is fairly icky.
+ *
+ * Instead, we fork off a process which watches the file descriptors and writes
+ * the LHREQ_BREAK command to the /dev/lguest filedescriptor to tell the Host
+ * loop to stop running the Guest.  This causes it to return from the
+ * /dev/lguest read with -EAGAIN, where it will write to /dev/lguest to reset
+ * the LHREQ_BREAK and wake us up again.
+ *
+ * This, of course, is merely a different *kind* of icky.
+ */
 static void wake_parent(int pipefd, int lguest_fd, struct device_list *devices)
 {
+       /* Add the pipe from the Launcher to the fdset in the device_list, so
+        * we watch it, too. */
        set_fd(pipefd, devices);
 
        for (;;) {
                fd_set rfds = devices->infds;
                u32 args[] = { LHREQ_BREAK, 1 };
 
+               /* Wait until input is ready from one of the devices. */
                select(devices->max_infd+1, &rfds, NULL, NULL, NULL);
+               /* Is it a message from the Launcher? */
                if (FD_ISSET(pipefd, &rfds)) {
                        int ignorefd;
+                       /* If read() returns 0, it means the Launcher has
+                        * exited.  We silently follow. */
                        if (read(pipefd, &ignorefd, sizeof(ignorefd)) == 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);
-               } else
+               } 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)
 {
        int pipefd[2], child;
 
+       /* We create a pipe to talk to the waker, and also so it knows when the
+        * Launcher dies (and closes pipe). */
        pipe(pipefd);
        child = fork();
        if (child == -1)
                err(1, "forking");
 
        if (child == 0) {
+               /* Close the "writing" end of our copy of the pipe */
                close(pipefd[1]);
                wake_parent(pipefd[0], lguest_fd, device_list);
        }
+       /* Close the reading end of our copy of the pipe. */
        close(pipefd[0]);
 
+       /* Here is the fd used to talk to the waker. */
        return pipefd[1];
 }
 
+/*L:210
+ * Device Handling.
+ *
+ * When the Guest sends DMA to us, it sends us an array of addresses and sizes.
+ * We need to make sure it's not trying to reach into the Launcher itself, so
+ * we have a convenient routine which check it and exits with an error message
+ * if something funny is going on:
+ */
 static void *_check_pointer(unsigned long addr, unsigned int size,
                            unsigned int line)
 {
-       if (addr >= LGUEST_GUEST_TOP || addr + size >= LGUEST_GUEST_TOP)
+       /* 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);
+       /* We return a pointer for the caller's convenience, now we know it's
+        * safe to use. */
        return (void *)addr;
 }
+/* A macro which transparently hands the line number to the real function. */
 #define check_pointer(addr,size) _check_pointer(addr, size, __LINE__)
 
-/* Returns pointer to dma->used_len */
+/* 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)
 {
        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;
 
@@ -403,9 +631,15 @@ static u32 *dma2iov(unsigned long dma, struct iovec iov[], unsigned *num)
                iov[i].iov_len = udma->len[i];
        }
        *num = i;
+
+       /* We return the pointer to where the caller should write the amount of
+        * the buffer used. */
        return &udma->used_len;
 }
 
+/* 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)
 {
@@ -413,16 +647,21 @@ static u32 *get_dma_buffer(int fd, void *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;
 
-       /* Kernel stashes irq in ->used_len. */
+       /* 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;
 }
 
+/* This is a convenient routine to send the Guest an interrupt. */
 static void trigger_irq(int fd, u32 irq)
 {
        u32 buf[] = { LHREQ_IRQ, irq };
@@ -430,6 +669,10 @@ static void trigger_irq(int fd, u32 irq)
                err(1, "Triggering irq %i", 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)
 {
        static char discard_buf[1024];
@@ -438,19 +681,24 @@ static void discard_iovec(struct iovec *iov, unsigned int *num)
        iov->iov_len = sizeof(discard_buf);
 }
 
+/* Here is the input terminal setting we save, and the routine to restore them
+ * on exit so the user can see what they type next. */
 static struct termios orig_term;
 static void restore_term(void)
 {
        tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
 }
 
+/* We associate some data with the console for our exit hack. */
 struct console_abort
 {
+       /* How many times have they hit ^C? */
        int count;
+       /* When did they start? */
        struct timeval start;
 };
 
-/* We DMA input to buffer bound at start of console page. */
+/* This is the routine which handles console input (ie. stdin). */
 static bool handle_console_input(int fd, struct device *dev)
 {
        u32 irq = 0, *lenp;
@@ -459,24 +707,38 @@ static bool handle_console_input(int fd, struct device *dev)
        struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
        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);
        }
 
+       /* 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);
        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. */
                warnx("Failed to get console input, ignoring console.");
                len = 0;
        }
 
+       /* If we read the data into the Guest, fill in the length and send the
+        * interrupt. */
        if (lenp) {
                *lenp = len;
                trigger_irq(fd, irq);
        }
 
-       /* Three ^C within one second?  Exit. */
+       /* Three ^C within one second?  Exit.
+        *
+        * This is such a hack, but works surprisingly well.  Each ^C has to be
+        * in a buffer by itself, so they can't be too fast.  But we check that
+        * we get three within about a second, so they can't be too slow. */
        if (len == 1 && ((char *)iov[0].iov_base)[0] == 3) {
                if (!abort->count++)
                        gettimeofday(&abort->start, NULL);
@@ -484,43 +746,60 @@ 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) {
-                               /* Make sure waker is not blocked in BREAK */
                                u32 args[] = { LHREQ_BREAK, 0 };
+                               /* Close the fd so Waker will know it has to
+                                * exit. */
                                close(waker_fd);
+                               /* Just in case waker is blocked in BREAK, send
+                                * unbreak now. */
                                write(fd, args, sizeof(args));
                                exit(2);
                        }
                        abort->count = 0;
                }
        } else
+               /* 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)
 {
+       /* 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)
 {
-       /* Now we've seen output, we should warn if we can't get buffers. */
+       /* 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);
 }
 
+/* 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)
 {
        return 4 * peernum;
 }
 
+/* This is where we handle a packet coming in from the tun device */
 static bool handle_tun_input(int fd, struct device *dev)
 {
        u32 irq = 0, *lenp;
@@ -528,17 +807,28 @@ static bool handle_tun_input(int fd, struct device *dev)
        unsigned num;
        struct iovec iov[LGUEST_MAX_DMA_SECTIONS];
 
+       /* 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) {
+               /* 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)
                        warn("network: no dma buffer!");
                discard_iovec(iov, &num);
        }
 
+       /* Read the packet from the device directly into the Guest's buffer. */
        len = readv(dev->fd, iov, num);
        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);
@@ -546,9 +836,13 @@ static bool handle_tun_input(int fd, struct device *dev)
        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");
+       /* 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)
 {
@@ -558,36 +852,64 @@ static u32 handle_block_output(int fd, const struct iovec *iov,
        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 */
                        ftruncate(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;
 }
 
+/* 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)
 {
@@ -596,30 +918,53 @@ static void handle_output(int fd, unsigned long dma, unsigned long key,
        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;
                }
        }
+
+       /* 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);
 }
 
+/* This is called when the waker wakes us up: check for incoming file
+ * descriptors. */
 static void handle_input(int fd, struct device_list *devices)
 {
+       /* 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;
 
+               /* If nothing is ready, we're done. */
                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) {
                        if (i->handle_input && FD_ISSET(i->fd, &fds)) {
+                               /* 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));
@@ -629,26 +974,42 @@ static void handle_input(int fd, struct device_list *devices)
        }
 }
 
-static struct lguest_device_desc *new_dev_desc(u16 type, u16 features,
-                                              u16 num_pages)
+/*L:190
+ * Device Setup
+ *
+ * All devices need a descriptor so the Guest knows it exists, and a "struct
+ * device" so the Launcher can keep track of it.  We have common helper
+ * 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)
 {
-       static unsigned long top = LGUEST_GUEST_TOP;
-       struct lguest_device_desc *desc;
+       unsigned int i;
 
-       desc = malloc(sizeof(*desc));
-       desc->type = type;
-       desc->num_pages = num_pages;
-       desc->features = features;
-       desc->status = 0;
-       if (num_pages) {
-               top -= num_pages*getpagesize();
-               map_zeroed_pages(top, num_pages);
-               desc->pfn = top / getpagesize();
-       } else
-               desc->pfn = 0;
-       return desc;
+       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");
 }
 
+/* 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,
@@ -661,15 +1022,21 @@ static struct device *new_device(struct device_list *devices,
 {
        struct device *dev = malloc(sizeof(*dev));
 
-       /* Append to device list. */
+       /* Append to device list.  Prepending to a single-linked list is
+        * 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;
        dev->next = NULL;
        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(type, features, num_pages);
+       dev->desc = new_dev_desc(devices->descs, type, features, num_pages);
        dev->mem = (void *)(dev->desc->pfn * getpagesize());
        dev->handle_input = handle_input;
        dev->watch_key = (unsigned long)dev->mem + watch_off;
@@ -677,27 +1044,37 @@ static struct device *new_device(struct device_list *devices,
        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)
 {
        struct device *dev;
 
+       /* If we can save the initial standard input settings... */
        if (tcgetattr(STDIN_FILENO, &orig_term) == 0) {
                struct termios term = orig_term;
+               /* Then we turn off echo, line buffering and ^C etc.  We want a
+                * raw input stream to the Guest. */
                term.c_lflag &= ~(ISIG|ICANON|ECHO);
                tcsetattr(STDIN_FILENO, TCSANOW, &term);
+               /* If we exit gracefully, the original settings will be
+                * restored so the user can see what they're typing. */
                atexit(restore_term);
        }
 
-       /* We don't currently require a page for the console. */
+       /* 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);
+       /* 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;
@@ -705,20 +1082,47 @@ static void setup_block_file(const char *filename, struct device_list *devices)
        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);
-       p = dev->mem;
 
+       /* 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);
 }
 
-/* We use fnctl locks to reserve network slots (autocleanup!) */
+/*
+ * Network Devices.
+ *
+ * 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.
+ *
+ * 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;
@@ -726,26 +1130,33 @@ static unsigned int find_slot(int netfd, const char *filename)
        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));
@@ -755,11 +1166,15 @@ static void setup_net_file(const char *filename,
                        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);
 
-       /* We overwrite the /dev/zero mapping with the actual file. */
+       /* 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);
@@ -767,6 +1182,7 @@ static void setup_net_file(const char *filename,
                (void *)(dev->desc->pfn * getpagesize()), filename,
                dev->desc->features & ~LGUEST_NET_F_NOCSUM);
 }
+/*:*/
 
 static u32 str2ip(const char *ipaddr)
 {
@@ -776,7 +1192,11 @@ static u32 str2ip(const char *ipaddr)
        return (byte[0] << 24) | (byte[1] << 16) | (byte[2] << 8) | byte[3];
 }
 
-/* adapted from libbridge */
+/* This code is "adapted" from libbridge: it attaches the Host end of the
+ * network device to the bridge device specified by the command line.
+ *
+ * This is yet another James Morris contribution (I'm an IP-level guy, so I
+ * dislike bridging), and I just try not to break it. */
 static void add_to_bridge(int fd, const char *if_name, const char *br_name)
 {
        int ifidx;
@@ -795,12 +1215,16 @@ static void add_to_bridge(int fd, const char *if_name, const char *br_name)
                err(1, "can't add %s to bridge %s", if_name, 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). */
 static void configure_device(int fd, const char *devname, u32 ipaddr,
                             unsigned char hwaddr[6])
 {
        struct ifreq ifr;
        struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
 
+       /* Don't read these incantations.  Just cut & paste them like I did! */
        memset(&ifr, 0, sizeof(ifr));
        strcpy(ifr.ifr_name, devname);
        sin->sin_family = AF_INET;
@@ -811,12 +1235,19 @@ static void configure_device(int fd, const char *devname, u32 ipaddr,
        if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0)
                err(1, "Bringing interface %s up", devname);
 
+       /* SIOC stands for Socket I/O Control.  G means Get (vs S for Set
+        * above).  IF means Interface, and HWADDR is hardware address.
+        * Simple! */
        if (ioctl(fd, SIOCGIFHWADDR, &ifr) != 0)
                err(1, "getting hw address for %s", devname);
-
        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)
 {
        struct device *dev;
@@ -825,36 +1256,56 @@ static void setup_tun_net(const char *arg, struct device_list *devices)
        u32 ip;
        const char *br_name = NULL;
 
+       /* 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
+        * the truth, I completely blundered my way through this code, but it
+        * works now! */
        netfd = open_or_die("/dev/net/tun", O_RDWR);
        memset(&ifr, 0, sizeof(ifr));
        ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
        strcpy(ifr.ifr_name, "tap%d");
        if (ioctl(netfd, TUNSETIFF, &ifr) != 0)
                err(1, "configuring /dev/net/tun");
+       /* We don't need checksums calculated for packets coming in this
+        * device: trust us! */
        ioctl(netfd, TUNSETNOCSUM, 1);
 
-       /* You will be peer 1: we should create enough jitter to randomize */
+       /* 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);
+
+       /* 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;
 
+       /* 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! */
        ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
        if (ipfd < 0)
                err(1, "opening IP socket");
 
+       /* If the command line was --tunnet=bridge:<name> do bridging. */
        if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) {
                ip = INADDR_ANY;
                br_name = arg + strlen(BRIDGE_PFX);
                add_to_bridge(ipfd, ifr.ifr_name, br_name);
-       } else
+       } else /* It is an IP address to set up the device with */
                ip = str2ip(arg);
 
-       /* We are peer 0, ie. first slot. */
+       /* 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 "promisc" bit: we want every single packet. */
+       /* 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;
 
        close(ipfd);
@@ -865,31 +1316,10 @@ static void setup_tun_net(const char *arg, struct device_list *devices)
        if (br_name)
                verbose("attached to bridge: %s\n", br_name);
 }
+/* That's the end of device setup. */
 
-/* Now we know how much memory we have, we copy in device descriptors */
-static void map_device_descriptors(struct device_list *devs, unsigned long mem)
-{
-       struct device *i;
-       unsigned int num;
-       struct lguest_device_desc *descs;
-
-       /* Device descriptor array sits just above top of normal memory */
-       descs = map_zeroed_pages(mem, 1);
-
-       for (i = devs->dev, num = 0; i; i = i->next, num++) {
-               if (num == LGUEST_MAX_DEVICES)
-                       errx(1, "too many devices");
-               verbose("Device %i: %s\n", num,
-                       i->desc->type == LGUEST_DEVICE_T_NET ? "net"
-                       : i->desc->type == LGUEST_DEVICE_T_CONSOLE ? "console"
-                       : i->desc->type == LGUEST_DEVICE_T_BLOCK ? "block"
-                       : "unknown");
-               descs[num] = *i->desc;
-               free(i->desc);
-               i->desc = &descs[num];
-       }
-}
-
+/*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)
 {
@@ -901,20 +1331,37 @@ run_guest(int lguest_fd, struct device_list *device_list)
                /* 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. */
+
+               /* 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);
                        continue;
+               /* ENOENT means the Guest died.  Reading tells us why. */
                } else if (errno == ENOENT) {
                        char reason[1024] = { 0 };
                        read(lguest_fd, reason, sizeof(reason)-1);
                        errx(1, "%s", reason);
+               /* EAGAIN means the waker wanted us to look at some input.
+                * Anything else means a bug or incompatible change. */
                } else if (errno != EAGAIN)
                        err(1, "Running guest failed");
+
+               /* Service input, then unset the BREAK which releases
+                * the Waker. */
                handle_input(lguest_fd, device_list);
                if (write(lguest_fd, args, sizeof(args)) < 0)
                        err(1, "Resetting break");
        }
 }
+/*
+ * This is the end of the Launcher.
+ *
+ * But wait!  We've seen I/O from the Launcher, and we've seen I/O from the
+ * Drivers.  If we were to see the Host kernel I/O code, our understanding
+ * would be complete... :*/
 
 static struct option opts[] = {
        { "verbose", 0, NULL, 'v' },
@@ -932,19 +1379,59 @@ static void usage(void)
             "<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.
+ */
 int main(int argc, char *argv[])
 {
-       unsigned long mem, pgdir, start, page_offset, initrd_size = 0;
-       int c, lguest_fd;
+       /* 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;
+       /* 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;
+       /* If they specify an initrd file to load. */
        const char *initrd_name = NULL;
 
+       /* First we initialize the device list.  Since console and network
+        * 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);
 
+       /* 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
+        * line.  So we quickly look through the arguments to find the amount
+        * 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();
+                       break;
+               }
+       }
+
+       /* The options are fairly straight-forward */
        while ((c = getopt_long(argc, argv, "v", opts, NULL)) != EOF) {
                switch (c) {
                case 'v':
@@ -967,46 +1454,71 @@ int main(int argc, char *argv[])
                        usage();
                }
        }
+       /* After the other arguments we expect memory and kernel image name,
+        * followed by command line arguments for the kernel. */
        if (optind + 2 > argc)
                usage();
 
-       /* We need a console device */
+       /* We always have a console device */
        setup_console(&device_list);
 
-       /* First we map /dev/zero over all of guest-physical memory. */
-       mem = atoi(argv[optind]) * 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. */
        map_zeroed_pages(0, mem / getpagesize());
 
        /* Now we load the kernel */
        start = load_kernel(open_or_die(argv[optind+1], O_RDONLY),
                            &page_offset);
 
-       /* Write the device descriptors into memory. */
-       map_device_descriptors(&device_list, mem);
-
-       /* Map the initrd image if requested */
+       /* 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;
+               /* The bootloader type 0xFF means "unknown"; that's OK. */
                *(unsigned char *)(boot+0x210) = 0xFF;
        }
 
-       /* Set up the initial linar pagetables. */
+       /* Set up the initial linear pagetables, starting below the initrd. */
        pgdir = setup_pagetables(mem, initrd_size, page_offset);
 
-       /* E820 memory map: ours is a simple, single region. */
+       /* 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 });
-       /* Command line pointer and command line (at 4096) */
+       /* 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);
-       /* Paravirt type: 1 == lguest */
+
+       /* The guest type value of "1" tells the Guest it's under lguest. */
        *(int *)(boot + 0x23c) = 1;
 
+       /* We tell the kernel to initialize the Guest: this returns the open
+        * /dev/lguest file descriptor. */
        lguest_fd = tell_kernel(pgdir, start, page_offset);
+
+       /* 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);
 
+       /* Finally, run the Guest.  This doesn't return. */
        run_guest(lguest_fd, &device_list);
 }
+/*:*/
+
+/*M:999
+ * Mastery is done: you now know everything I do.
+ *
+ * But surely you have seen code, features and bugs in your wanderings which
+ * you now yearn to attack?  That is the real game, and I look forward to you
+ * patching and forking lguest into the Your-Name-Here-visor.
+ *
+ * Farewell, and good coding!
+ * Rusty Russell.
+ */
index 6f72021..442e14d 100644 (file)
@@ -1,10 +1,11 @@
-Version 10 of schedstats includes support for sched_domains, which
-hit the mainline kernel in 2.6.7.  Some counters make more sense to be
-per-runqueue; other to be per-domain.  Note that domains (and their associated
-information) will only be pertinent and available on machines utilizing
-CONFIG_SMP.
-
-In version 10 of schedstat, there is at least one level of domain
+Version 14 of schedstats includes support for sched_domains, which hit the
+mainline kernel in 2.6.20 although it is identical to the stats from version
+12 which was in the kernel from 2.6.13-2.6.19 (version 13 never saw a kernel
+release).  Some counters make more sense to be per-runqueue; other to be
+per-domain.  Note that domains (and their associated information) will only
+be pertinent and available on machines utilizing CONFIG_SMP.
+
+In version 14 of schedstat, there is at least one level of domain
 statistics for each cpu listed, and there may well be more than one
 domain.  Domains have no particular names in this implementation, but
 the highest numbered one typically arbitrates balancing across all the
@@ -27,7 +28,7 @@ to write their own scripts, the fields are described here.
 
 CPU statistics
 --------------
-cpu<N> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
+cpu<N> 1 2 3 4 5 6 7 8 9 10 11 12
 
 NOTE: In the sched_yield() statistics, the active queue is considered empty
     if it has only one process in it, since obviously the process calling
@@ -39,48 +40,20 @@ First four fields are sched_yield() statistics:
      3) # of times just the expired queue was empty
      4) # of times sched_yield() was called
 
-Next four are schedule() statistics:
-     5) # of times the active queue had at least one other process on it
-     6) # of times we switched to the expired queue and reused it
-     7) # of times schedule() was called
-     8) # of times schedule() left the processor idle
-
-Next four are active_load_balance() statistics:
-     9) # of times active_load_balance() was called
-    10) # of times active_load_balance() caused this cpu to gain a task
-    11) # of times active_load_balance() caused this cpu to lose a task
-    12) # of times active_load_balance() tried to move a task and failed
-
-Next three are try_to_wake_up() statistics:
-    13) # of times try_to_wake_up() was called
-    14) # of times try_to_wake_up() successfully moved the awakening task
-    15) # of times try_to_wake_up() attempted to move the awakening task
-
-Next two are wake_up_new_task() statistics:
-    16) # of times wake_up_new_task() was called
-    17) # of times wake_up_new_task() successfully moved the new task
-
-Next one is a sched_migrate_task() statistic:
-    18) # of times sched_migrate_task() was called
+Next three are schedule() statistics:
+     5) # of times we switched to the expired queue and reused it
+     6) # of times schedule() was called
+     7) # of times schedule() left the processor idle
 
-Next one is a sched_balance_exec() statistic:
-    19) # of times sched_balance_exec() was called
+Next two are try_to_wake_up() statistics:
+     8) # of times try_to_wake_up() was called
+     9) # of times try_to_wake_up() was called to wake up the local cpu
 
 Next three are statistics describing scheduling latency:
-    20) sum of all time spent running by tasks on this processor (in ms)
-    21) sum of all time spent waiting to run by tasks on this processor (in ms)
-    22) # of tasks (not necessarily unique) given to the processor
-
-The last six are statistics dealing with pull_task():
-    23) # of times pull_task() moved a task to this cpu when newly idle
-    24) # of times pull_task() stole a task from this cpu when another cpu
-       was newly idle
-    25) # of times pull_task() moved a task to this cpu when idle
-    26) # of times pull_task() stole a task from this cpu when another cpu
-       was idle
-    27) # of times pull_task() moved a task to this cpu when busy
-    28) # of times pull_task() stole a task from this cpu when another cpu
-       was busy
+    10) sum of all time spent running by tasks on this processor (in jiffies)
+    11) sum of all time spent waiting to run by tasks on this processor (in
+        jiffies)
+    12) # of timeslices run on this cpu
 
 
 Domain statistics
@@ -89,65 +62,95 @@ One of these is produced per domain for each cpu described. (Note that if
 CONFIG_SMP is not defined, *no* domains are utilized and these lines
 will not appear in the output.)
 
-domain<N> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
+domain<N> <cpumask> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
 
 The first field is a bit mask indicating what cpus this domain operates over.
 
-The next fifteen are a variety of load_balance() statistics:
-
-     1) # of times in this domain load_balance() was called when the cpu
-       was idle
-     2) # of times in this domain load_balance() was called when the cpu
-       was busy
-     3) # of times in this domain load_balance() was called when the cpu
-       was just becoming idle
-     4) # of times in this domain load_balance() tried to move one or more
-       tasks and failed, when the cpu was idle
-     5) # of times in this domain load_balance() tried to move one or more
-       tasks and failed, when the cpu was busy
-     6) # of times in this domain load_balance() tried to move one or more
-       tasks and failed, when the cpu was just becoming idle
-     7) sum of imbalances discovered (if any) with each call to
-       load_balance() in this domain when the cpu was idle
-     8) sum of imbalances discovered (if any) with each call to
-       load_balance() in this domain when the cpu was busy
-     9) sum of imbalances discovered (if any) with each call to
-       load_balance() in this domain when the cpu was just becoming idle
-    10) # of times in this domain load_balance() was called but did not find
-       a busier queue while the cpu was idle
-    11) # of times in this domain load_balance() was called but did not find
-       a busier queue while the cpu was busy
-    12) # of times in this domain load_balance() was called but did not find
-       a busier queue while the cpu was just becoming idle
-    13) # of times in this domain a busier queue was found while the cpu was
-       idle but no busier group was found
-    14) # of times in this domain a busier queue was found while the cpu was
-       busy but no busier group was found
-    15) # of times in this domain a busier queue was found while the cpu was
-       just becoming idle but no busier group was found
-
-Next two are sched_balance_exec() statistics:
-    17) # of times in this domain sched_balance_exec() successfully pushed
-       a task to a new cpu
-    18) # of times in this domain sched_balance_exec() tried but failed to
-       push a task to a new cpu
-
-Next two are try_to_wake_up() statistics:
-    19) # of times in this domain try_to_wake_up() tried to move a task based
-       on affinity and cache warmth
-    20) # of times in this domain try_to_wake_up() tried to move a task based
-       on load balancing
-
+The next 24 are a variety of load_balance() statistics in grouped into types
+of idleness (idle, busy, and newly idle):
+
+     1) # of times in this domain load_balance() was called when the
+        cpu was idle
+     2) # of times in this domain load_balance() checked but found
+        the load did not require balancing when the cpu was idle
+     3) # of times in this domain load_balance() tried to move one or
+        more tasks and failed, when the cpu was idle
+     4) sum of imbalances discovered (if any) with each call to
+        load_balance() in this domain when the cpu was idle
+     5) # of times in this domain pull_task() was called when the cpu
+        was idle
+     6) # of times in this domain pull_task() was called even though
+        the target task was cache-hot when idle
+     7) # of times in this domain load_balance() was called but did
+        not find a busier queue while the cpu was idle
+     8) # of times in this domain a busier queue was found while the
+        cpu was idle but no busier group was found
+
+     9) # of times in this domain load_balance() was called when the
+        cpu was busy
+    10) # of times in this domain load_balance() checked but found the
+        load did not require balancing when busy
+    11) # of times in this domain load_balance() tried to move one or
+        more tasks and failed, when the cpu was busy
+    12) sum of imbalances discovered (if any) with each call to
+        load_balance() in this domain when the cpu was busy
+    13) # of times in this domain pull_task() was called when busy
+    14) # of times in this domain pull_task() was called even though the
+        target task was cache-hot when busy
+    15) # of times in this domain load_balance() was called but did not
+        find a busier queue while the cpu was busy
+    16) # of times in this domain a busier queue was found while the cpu
+        was busy but no busier group was found
+
+    17) # of times in this domain load_balance() was called when the
+        cpu was just becoming idle
+    18) # of times in this domain load_balance() checked but found the
+        load did not require balancing when the cpu was just becoming idle
+    19) # of times in this domain load_balance() tried to move one or more
+        tasks and failed, when the cpu was just becoming idle
+    20) sum of imbalances discovered (if any) with each call to
+        load_balance() in this domain when the cpu was just becoming idle
+    21) # of times in this domain pull_task() was called when newly idle
+    22) # of times in this domain pull_task() was called even though the
+        target task was cache-hot when just becoming idle
+    23) # of times in this domain load_balance() was called but did not
+        find a busier queue while the cpu was just becoming idle
+    24) # of times in this domain a busier queue was found while the cpu
+        was just becoming idle but no busier group was found
+
+   Next three are active_load_balance() statistics:
+    25) # of times active_load_balance() was called
+    26) # of times active_load_balance() tried to move a task and failed
+    27) # of times active_load_balance() successfully moved a task
+
+   Next three are sched_balance_exec() statistics:
+    28) sbe_cnt is not used
+    29) sbe_balanced is not used
+    30) sbe_pushed is not used
+
+   Next three are sched_balance_fork() statistics:
+    31) sbf_cnt is not used
+    32) sbf_balanced is not used
+    33) sbf_pushed is not used
+
+   Next three are try_to_wake_up() statistics:
+    34) # of times in this domain try_to_wake_up() awoke a task that
+        last ran on a different cpu in this domain
+    35) # of times in this domain try_to_wake_up() moved a task to the
+        waking cpu because it was cache-cold on its own cpu anyway
+    36) # of times in this domain try_to_wake_up() started passive balancing
 
 /proc/<pid>/schedstat
 ----------------
 schedstats also adds a new /proc/<pid/schedstat file to include some of
 the same information on a per-process level.  There are three fields in
-this file correlating to fields 20, 21, and 22 in the CPU fields, but
-they only apply for that process.
+this file correlating for that process to:
+     1) time spent on the cpu
+     2) time spent waiting on a runqueue
+     3) # of timeslices run on this cpu
 
 A program could be easily written to make use of these extra fields to
 report on how well a particular process or set of processes is faring
 under the scheduler's policies.  A simple version of such a program is
 available at
-    http://eaglet.rain.com/rick/linux/schedstat/v10/latency.c
+    http://eaglet.rain.com/rick/linux/schedstat/v12/latency.c
index 01f222e..babd00b 100644 (file)
@@ -3339,6 +3339,14 @@ M:       thomas@winischhofer.net
 W:     http://www.winischhofer.at/linuxsisusbvga.shtml
 S:     Maintained
 
+SLAB ALLOCATOR
+P:     Christoph Lameter
+M:     clameter@sgi.com
+P:     Pekka Enberg
+M:     penberg@cs.helsinki.fi
+L:     linux-mm@kvack.org
+S:     Maintained
+
 SMC91x ETHERNET DRIVER
 P:     Nicolas Pitre
 M:     nico@cam.org
index 23f81c9..dfe3d16 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -299,7 +299,7 @@ CHECKFLAGS     := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise $(C
 MODFLAGS       = -DMODULE
 CFLAGS_MODULE   = $(MODFLAGS)
 AFLAGS_MODULE   = $(MODFLAGS)
-LDFLAGS_MODULE  = -r
+LDFLAGS_MODULE  =
 CFLAGS_KERNEL  =
 AFLAGS_KERNEL  =
 
index e27d23c..7ac1f13 100644 (file)
@@ -10,6 +10,7 @@
 #include <asm/system.h>
 #include <asm/asm-offsets.h>
 
+.section .text.head, "ax"
 .globl swapper_pg_dir
 .globl _stext
 swapper_pg_dir=SWAPPER_PGD
index ab642a4..9dc1cee 100644 (file)
@@ -195,7 +195,7 @@ pcibios_init(void)
 
 subsys_initcall(pcibios_init);
 
-char * __init
+char * __devinit
 pcibios_setup(char *str)
 {
        return str;
@@ -204,7 +204,7 @@ pcibios_setup(char *str)
 #ifdef ALPHA_RESTORE_SRM_SETUP
 static struct pdev_srm_saved_conf *srm_saved_configs;
 
-void __init
+void __devinit
 pdev_save_srm_config(struct pci_dev *dev)
 {
        struct pdev_srm_saved_conf *tmp;
@@ -247,14 +247,14 @@ pci_restore_srm_config(void)
 }
 #endif
 
-void __init
+void __devinit
 pcibios_fixup_resource(struct resource *res, struct resource *root)
 {
        res->start += root->start;
        res->end += root->start;
 }
 
-void __init
+void __devinit
 pcibios_fixup_device_resources(struct pci_dev *dev, struct pci_bus *bus)
 {
        /* Update device resources.  */
@@ -273,7 +273,7 @@ pcibios_fixup_device_resources(struct pci_dev *dev, struct pci_bus *bus)
        }
 }
 
-void __init
+void __devinit
 pcibios_fixup_bus(struct pci_bus *bus)
 {
        /* Propagate hose info into the subordinate devices.  */
index 6b07f89..e1c4707 100644 (file)
@@ -58,7 +58,7 @@ size_for_memory(unsigned long max)
        return max;
 }
 \f
-struct pci_iommu_arena *
+struct pci_iommu_arena * __init
 iommu_arena_new_node(int nid, struct pci_controller *hose, dma_addr_t base,
                     unsigned long window_size, unsigned long align)
 {
@@ -117,7 +117,7 @@ iommu_arena_new_node(int nid, struct pci_controller *hose, dma_addr_t base,
        return arena;
 }
 
-struct pci_iommu_arena *
+struct pci_iommu_arena * __init
 iommu_arena_new(struct pci_controller *hose, dma_addr_t base,
                unsigned long window_size, unsigned long align)
 {
index b287314..ad17644 100644 (file)
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/err.h>
 #include <linux/threads.h>
 #include <linux/smp.h>
 #include <linux/interrupt.h>
@@ -358,7 +359,7 @@ secondary_cpu_start(int cpuid, struct task_struct *idle)
 /*
  * Bring one cpu online.
  */
-static int __devinit
+static int __cpuinit
 smp_boot_one_cpu(int cpuid)
 {
        struct task_struct *idle;
@@ -487,7 +488,7 @@ smp_prepare_boot_cpu(void)
 {
 }
 
-int __devinit
+int __cpuinit
 __cpu_up(unsigned int cpu)
 {
        smp_boot_one_cpu(cpu);
@@ -541,7 +542,7 @@ smp_percpu_timer_interrupt(struct pt_regs *regs)
        set_irq_regs(old_regs);
 }
 
-int __init
+int
 setup_profiling_timer(unsigned int multiplier)
 {
        return -EINVAL;
index fe13daa..7af07d3 100644 (file)
@@ -15,6 +15,7 @@ SECTIONS
 
   _text = .;                                   /* Text and read-only data */
   .text : { 
+       *(.text.head)
        TEXT_TEXT
        SCHED_TEXT
        LOCK_TEXT
index 8501631..c8569e8 100644 (file)
@@ -341,6 +341,7 @@ config ARCH_PXA
        select ARCH_MTD_XIP
        select GENERIC_GPIO
        select GENERIC_TIME
+       select GENERIC_CLOCKEVENTS
        help
          Support for Intel's PXA2XX processor line.
 
index 5be2e98..4de432e 100644 (file)
@@ -23,6 +23,7 @@
 #include <linux/cpu.h>
 #include <linux/interrupt.h>
 #include <linux/smp.h>
+#include <linux/fs.h>
 
 #include <asm/cpu.h>
 #include <asm/elf.h>
index 1b76d87..eafbb2b 100644 (file)
@@ -17,6 +17,7 @@
 #include <linux/profile.h>
 #include <linux/errno.h>
 #include <linux/mm.h>
+#include <linux/err.h>
 #include <linux/cpu.h>
 #include <linux/smp.h>
 #include <linux/seq_file.h>
@@ -630,7 +631,7 @@ void smp_send_stop(void)
 /*
  * not supported here
  */
-int __init setup_profiling_timer(unsigned int multiplier)
+int setup_profiling_timer(unsigned int multiplier)
 {
        return -EINVAL;
 }
index f2114bc..8ad4761 100644 (file)
@@ -352,10 +352,8 @@ asmlinkage void __exception do_undefinstr(struct pt_regs *regs)
 
 asmlinkage void do_unexp_fiq (struct pt_regs *regs)
 {
-#ifndef CONFIG_IGNORE_FIQ
        printk("Hmm.  Unexpected FIQ received, but trying to continue\n");
        printk("You may have a hardware problem...\n");
-#endif
 }
 
 /*
index 64067cd..52ac37d 100644 (file)
@@ -3,6 +3,7 @@
  *
  * HP Jornada720 init code
  *
+ * Copyright (C) 2007 Kristoffer Ericson <Kristoffer.Ericson@gmail.com>
  * Copyright (C) 2006 Filip Zyzniewski <filip.zyzniewski@tefnet.pl>
  *  Copyright (C) 2005 Michael Gernoth <michael@gernoth.net>
  *
@@ -220,14 +221,16 @@ static struct platform_device sa1111_device = {
        .resource       = sa1111_resources,
 };
 
-static struct platform_device jornada720_mcu_device = {
-       .name           = "jornada720_mcu",
-       .id             = -1,
+static struct platform_device jornada_ssp_device = {
+       .name           = "jornada_ssp",
+       .id             = -1,
 };
 
 static struct platform_device *devices[] __initdata = {
        &sa1111_device,
-       &jornada720_mcu_device,
+#ifdef CONFIG_SA1100_JORNADA720_SSP
+       &jornada_ssp_device,
+#endif
        &s1d13xxxfb_device,
 };
 
@@ -236,19 +239,19 @@ static int __init jornada720_init(void)
        int ret = -ENODEV;
 
        if (machine_is_jornada720()) {
-               GPDR |= GPIO_GPIO20;
-               /* oscillator setup (line 116 of HP's doc) */
+               /* we want to use gpio20 as input to drive the clock of our uart 3 */
+               GPDR |= GPIO_GPIO20;    /* Clear gpio20 pin as input */
                TUCR = TUCR_VAL;
-               /* resetting SA1111 (line 118 of HP's doc) */
-               GPSR = GPIO_GPIO20;
+               GPSR = GPIO_GPIO20;     /* start gpio20 pin */
                udelay(1);
-               GPCR = GPIO_GPIO20;
+               GPCR = GPIO_GPIO20;     /* stop gpio20 */
                udelay(1);
-               GPSR = GPIO_GPIO20;
-               udelay(20);
+               GPSR = GPIO_GPIO20;     /* restart gpio20 */
+               udelay(20);             /* give it some time to restart */
 
                ret = platform_add_devices(devices, ARRAY_SIZE(devices));
        }
+
        return ret;
 }
 
@@ -345,7 +348,7 @@ static void __init jornada720_mach_init(void)
 }
 
 MACHINE_START(JORNADA720, "HP Jornada 720")
-       /* Maintainer: Michael Gernoth <michael@gernoth.net> */
+       /* Maintainer: Kristoffer Ericson <Kristoffer.Ericson@gmail.com> */
        .phys_io        = 0x80000000,
        .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
        .boot_params    = 0xc0000100,
index 0a45e1a..395c39b 100644 (file)
@@ -161,7 +161,7 @@ static int __init jornada_ssp_probe(struct platform_device *dev)
        ret = jornada_ssp_inout(GETBRIGHTNESS);
 
        /* seems like it worked, just feed it with TxDummy to get rid of data */
-       if (ret == TxDummy)
+       if (ret == TXDUMMY)
                jornada_ssp_inout(TXDUMMY);
 
        jornada_ssp_end();
index de7e6ef..0360b1f 100644 (file)
@@ -161,11 +161,11 @@ static void mbox_rx_work(struct work_struct *work)
 /*
  * Mailbox interrupt handler
  */
-static void mbox_txq_fn(request_queue_t * q)
+static void mbox_txq_fn(struct request_queue * q)
 {
 }
 
-static void mbox_rxq_fn(request_queue_t * q)
+static void mbox_rxq_fn(struct request_queue * q)
 {
 }
 
@@ -180,7 +180,7 @@ static void __mbox_rx_interrupt(struct omap_mbox *mbox)
 {
        struct request *rq;
        mbox_msg_t msg;
-       request_queue_t *q = mbox->rxq->queue;
+       struct request_queue *q = mbox->rxq->queue;
 
        disable_mbox_irq(mbox, IRQ_RX);
 
@@ -297,7 +297,7 @@ static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
                                        request_fn_proc * proc,
                                        void (*work) (struct work_struct *))
 {
-       request_queue_t *q;
+       struct request_queue *q;
        struct omap_mbox_queue *mq;
 
        mq = kzalloc(sizeof(struct omap_mbox_queue), GFP_KERNEL);
index 1b75672..2084166 100644 (file)
@@ -24,6 +24,8 @@ machine-$(CONFIG_BF533) := bf533
 machine-$(CONFIG_BF534) := bf537
 machine-$(CONFIG_BF536) := bf537
 machine-$(CONFIG_BF537) := bf537
+machine-$(CONFIG_BF542) := bf548
+machine-$(CONFIG_BF544) := bf548
 machine-$(CONFIG_BF548) := bf548
 machine-$(CONFIG_BF549) := bf548
 machine-$(CONFIG_BF561) := bf561
@@ -36,6 +38,8 @@ cpu-$(CONFIG_BF533) := bf533
 cpu-$(CONFIG_BF534) := bf534
 cpu-$(CONFIG_BF536) := bf536
 cpu-$(CONFIG_BF537) := bf537
+cpu-$(CONFIG_BF542) := bf542
+cpu-$(CONFIG_BF544) := bf544
 cpu-$(CONFIG_BF548) := bf548
 cpu-$(CONFIG_BF549) := bf549
 cpu-$(CONFIG_BF561) := bf561
index ea48d5b..94d7b11 100644 (file)
@@ -160,7 +160,8 @@ dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
        BUG_ON(direction == DMA_NONE);
 
        for (i = 0; i < nents; i++, sg++) {
-               sg->dma_address = page_address(sg->page) + sg->offset;
+               sg->dma_address = (dma_addr_t)(page_address(sg->page) +
+                                       sg->offset);
 
                invalidate_dcache_range(sg_dma_address(sg),
                                        sg_dma_address(sg) +
index f59dcee..88f221b 100644 (file)
@@ -402,11 +402,7 @@ void __init setup_arch(char **cmdline_p)
        if (l1_length > L1_DATA_A_LENGTH)
                panic("L1 data memory overflow\n");
 
-#ifdef BF561_FAMILY
-       _bfin_swrst = bfin_read_SICA_SWRST();
-#else
        _bfin_swrst = bfin_read_SWRST();
-#endif
 
        /* Copy atomic sequences to their fixed location, and sanity check that
           these locations are the ones that we advertise to userspace.  */
@@ -429,6 +425,7 @@ void __init setup_arch(char **cmdline_p)
        BUG_ON((char *)&atomic_xor32 - (char *)&fixed_code_start
               != ATOMIC_XOR32 - FIXED_CODE_START);
 
+       init_exception_vectors();
        bf53x_cache_init();
 }
 
index 3909f5b..8766bd6 100644 (file)
@@ -140,7 +140,7 @@ asmlinkage void trap_c(struct pt_regs *fp)
 #ifdef CONFIG_KGDB
 # define CHK_DEBUGGER_TRAP() \
        do { \
-               CHK_DEBUGGER(trapnr, sig, info.si_code, fp); \
+               CHK_DEBUGGER(trapnr, sig, info.si_code, fp, ); \
        } while (0)
 # define CHK_DEBUGGER_TRAP_MAYBE() \
        do { \
index d06f860..fb53780 100644 (file)
@@ -32,6 +32,7 @@
 #include <asm-generic/vmlinux.lds.h>
 #include <asm/mem_map.h>
 #include <asm/page.h>
+#include <asm/thread_info.h>
 
 OUTPUT_FORMAT("elf32-bfin")
 ENTRY(__start)
@@ -64,8 +65,12 @@ SECTIONS
 
        .data :
        {
-               . = ALIGN(PAGE_SIZE);
+               /* make sure the init_task is aligned to the
+                * kernel thread size so we can locate the kernel
+                * stack properly and quickly.
+                */
                __sdata = .;
+               . = ALIGN(THREAD_SIZE);
                *(.data.init_task)
                DATA_DATA
                CONSTRUCTORS
@@ -73,14 +78,14 @@ SECTIONS
                . = ALIGN(32);
                *(.data.cacheline_aligned)
 
-               . = ALIGN(PAGE_SIZE);
+               . = ALIGN(THREAD_SIZE);
                __edata = .;
        }
 
-       . = ALIGN(PAGE_SIZE);
        ___init_begin = .;
        .init :
        {
+               . = ALIGN(PAGE_SIZE);
                __sinittext = .;
                *(.init.text)
                __einittext = .;
@@ -153,10 +158,9 @@ SECTIONS
                __ebss_b_l1 = .;
        }
 
-       . = LOADADDR(.data_b_l1) + SIZEOF(.data_b_l1);
-       ___init_end = ALIGN(PAGE_SIZE);
+       ___init_end = LOADADDR(.data_b_l1) + SIZEOF(.data_b_l1);
 
-       .bss ___init_end :
+       .bss LOADADDR(.data_b_l1) + SIZEOF(.data_b_l1) :
        {
                . = ALIGN(4);
                ___bss_start = .;
index 2f08bcb..38650a6 100644 (file)
@@ -440,15 +440,15 @@ ENTRY(_bfin_reset)
        SSYNC;
 
        /* make sure SYSCR is set to use BMODE */
-       P0.h = hi(SICA_SYSCR);
-       P0.l = lo(SICA_SYSCR);
-       R0.l = 0x20;
+       P0.h = hi(SYSCR);
+       P0.l = lo(SYSCR);
+       R0.l = 0x20;            /* on BF561, disable core b */
        W[P0] = R0.l;
        SSYNC;
 
        /* issue a system soft reset */
-       P1.h = hi(SICA_SWRST);
-       P1.l = lo(SICA_SWRST);
+       P1.h = hi(SWRST);
+       P1.l = lo(SWRST);
        R1.l = 0x0007;
        W[P1] = R1;
        SSYNC;
index 9d47562..5be6b97 100644 (file)
@@ -60,6 +60,9 @@ ENDPROC(_bfin_write_IMEM_CONTROL)
 
 #if defined(CONFIG_BLKFIN_DCACHE)
 ENTRY(_bfin_write_DMEM_CONTROL)
+       P0.l = (DMEM_CONTROL & 0xFFFF);
+       P0.h = (DMEM_CONTROL >> 16);
+
        CLI R1;
        SSYNC;          /* SSYNC required before writing to DMEM_CONTROL. */
        .align 8;
index 6b9fd03..660f881 100644 (file)
@@ -358,26 +358,10 @@ static void bf561_demux_gpio_irq(unsigned int inta_irq,
 
 #endif                         /* CONFIG_IRQCHIP_DEMUX_GPIO */
 
-/*
- * This function should be called during kernel startup to initialize
- * the BFin IRQ handling routines.
- */
-int __init init_arch_irq(void)
+void __init init_exception_vectors(void)
 {
-       int irq;
-       unsigned long ilat = 0;
-       /*  Disable all the peripheral intrs  - page 4-29 HW Ref manual */
-       bfin_write_SICA_IMASK0(SIC_UNMASK_ALL);
-       bfin_write_SICA_IMASK1(SIC_UNMASK_ALL);
        SSYNC();
 
-       bfin_write_SICA_IWR0(IWR_ENABLE_ALL);
-       bfin_write_SICA_IWR1(IWR_ENABLE_ALL);
-
-       local_irq_disable();
-
-       init_exception_buff();
-
 #ifndef CONFIG_KGDB
        bfin_write_EVT0(evt_emulation);
 #endif
@@ -395,6 +379,27 @@ int __init init_arch_irq(void)
        bfin_write_EVT14(evt14_softirq);
        bfin_write_EVT15(evt_system_call);
        CSYNC();
+}
+
+/*
+ * This function should be called during kernel startup to initialize
+ * the BFin IRQ handling routines.
+ */
+int __init init_arch_irq(void)
+{
+       int irq;
+       unsigned long ilat = 0;
+       /*  Disable all the peripheral intrs  - page 4-29 HW Ref manual */
+       bfin_write_SICA_IMASK0(SIC_UNMASK_ALL);
+       bfin_write_SICA_IMASK1(SIC_UNMASK_ALL);
+       SSYNC();
+
+       bfin_write_SICA_IWR0(IWR_ENABLE_ALL);
+       bfin_write_SICA_IWR1(IWR_ENABLE_ALL);
+
+       local_irq_disable();
+
+       init_exception_buff();
 
        for (irq = 0; irq <= SYS_IRQS; irq++) {
                if (irq <= IRQ_CORETMR)
index 28a878c..4708023 100644 (file)
@@ -579,8 +579,12 @@ static unsigned int bfin_gpio_irq_startup(unsigned int irq)
        u16 gpionr = irq - IRQ_PA0;
        u8 pint_val = irq2pint_lut[irq - SYS_IRQS];
 
-       if (pint_val == IRQ_NOT_AVAIL)
+       if (pint_val == IRQ_NOT_AVAIL) {
+               printk(KERN_ERR
+               "GPIO IRQ %d :Not in PINT Assign table "
+               "Reconfigure Interrupt to Port Assignemt\n", irq);
                return -ENODEV;
+       }
 
        if (!(gpio_enabled[gpio_bank(gpionr)] & gpio_bit(gpionr))) {
                ret = gpio_request(gpionr, NULL);
@@ -713,6 +717,29 @@ static void bfin_demux_gpio_irq(unsigned int intb_irq,
 }
 #endif                         /* CONFIG_IRQCHIP_DEMUX_GPIO */
 
+void __init init_exception_vectors(void)
+{
+       SSYNC();
+
+#ifndef CONFIG_KGDB
+       bfin_write_EVT0(evt_emulation);
+#endif
+       bfin_write_EVT2(evt_evt2);
+       bfin_write_EVT3(trap);
+       bfin_write_EVT5(evt_ivhw);
+       bfin_write_EVT6(evt_timer);
+       bfin_write_EVT7(evt_evt7);
+       bfin_write_EVT8(evt_evt8);
+       bfin_write_EVT9(evt_evt9);
+       bfin_write_EVT10(evt_evt10);
+       bfin_write_EVT11(evt_evt11);
+       bfin_write_EVT12(evt_evt12);
+       bfin_write_EVT13(evt_evt13);
+       bfin_write_EVT14(evt14_softirq);
+       bfin_write_EVT15(evt_system_call);
+       CSYNC();
+}
+
 /*
  * This function should be called during kernel startup to initialize
  * the BFin IRQ handling routines.
@@ -733,29 +760,10 @@ int __init init_arch_irq(void)
        bfin_write_SIC_IMASK(SIC_UNMASK_ALL);
        bfin_write_SIC_IWR(IWR_ENABLE_ALL);
 #endif
-
        SSYNC();
 
        local_irq_disable();
 
-#ifndef CONFIG_KGDB
-       bfin_write_EVT0(evt_emulation);
-#endif
-       bfin_write_EVT2(evt_evt2);
-       bfin_write_EVT3(trap);
-       bfin_write_EVT5(evt_ivhw);
-       bfin_write_EVT6(evt_timer);
-       bfin_write_EVT7(evt_evt7);
-       bfin_write_EVT8(evt_evt8);
-       bfin_write_EVT9(evt_evt9);
-       bfin_write_EVT10(evt_evt10);
-       bfin_write_EVT11(evt_evt11);
-       bfin_write_EVT12(evt_evt12);
-       bfin_write_EVT13(evt_evt13);
-       bfin_write_EVT14(evt14_softirq);
-       bfin_write_EVT15(evt_system_call);
-       CSYNC();
-
 #if defined(CONFIG_IRQCHIP_DEMUX_GPIO) && defined(CONFIG_BF54x)
 #ifdef CONFIG_PINTx_REASSIGN
        pint[0]->assign = CONFIG_PINT0_ASSIGN;
index 26b3df3..6fbe266 100644 (file)
@@ -13,6 +13,7 @@
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/smp.h>
 #include <linux/sem.h>
 #include <linux/msg.h>
index b31c080..f03531e 100644 (file)
@@ -36,11 +36,11 @@ config DEBUG_STACK_USAGE
          This option will slow down process creation somewhat.
 
 comment "Page alloc debug is incompatible with Software Suspend on i386"
-       depends on DEBUG_KERNEL && SOFTWARE_SUSPEND
+       depends on DEBUG_KERNEL && HIBERNATION
 
 config DEBUG_PAGEALLOC
        bool "Debug page memory allocations"
-       depends on DEBUG_KERNEL && !SOFTWARE_SUSPEND && !HUGETLBFS
+       depends on DEBUG_KERNEL && !HIBERNATION && !HUGETLBFS
        help
          Unmap pages from the kernel linear mapping after free_pages().
          This results in a large slowdown, but helps to find certain types
index a34087c..eab50c5 100644 (file)
@@ -40,14 +40,15 @@ int query_apm_bios(void)
        if (bx != 0x504d)       /* "PM" signature */
                return -1;
 
-       if (cx & 0x02)          /* 32 bits supported? */
+       if (!(cx & 0x02))               /* 32 bits supported? */
                return -1;
 
        /* Disconnect first, just in case */
        ax = 0x5304;
+       bx = 0;
        asm volatile("pushl %%ebp ; int $0x15 ; popl %%ebp"
-                    : "+a" (ax)
-                    : : "ebx", "ecx", "edx", "esi", "edi");
+                    : "+a" (ax), "+b" (bx)
+                    : : "ecx", "edx", "esi", "edi");
 
        /* Paranoia */
        ebx = esi = 0;
index 7f01f96..0eeef39 100644 (file)
@@ -73,15 +73,15 @@ static void keyboard_set_repeat(void)
 }
 
 /*
- * Get Intel SpeedStep IST information.
+ * Get Intel SpeedStep (IST) information.
  */
-static void query_speedstep_ist(void)
+static void query_ist(void)
 {
        asm("int $0x15"
-           : "=a" (boot_params.speedstep_info[0]),
-             "=b" (boot_params.speedstep_info[1]),
-             "=c" (boot_params.speedstep_info[2]),
-             "=d" (boot_params.speedstep_info[3])
+           : "=a" (boot_params.ist_info.signature),
+             "=b" (boot_params.ist_info.command),
+             "=c" (boot_params.ist_info.event),
+             "=d" (boot_params.ist_info.perf_level)
            : "a" (0x0000e980),  /* IST Support */
              "d" (0x47534943)); /* Request value */
 }
@@ -144,8 +144,8 @@ void main(void)
        query_voyager();
 #endif
 
-       /* Query SpeedStep IST information */
-       query_speedstep_ist();
+       /* Query Intel SpeedStep (IST) information */
+       query_ist();
 
        /* Query APM information */
 #if defined(CONFIG_APM) || defined(CONFIG_APM_MODULE)
index c3750c2..c85598a 100644 (file)
@@ -430,22 +430,12 @@ void __init alternative_instructions(void)
  * And on the local CPU you need to be protected again NMI or MCE handlers
  * seeing an inconsistent instruction while you patch.
  */
-void __kprobes text_poke(void *oaddr, unsigned char *opcode, int len)
+void __kprobes text_poke(void *addr, unsigned char *opcode, int len)
 {
-        u8 *addr = oaddr;
-       if (!pte_write(*lookup_address((unsigned long)addr))) {
-               struct page *p[2] = { virt_to_page(addr), virt_to_page(addr+PAGE_SIZE) };
-               addr = vmap(p, 2, VM_MAP, PAGE_KERNEL);
-               if (!addr)
-                       return;
-               addr += ((unsigned long)oaddr) % PAGE_SIZE;
-       }
        memcpy(addr, opcode, len);
        sync_core();
        /* Not strictly needed, but can speed CPU recovery up. Ignore cross cacheline
           case. */
        if (cpu_has_clflush)
-               asm("clflush (%0) " :: "r" (oaddr) : "memory");
-       if (addr != oaddr)
-               vunmap(addr);
+               asm("clflush (%0) " :: "r" (addr) : "memory");
 }
index 094118b..d8c6f13 100644 (file)
@@ -92,7 +92,7 @@ config X86_POWERNOW_K8
 config X86_POWERNOW_K8_ACPI
        bool "ACPI Support"
        select ACPI_PROCESSOR
-       depends on X86_POWERNOW_K8
+       depends on ACPI && X86_POWERNOW_K8
        default y
        help
          This provides access to the K8s Processor Performance States via ACPI.
index e60cddb..3c86b97 100644 (file)
@@ -321,7 +321,7 @@ static int __init request_standard_resources(void)
 
 subsys_initcall(request_standard_resources);
 
-#if defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND)
+#if defined(CONFIG_PM) && defined(CONFIG_HIBERNATION)
 /**
  * e820_mark_nosave_regions - Find the ranges of physical addresses that do not
  * correspond to e820 RAM areas and mark the corresponding pages as nosave for
index d865d04..09cf781 100644 (file)
@@ -82,6 +82,7 @@
 #include <linux/miscdevice.h>
 #include <linux/spinlock.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/mutex.h>
 #include <linux/cpu.h>
 #include <linux/firmware.h>
index e5dcb93..4214730 100644 (file)
@@ -9,6 +9,7 @@
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/smp.h>
 #include <linux/sem.h>
 #include <linux/msg.h>
index 6deb159..4eb2e40 100644 (file)
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/elf.h>
 #include <linux/mm.h>
+#include <linux/err.h>
 #include <linux/module.h>
 
 #include <asm/cpufeature.h>
index c3b9905..730a5b1 100644 (file)
@@ -432,7 +432,7 @@ static void __init pagetable_init (void)
        paravirt_pagetable_setup_done(pgd_base);
 }
 
-#if defined(CONFIG_SOFTWARE_SUSPEND) || defined(CONFIG_ACPI_SLEEP)
+#if defined(CONFIG_HIBERNATION) || defined(CONFIG_ACPI)
 /*
  * Swap suspend & friends need this for resume because things like the intel-agp
  * driver might have split up a kernel 4MB mapping.
@@ -800,9 +800,17 @@ void mark_rodata_ro(void)
        unsigned long start = PFN_ALIGN(_text);
        unsigned long size = PFN_ALIGN(_etext) - start;
 
-       change_page_attr(virt_to_page(start),
-                        size >> PAGE_SHIFT, PAGE_KERNEL_RX);
-       printk("Write protecting the kernel text: %luk\n", size >> 10);
+#ifndef CONFIG_KPROBES
+#ifdef CONFIG_HOTPLUG_CPU
+       /* It must still be possible to apply SMP alternatives. */
+       if (num_possible_cpus() <= 1)
+#endif
+       {
+               change_page_attr(virt_to_page(start),
+                                size >> PAGE_SHIFT, PAGE_KERNEL_RX);
+               printk("Write protecting the kernel text: %luk\n", size >> 10);
+       }
+#endif
        start += size;
        size = (unsigned long)__end_rodata - start;
        change_page_attr(virt_to_page(start),
index 2de7bbf..d764ec9 100644 (file)
@@ -1,2 +1,2 @@
 obj-$(CONFIG_PM)               += cpu.o
-obj-$(CONFIG_SOFTWARE_SUSPEND) += swsusp.o suspend.o
+obj-$(CONFIG_HIBERNATION)      += swsusp.o suspend.o
index 36c7b96..21aa4fc 100644 (file)
@@ -425,6 +425,9 @@ config COMPAT
        depends on IA32_SUPPORT
        default y
 
+config COMPAT_FOR_U64_ALIGNMENT
+       def_bool COMPAT
+
 config IA64_MCA_RECOVERY
        tristate "MCA recovery from errors other than TLB."
 
index cd4adf5..e980e7a 100644 (file)
@@ -2015,9 +2015,14 @@ acpi_sba_ioc_add(struct acpi_device *device)
        return 0;
 }
 
+static const struct acpi_device_id hp_ioc_iommu_device_ids[] = {
+       {"HWP0001", 0},
+       {"HWP0004", 0},
+       {"", 0},
+};
 static struct acpi_driver acpi_sba_ioc_driver = {
        .name           = "IOC IOMMU Driver",
-       .ids            = "HWP0001,HWP0004",
+       .ids            = hp_ioc_iommu_device_ids,
        .ops            = {
                .add    = acpi_sba_ioc_add,
        },
index decdf6e..e62694f 100644 (file)
@@ -101,7 +101,7 @@ simscsi_interrupt (unsigned long val)
 {
        struct scsi_cmnd *sc;
 
-       while ((sc = queue[rd].sc) != 0) {
+       while ((sc = queue[rd].sc) != NULL) {
                atomic_dec(&num_reqs);
                queue[rd].sc = NULL;
                if (DBG)
index e13a1a1..d1d50cd 100644 (file)
@@ -249,11 +249,11 @@ ia32_init (void)
 
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
        {
-               extern struct kmem_cache *partial_page_cachep;
+               extern struct kmem_cache *ia64_partial_page_cachep;
 
-               partial_page_cachep = kmem_cache_create("partial_page_cache",
-                                               sizeof(struct partial_page),
-                                               0, SLAB_PANIC, NULL);
+               ia64_partial_page_cachep = kmem_cache_create("ia64_partial_page_cache",
+                                       sizeof(struct ia64_partial_page),
+                                       0, SLAB_PANIC, NULL);
        }
 #endif
        return 0;
index cfa0bc0..466bbcb 100644 (file)
@@ -25,8 +25,8 @@
  * partially mapped pages provide precise accounting of which 4k sub pages
  * are mapped and which ones are not, thereby improving IA-32 compatibility.
  */
-struct partial_page {
-       struct partial_page     *next; /* linked list, sorted by address */
+struct ia64_partial_page {
+       struct ia64_partial_page *next; /* linked list, sorted by address */
        struct rb_node          pp_rb;
        /* 64K is the largest "normal" page supported by ia64 ABI. So 4K*64
         * should suffice.*/
@@ -34,17 +34,17 @@ struct partial_page {
        unsigned int            base;
 };
 
-struct partial_page_list {
-       struct partial_page     *pp_head; /* list head, points to the lowest
+struct ia64_partial_page_list {
+       struct ia64_partial_page *pp_head; /* list head, points to the lowest
                                           * addressed partial page */
        struct rb_root          ppl_rb;
-       struct partial_page     *pp_hint; /* pp_hint->next is the last
+       struct ia64_partial_page *pp_hint; /* pp_hint->next is the last
                                           * accessed partial page */
        atomic_t                pp_count; /* reference count */
 };
 
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
-struct partial_page_list* ia32_init_pp_list (void);
+struct ia64_partial_page_list* ia32_init_pp_list (void);
 #else
 # define ia32_init_pp_list()   0
 #endif
index 0afb4fe..af10462 100644 (file)
@@ -253,17 +253,17 @@ mmap_subpage (struct file *file, unsigned long start, unsigned long end, int pro
        return ret;
 }
 
-/* SLAB cache for partial_page structures */
-struct kmem_cache *partial_page_cachep;
+/* SLAB cache for ia64_partial_page structures */
+struct kmem_cache *ia64_partial_page_cachep;
 
 /*
- * init partial_page_list.
+ * init ia64_partial_page_list.
  * return 0 means kmalloc fail.
  */
-struct partial_page_list*
+struct ia64_partial_page_list*
 ia32_init_pp_list(void)
 {
-       struct partial_page_list *p;
+       struct ia64_partial_page_list *p;
 
        if ((p = kmalloc(sizeof(*p), GFP_KERNEL)) == NULL)
                return p;
@@ -280,12 +280,12 @@ ia32_init_pp_list(void)
  * Else, return 0 and provide @pprev, @rb_link, @rb_parent to
  * be used by later __ia32_insert_pp().
  */
-static struct partial_page *
-__ia32_find_pp(struct partial_page_list *ppl, unsigned int start,
-       struct partial_page **pprev, struct rb_node ***rb_link,
+static struct ia64_partial_page *
+__ia32_find_pp(struct ia64_partial_page_list *ppl, unsigned int start,
+       struct ia64_partial_page **pprev, struct rb_node ***rb_link,
        struct rb_node **rb_parent)
 {
-       struct partial_page *pp;
+       struct ia64_partial_page *pp;
        struct rb_node **__rb_link, *__rb_parent, *rb_prev;
 
        pp = ppl->pp_hint;
@@ -297,7 +297,7 @@ __ia32_find_pp(struct partial_page_list *ppl, unsigned int start,
 
        while (*__rb_link) {
                __rb_parent = *__rb_link;
-               pp = rb_entry(__rb_parent, struct partial_page, pp_rb);
+               pp = rb_entry(__rb_parent, struct ia64_partial_page, pp_rb);
 
                if (pp->base == start) {
                        ppl->pp_hint = pp;
@@ -314,7 +314,7 @@ __ia32_find_pp(struct partial_page_list *ppl, unsigned int start,
        *rb_parent = __rb_parent;
        *pprev = NULL;
        if (rb_prev)
-               *pprev = rb_entry(rb_prev, struct partial_page, pp_rb);
+               *pprev = rb_entry(rb_prev, struct ia64_partial_page, pp_rb);
        return NULL;
 }
 
@@ -322,9 +322,9 @@ __ia32_find_pp(struct partial_page_list *ppl, unsigned int start,
  * insert @pp into @ppl.
  */
 static void
-__ia32_insert_pp(struct partial_page_list *ppl, struct partial_page *pp,
-        struct partial_page *prev, struct rb_node **rb_link,
-       struct rb_node *rb_parent)
+__ia32_insert_pp(struct ia64_partial_page_list *ppl,
+       struct ia64_partial_page *pp, struct ia64_partial_page *prev,
+       struct rb_node **rb_link, struct rb_node *rb_parent)
 {
        /* link list */
        if (prev) {
@@ -334,7 +334,7 @@ __ia32_insert_pp(struct partial_page_list *ppl, struct partial_page *pp,
                ppl->pp_head = pp;
                if (rb_parent)
                        pp->next = rb_entry(rb_parent,
-                               struct partial_page, pp_rb);
+                               struct ia64_partial_page, pp_rb);
                else
                        pp->next = NULL;
        }
@@ -350,8 +350,8 @@ __ia32_insert_pp(struct partial_page_list *ppl, struct partial_page *pp,
  * delete @pp from partial page list @ppl.
  */
 static void
-__ia32_delete_pp(struct partial_page_list *ppl, struct partial_page *pp,
-       struct partial_page *prev)
+__ia32_delete_pp(struct ia64_partial_page_list *ppl,
+       struct ia64_partial_page *pp, struct ia64_partial_page *prev)
 {
        if (prev) {
                prev->next = pp->next;
@@ -363,15 +363,15 @@ __ia32_delete_pp(struct partial_page_list *ppl, struct partial_page *pp,
                        ppl->pp_hint = pp->next;
        }
        rb_erase(&pp->pp_rb, &ppl->ppl_rb);
-       kmem_cache_free(partial_page_cachep, pp);
+       kmem_cache_free(ia64_partial_page_cachep, pp);
 }
 
-static struct partial_page *
-__pp_prev(struct partial_page *pp)
+static struct ia64_partial_page *
+__pp_prev(struct ia64_partial_page *pp)
 {
        struct rb_node *prev = rb_prev(&pp->pp_rb);
        if (prev)
-               return rb_entry(prev, struct partial_page, pp_rb);
+               return rb_entry(prev, struct ia64_partial_page, pp_rb);
        else
                return NULL;
 }
@@ -383,7 +383,7 @@ __pp_prev(struct partial_page *pp)
 static void
 __ia32_delete_pp_range(unsigned int start, unsigned int end)
 {
-       struct partial_page *pp, *prev;
+       struct ia64_partial_page *pp, *prev;
        struct rb_node **rb_link, *rb_parent;
 
        if (start >= end)
@@ -401,7 +401,7 @@ __ia32_delete_pp_range(unsigned int start, unsigned int end)
        }
 
        while (pp && pp->base < end) {
-               struct partial_page *tmp = pp->next;
+               struct ia64_partial_page *tmp = pp->next;
                __ia32_delete_pp(current->thread.ppl, pp, prev);
                pp = tmp;
        }
@@ -414,7 +414,7 @@ __ia32_delete_pp_range(unsigned int start, unsigned int end)
 static int
 __ia32_set_pp(unsigned int start, unsigned int end, int flags)
 {
-       struct partial_page *pp, *prev;
+       struct ia64_partial_page *pp, *prev;
        struct rb_node ** rb_link, *rb_parent;
        unsigned int pstart, start_bit, end_bit, i;
 
@@ -450,8 +450,8 @@ __ia32_set_pp(unsigned int start, unsigned int end, int flags)
                        return 0;
        }
 
-       /* new a partial_page */
-       pp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
+       /* new a ia64_partial_page */
+       pp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
        if (!pp)
                return -ENOMEM;
        pp->base = pstart;
@@ -504,7 +504,7 @@ ia32_set_pp(unsigned int start, unsigned int end, int flags)
 static int
 __ia32_unset_pp(unsigned int start, unsigned int end)
 {
-       struct partial_page *pp, *prev;
+       struct ia64_partial_page *pp, *prev;
        struct rb_node ** rb_link, *rb_parent;
        unsigned int pstart, start_bit, end_bit, i;
        struct vm_area_struct *vma;
@@ -532,8 +532,8 @@ __ia32_unset_pp(unsigned int start, unsigned int end)
                return -ENOMEM;
        }
 
-       /* new a partial_page */
-       pp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
+       /* new a ia64_partial_page */
+       pp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
        if (!pp)
                return -ENOMEM;
        pp->base = pstart;
@@ -605,7 +605,7 @@ ia32_unset_pp(unsigned int *startp, unsigned int *endp)
 static int
 __ia32_compare_pp(unsigned int start, unsigned int end)
 {
-       struct partial_page *pp, *prev;
+       struct ia64_partial_page *pp, *prev;
        struct rb_node ** rb_link, *rb_parent;
        unsigned int pstart, start_bit, end_bit, size;
        unsigned int first_bit, next_zero_bit;  /* the first range in bitmap */
@@ -682,13 +682,13 @@ ia32_compare_pp(unsigned int *startp, unsigned int *endp)
 }
 
 static void
-__ia32_drop_pp_list(struct partial_page_list *ppl)
+__ia32_drop_pp_list(struct ia64_partial_page_list *ppl)
 {
-       struct partial_page *pp = ppl->pp_head;
+       struct ia64_partial_page *pp = ppl->pp_head;
 
        while (pp) {
-               struct partial_page *next = pp->next;
-               kmem_cache_free(partial_page_cachep, pp);
+               struct ia64_partial_page *next = pp->next;
+               kmem_cache_free(ia64_partial_page_cachep, pp);
                pp = next;
        }
 
@@ -696,9 +696,9 @@ __ia32_drop_pp_list(struct partial_page_list *ppl)
 }
 
 void
-ia32_drop_partial_page_list(struct task_struct *task)
+ia32_drop_ia64_partial_page_list(struct task_struct *task)
 {
-       struct partial_page_list* ppl = task->thread.ppl;
+       struct ia64_partial_page_list* ppl = task->thread.ppl;
 
        if (ppl && atomic_dec_and_test(&ppl->pp_count))
                __ia32_drop_pp_list(ppl);
@@ -708,9 +708,9 @@ ia32_drop_partial_page_list(struct task_struct *task)
  * Copy current->thread.ppl to ppl (already initialized).
  */
 static int
-__ia32_copy_pp_list(struct partial_page_list *ppl)
+__ia32_copy_pp_list(struct ia64_partial_page_list *ppl)
 {
-       struct partial_page *pp, *tmp, *prev;
+       struct ia64_partial_page *pp, *tmp, *prev;
        struct rb_node **rb_link, *rb_parent;
 
        ppl->pp_head = NULL;
@@ -721,7 +721,7 @@ __ia32_copy_pp_list(struct partial_page_list *ppl)
        prev = NULL;
 
        for (pp = current->thread.ppl->pp_head; pp; pp = pp->next) {
-               tmp = kmem_cache_alloc(partial_page_cachep, GFP_KERNEL);
+               tmp = kmem_cache_alloc(ia64_partial_page_cachep, GFP_KERNEL);
                if (!tmp)
                        return -ENOMEM;
                *tmp = *pp;
@@ -734,7 +734,8 @@ __ia32_copy_pp_list(struct partial_page_list *ppl)
 }
 
 int
-ia32_copy_partial_page_list(struct task_struct *p, unsigned long clone_flags)
+ia32_copy_ia64_partial_page_list(struct task_struct *p,
+                               unsigned long clone_flags)
 {
        int retval = 0;
 
index 103dd8e..3d45d24 100644 (file)
@@ -67,6 +67,8 @@ EXPORT_SYMBOL(pm_power_off);
 unsigned int acpi_cpei_override;
 unsigned int acpi_cpei_phys_cpuid;
 
+unsigned long acpi_wakeup_address = 0;
+
 const char __init *
 acpi_get_sysname(void)
 {
@@ -739,16 +741,15 @@ int __init acpi_boot_init(void)
 
 int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
 {
-       int vector;
+       int tmp;
 
        if (has_8259 && gsi < 16)
                *irq = isa_irq_to_vector(gsi);
        else {
-               vector = gsi_to_vector(gsi);
-               if (vector == -1)
+               tmp = gsi_to_irq(gsi);
+               if (tmp == -1)
                        return -1;
-
-               *irq = vector;
+               *irq = tmp;
        }
        return 0;
 }
@@ -986,4 +987,21 @@ int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
 
 EXPORT_SYMBOL(acpi_unregister_ioapic);
 
+/*
+ * acpi_save_state_mem() - save kernel state
+ *
+ * TBD when when IA64 starts to support suspend...
+ */
+int acpi_save_state_mem(void) { return 0; } 
+
+/*
+ * acpi_restore_state()
+ */
+void acpi_restore_state_mem(void) {}
+
+/*
+ * do_suspend_lowlevel()
+ */
+void do_suspend_lowlevel(void) {}
+
 #endif                         /* CONFIG_ACPI */
index 2fd96d9..790ef0d 100644 (file)
@@ -38,11 +38,11 @@ static struct clocksource clocksource_cyclone = {
 
 int __init init_cyclone_clock(void)
 {
-       u64* reg;
+       u64 __iomem *reg;
        u64 base;       /* saved cyclone base address */
        u64 offset;     /* offset from pageaddr to cyclone_timer register */
        int i;
-       u32* volatile cyclone_timer;    /* Cyclone MPMC0 register */
+       u32 __iomem *cyclone_timer;     /* Cyclone MPMC0 register */
 
        if (!use_cyclone)
                return 0;
@@ -51,7 +51,7 @@ int __init init_cyclone_clock(void)
 
        /* find base address */
        offset = (CYCLONE_CBAR_ADDR);
-       reg = (u64*)ioremap_nocache(offset, sizeof(u64));
+       reg = ioremap_nocache(offset, sizeof(u64));
        if(!reg){
                printk(KERN_ERR "Summit chipset: Could not find valid CBAR"
                                " register.\n");
@@ -69,7 +69,7 @@ int __init init_cyclone_clock(void)
 
        /* setup PMCC */
        offset = (base + CYCLONE_PMCC_OFFSET);
-       reg = (u64*)ioremap_nocache(offset, sizeof(u64));
+       reg = ioremap_nocache(offset, sizeof(u64));
        if(!reg){
                printk(KERN_ERR "Summit chipset: Could not find valid PMCC"
                                " register.\n");
@@ -81,7 +81,7 @@ int __init init_cyclone_clock(void)
 
        /* setup MPCS */
        offset = (base + CYCLONE_MPCS_OFFSET);
-       reg = (u64*)ioremap_nocache(offset, sizeof(u64));
+       reg = ioremap_nocache(offset, sizeof(u64));
        if(!reg){
                printk(KERN_ERR "Summit chipset: Could not find valid MPCS"
                                " register.\n");
@@ -93,7 +93,7 @@ int __init init_cyclone_clock(void)
 
        /* map in cyclone_timer */
        offset = (base + CYCLONE_MPMC_OFFSET);
-       cyclone_timer = (u32*)ioremap_nocache(offset, sizeof(u32));
+       cyclone_timer = ioremap_nocache(offset, sizeof(u32));
        if(!cyclone_timer){
                printk(KERN_ERR "Summit chipset: Could not find valid MPMC"
                                " register.\n");
@@ -110,7 +110,7 @@ int __init init_cyclone_clock(void)
                        printk(KERN_ERR "Summit chipset: Counter not counting!"
                                        " DISABLED\n");
                        iounmap(cyclone_timer);
-                       cyclone_timer = 0;
+                       cyclone_timer = NULL;
                        use_cyclone = 0;
                        return -ENODEV;
                }
index 44d540e..4e5e275 100644 (file)
@@ -178,7 +178,7 @@ swapper_pg_dir:
 halt_msg:
        stringz "Halting kernel\n"
 
-       .text
+       .section .text.head,"ax"
 
        .global start_ap
 
@@ -392,6 +392,8 @@ self:       hint @pause
        br.sptk.many self               // endless loop
 END(_start)
 
+       .text
+
 GLOBAL_ENTRY(ia64_save_debug_regs)
        alloc r16=ar.pfs,1,0,0,0
        mov r20=ar.lc                   // preserve ar.lc
index b69c397..bc8efca 100644 (file)
@@ -8,6 +8,7 @@
 
 #include <linux/init.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/init_task.h>
index 91797c1..9386b95 100644 (file)
@@ -85,8 +85,8 @@ DEFINE_PER_CPU(int[IA64_NUM_VECTORS], vector_irq) = {
        [0 ... IA64_NUM_VECTORS - 1] = IA64_SPURIOUS_INT_VECTOR
 };
 
-static cpumask_t vector_table[IA64_MAX_DEVICE_VECTORS] = {
-       [0 ... IA64_MAX_DEVICE_VECTORS - 1] = CPU_MASK_NONE
+static cpumask_t vector_table[IA64_NUM_VECTORS] = {
+       [0 ... IA64_NUM_VECTORS - 1] = CPU_MASK_NONE
 };
 
 static int irq_status[NR_IRQS] = {
@@ -123,17 +123,18 @@ static inline int find_unassigned_irq(void)
 static inline int find_unassigned_vector(cpumask_t domain)
 {
        cpumask_t mask;
-       int pos;
+       int pos, vector;
 
        cpus_and(mask, domain, cpu_online_map);
        if (cpus_empty(mask))
                return -EINVAL;
 
        for (pos = 0; pos < IA64_NUM_DEVICE_VECTORS; pos++) {
-               cpus_and(mask, domain, vector_table[pos]);
+               vector = IA64_FIRST_DEVICE_VECTOR + pos;
+               cpus_and(mask, domain, vector_table[vector]);
                if (!cpus_empty(mask))
                        continue;
-               return IA64_FIRST_DEVICE_VECTOR + pos;
+               return vector;
        }
        return -ENOSPC;
 }
@@ -141,9 +142,12 @@ static inline int find_unassigned_vector(cpumask_t domain)
 static int __bind_irq_vector(int irq, int vector, cpumask_t domain)
 {
        cpumask_t mask;
-       int cpu, pos;
+       int cpu;
        struct irq_cfg *cfg = &irq_cfg[irq];
 
+       BUG_ON((unsigned)irq >= NR_IRQS);
+       BUG_ON((unsigned)vector >= IA64_NUM_VECTORS);
+
        cpus_and(mask, domain, cpu_online_map);
        if (cpus_empty(mask))
                return -EINVAL;
@@ -156,8 +160,7 @@ static int __bind_irq_vector(int irq, int vector, cpumask_t domain)
        cfg->vector = vector;
        cfg->domain = domain;
        irq_status[irq] = IRQ_USED;
-       pos = vector - IA64_FIRST_DEVICE_VECTOR;
-       cpus_or(vector_table[pos], vector_table[pos], domain);
+       cpus_or(vector_table[vector], vector_table[vector], domain);
        return 0;
 }
 
@@ -174,7 +177,7 @@ int bind_irq_vector(int irq, int vector, cpumask_t domain)
 
 static void __clear_irq_vector(int irq)
 {
-       int vector, cpu, pos;
+       int vector, cpu;
        cpumask_t mask;
        cpumask_t domain;
        struct irq_cfg *cfg = &irq_cfg[irq];
@@ -189,8 +192,7 @@ static void __clear_irq_vector(int irq)
        cfg->vector = IRQ_VECTOR_UNASSIGNED;
        cfg->domain = CPU_MASK_NONE;
        irq_status[irq] = IRQ_UNUSED;
-       pos = vector - IA64_FIRST_DEVICE_VECTOR;
-       cpus_andnot(vector_table[pos], vector_table[pos], domain);
+       cpus_andnot(vector_table[vector], vector_table[vector], domain);
 }
 
 static void clear_irq_vector(int irq)
@@ -212,9 +214,6 @@ assign_irq_vector (int irq)
        vector = -ENOSPC;
 
        spin_lock_irqsave(&vector_lock, flags);
-       if (irq < 0) {
-               goto out;
-       }
        for_each_online_cpu(cpu) {
                domain = vector_allocation_domain(cpu);
                vector = find_unassigned_vector(domain);
@@ -223,6 +222,8 @@ assign_irq_vector (int irq)
        }
        if (vector < 0)
                goto out;
+       if (irq == AUTO_ASSIGN)
+               irq = vector;
        BUG_ON(__bind_irq_vector(irq, vector, domain));
  out:
        spin_unlock_irqrestore(&vector_lock, flags);
@@ -288,7 +289,7 @@ static int __init parse_vector_domain(char *arg)
                vector_domain_type = VECTOR_DOMAIN_PERCPU;
                no_int_routing = 1;
        }
-       return 1;
+       return 0;
 }
 early_param("vector", parse_vector_domain);
 #else
index 13df337..7ccb228 100644 (file)
 struct ia64_machine_vector ia64_mv;
 EXPORT_SYMBOL(ia64_mv);
 
-static __initdata const char *mvec_name;
-static __init int setup_mvec(char *s)
-{
-       mvec_name = s;
-       return 0;
-}
-early_param("machvec", setup_mvec);
-
 static struct ia64_machine_vector * __init
 lookup_machvec (const char *name)
 {
@@ -41,7 +33,7 @@ machvec_init (const char *name)
        struct ia64_machine_vector *mv;
 
        if (!name)
-               name = mvec_name ? mvec_name : acpi_get_sysname();
+               name = acpi_get_sysname();
        mv = lookup_machvec(name);
        if (!mv)
                panic("generic kernel failed to find machine vector for"
@@ -51,6 +43,23 @@ machvec_init (const char *name)
        printk(KERN_INFO "booting generic kernel on platform %s\n", name);
 }
 
+void __init
+machvec_init_from_cmdline(const char *cmdline)
+{
+       char str[64];
+       const char *start;
+       char *end;
+
+       if (! (start = strstr(cmdline, "machvec=")) )
+               return machvec_init(NULL);
+
+       strlcpy(str, start + strlen("machvec="), sizeof(str));
+       if ( (end = strchr(str, ' ')) )
+               *end = '\0';
+
+       return machvec_init(str);
+}
+
 #endif /* CONFIG_IA64_GENERIC */
 
 void
index fa40cba..4158906 100644 (file)
@@ -499,7 +499,8 @@ copy_thread (int nr, unsigned long clone_flags,
 
                /* Copy partially mapped page list */
                if (!retval)
-                       retval = ia32_copy_partial_page_list(p, clone_flags);
+                       retval = ia32_copy_ia64_partial_page_list(p,
+                                                               clone_flags);
        }
 #endif
 
@@ -728,7 +729,7 @@ flush_thread (void)
        ia64_drop_fpu(current);
 #ifdef CONFIG_IA32_SUPPORT
        if (IS_IA32_PROCESS(task_pt_regs(current))) {
-               ia32_drop_partial_page_list(current);
+               ia32_drop_ia64_partial_page_list(current);
                current->thread.task_size = IA32_PAGE_OFFSET;
                set_fs(USER_DS);
        }
@@ -754,7 +755,7 @@ exit_thread (void)
                pfm_release_debug_registers(current);
 #endif
        if (IS_IA32_PROCESS(task_pt_regs(current)))
-               ia32_drop_partial_page_list(current);
+               ia32_drop_ia64_partial_page_list(current);
 }
 
 unsigned long
index cf06fe7..7cecd29 100644 (file)
@@ -491,12 +491,17 @@ setup_arch (char **cmdline_p)
        efi_init();
        io_port_init();
 
-       parse_early_param();
-
 #ifdef CONFIG_IA64_GENERIC
-       machvec_init(NULL);
+       /* machvec needs to be parsed from the command line
+        * before parse_early_param() is called to ensure
+        * that ia64_mv is initialised before any command line
+        * settings may cause console setup to occur
+        */
+       machvec_init_from_cmdline(*cmdline_p);
 #endif
 
+       parse_early_param();
+
        if (early_console_setup(*cmdline_p) == 0)
                mark_bsp_online();
 
index 9f72838..0982882 100644 (file)
@@ -468,7 +468,7 @@ smp_send_stop (void)
        send_IPI_allbutself(IPI_CPU_STOP);
 }
 
-int __init
+int
 setup_profiling_timer (unsigned int multiplier)
 {
        return -EINVAL;
index 9f5c90b..62209dc 100644 (file)
@@ -487,7 +487,7 @@ struct create_idle {
        int cpu;
 };
 
-void
+void __cpuinit
 do_fork_idle(struct work_struct *work)
 {
        struct create_idle *c_idle =
@@ -497,7 +497,7 @@ do_fork_idle(struct work_struct *work)
        complete(&c_idle->done);
 }
 
-static int __devinit
+static int __cpuinit
 do_boot_cpu (int sapicid, int cpu)
 {
        int timeout;
@@ -808,7 +808,7 @@ set_cpu_sibling_map(int cpu)
        }
 }
 
-int __devinit
+int __cpuinit
 __cpu_up (unsigned int cpu)
 {
        int ret;
index 627785c..6c0e9e2 100644 (file)
@@ -52,7 +52,7 @@ static struct clocksource clocksource_itc = {
         .name           = "itc",
         .rating         = 350,
         .read           = itc_get_cycles,
-        .mask           = 0xffffffffffffffff,
+        .mask           = CLOCKSOURCE_MASK(64),
         .mult           = 0, /*to be caluclated*/
         .shift          = 16,
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
@@ -255,7 +255,7 @@ ia64_init_itm (void)
        }
 }
 
-static cycle_t itc_get_cycles()
+static cycle_t itc_get_cycles(void)
 {
        u64 lcycle, now, ret;
 
index 860f251..83e8067 100644 (file)
@@ -50,6 +50,8 @@ SECTIONS
        KPROBES_TEXT
        *(.gnu.linkonce.t*)
     }
+  .text.head : AT(ADDR(.text.head) - LOAD_OFFSET)
+       { *(.text.head) }
   .text2 : AT(ADDR(.text2) - LOAD_OFFSET)
        { *(.text2) }
 #ifdef CONFIG_SMP
index 07d0e92..488e48a 100644 (file)
@@ -581,7 +581,7 @@ pcibios_align_resource (void *data, struct resource *res,
 /*
  * PCI BIOS setup, always defaults to SAL interface
  */
-char * __init
+char * __devinit
 pcibios_setup (char *str)
 {
        return str;
index 6b2d77d..fe73c9e 100644 (file)
@@ -45,7 +45,8 @@ static void mask_and_ack_mappi(unsigned int irq)
 
 static void end_mappi_irq(unsigned int irq)
 {
-       enable_mappi_irq(irq);
+       if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)))
+               enable_mappi_irq(irq);
 }
 
 static unsigned int startup_mappi_irq(unsigned int irq)
@@ -88,7 +89,7 @@ void __init init_IRQ(void)
        irq_desc[M32R_IRQ_INT0].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_INT0].action = NULL;
        irq_desc[M32R_IRQ_INT0].depth = 1;
-       icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
+       icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD11;
        disable_mappi_irq(M32R_IRQ_INT0);
 #endif /* CONFIG_M32R_NE2000 */
 
index 99fc122..3ee9186 100644 (file)
@@ -15,6 +15,7 @@
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/stddef.h>
index 90238a8..36d78cf 100644 (file)
@@ -10,6 +10,7 @@
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/sem.h>
index 1175cef..185906b 100644 (file)
@@ -216,6 +216,18 @@ config XCOPILOT_BUGS
        help
          Support the bugs of Xcopilot.
 
+config UC5272
+        bool 'Arcturus Networks uC5272 dimm board support'
+        depends on M5272
+        help
+          Support for the Arcturus Networks uC5272 dimm board.
+
+config UC5282
+       bool "Arcturus Networks uC5282 board support"
+          depends on M528x
+       help
+          Support for the Arcturus Networks uC5282 dimm board.
+
 config UCSIMM
        bool "uCsimm module support"
        depends on M68EZ328
@@ -342,6 +354,18 @@ config SOM5282EM
        depends on M528x
        help
          Support for the EMAC.Inc SOM5282EM module.  
+         
+config WILDFIRE
+       bool "Intec Automation Inc. WildFire board support"
+       depends on M528x
+       help
+         Support for the Intec Automation Inc. WildFire.
+         
+config WILDFIREMOD
+       bool "Intec Automation Inc. WildFire module support"
+       depends on M528x
+       help
+         Support for the Intec Automation Inc. WildFire module.
 
 config ARN5307
        bool "Arnewsh 5307 board support"
index 8951793..1305cc9 100644 (file)
@@ -26,6 +26,8 @@ platform-$(CONFIG_M5407)      := 5407
 PLATFORM := $(platform-y)
 
 board-$(CONFIG_PILOT)          := pilot
+board-$(CONFIG_UC5272)          := UC5272
+board-$(CONFIG_UC5282)          := UC5282
 board-$(CONFIG_UCSIMM)         := ucsimm
 board-$(CONFIG_UCDIMM)         := ucdimm
 board-$(CONFIG_UCQUICC)                := uCquicc
index 0a25874..e10eafc 100644 (file)
@@ -8,6 +8,7 @@
 #include <linux/types.h>
 #include <linux/mm.h>
 #include <linux/string.h>
+#include <linux/device.h>
 #include <asm/io.h>
 
 void *dma_alloc_coherent(struct device *dev, size_t size,
index 2203f69..3f86ade 100644 (file)
@@ -42,8 +42,6 @@ EXPORT_SYMBOL(memory_end);
 
 char __initdata command_line[COMMAND_LINE_SIZE];
 
-void (*mach_trap_init)(void);
-
 /* machine dependent timer functions */
 void (*mach_sched_init)(irq_handler_t handler);
 void (*mach_tick)(void);
@@ -132,6 +130,11 @@ void setup_arch(char **cmdline_p)
 
        config_BSP(&command_line[0], sizeof(command_line));
 
+#if defined(CONFIG_BOOTPARAM)
+       strncpy(&command_line[0], CONFIG_BOOTPARAM_STRING, sizeof(command_line));
+       command_line[sizeof(command_line) - 1] = 0;
+#endif
+
        printk(KERN_INFO "\x0F\r\n\nuClinux/" CPU "\n");
 
 #ifdef CONFIG_UCDIMM
index 3343830..d0f2dc5 100644 (file)
@@ -28,7 +28,6 @@
 void coldfire_tick(void);
 void coldfire_timer_init(irq_handler_t handler);
 unsigned long coldfire_timer_offset(void);
-void coldfire_trap_init(void);
 void coldfire_reset(void);
 
 /***************************************************************************/
@@ -98,18 +97,9 @@ int mcf_timerirqpending(int timer)
 void config_BSP(char *commandp, int size)
 {
        mcf_setimr(MCFSIM_IMR_MASKALL);
-
-#if defined(CONFIG_BOOTPARAM)
-       strncpy(commandp, CONFIG_BOOTPARAM_STRING, size);
-       commandp[size-1] = 0;
-#else
-       memset(commandp, 0, size);
-#endif
-
        mach_sched_init = coldfire_timer_init;
        mach_tick = coldfire_tick;
        mach_gettimeoffset = coldfire_timer_offset;
-       mach_trap_init = coldfire_trap_init;
        mach_reset = coldfire_reset;
 }
 
index 0f67320..4ab614f 100644 (file)
@@ -27,7 +27,6 @@
 void coldfire_tick(void);
 void coldfire_timer_init(irq_handler_t handler);
 unsigned long coldfire_timer_offset(void);
-void coldfire_trap_init(void);
 void coldfire_reset(void);
 
 /***************************************************************************/
@@ -98,21 +97,15 @@ void config_BSP(char *commandp, int size)
 {
        mcf_setimr(MCFSIM_IMR_MASKALL);
 
-#if defined(CONFIG_BOOTPARAM)
-       strncpy(commandp, CONFIG_BOOTPARAM_STRING, size);
-       commandp[size-1] = 0;
-#elif defined(CONFIG_NETtel)
+#if defined(CONFIG_NETtel)
        /* Copy command line from FLASH to local buffer... */
        memcpy(commandp, (char *) 0xf0004000, size);
        commandp[size-1] = 0;
-#else
-       memset(commandp, 0, size);
 #endif /* CONFIG_NETtel */
 
        mach_sched_init = coldfire_timer_init;
        mach_tick = coldfire_tick;
        mach_gettimeoffset = coldfire_timer_offset;
-       mach_trap_init = coldfire_trap_init;
        mach_reset = coldfire_reset;
 }
 
index 58b2878..a2c95be 100644 (file)
@@ -30,7 +30,6 @@ unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
 void coldfire_pit_tick(void);
 void coldfire_pit_init(irq_handler_t handler);
 unsigned long coldfire_pit_offset(void);
-void coldfire_trap_init(void);
 void coldfire_reset(void);
 
 /***************************************************************************/
@@ -48,17 +47,9 @@ void mcf_autovector(unsigned int vec)
 
 void config_BSP(char *commandp, int size)
 {
-#ifdef CONFIG_BOOTPARAM
-    strncpy(commandp, CONFIG_BOOTPARAM_STRING, size);
-    commandp[size-1] = 0;
-#else
-    memset(commandp, 0, size);
-#endif
-
     mach_sched_init = coldfire_pit_init;
     mach_tick = coldfire_pit_tick;
     mach_gettimeoffset = coldfire_pit_offset;
-    mach_trap_init = coldfire_trap_init;
     mach_reset = coldfire_reset;
 }
 
index 9b054e6..0a3af05 100644 (file)
@@ -29,7 +29,6 @@
 void coldfire_pit_tick(void);
 void coldfire_pit_init(irq_handler_t handler);
 unsigned long coldfire_pit_offset(void);
-void coldfire_trap_init(void);
 void coldfire_reset(void);
 
 /***************************************************************************/
@@ -63,18 +62,9 @@ void mcf_autovector(unsigned int vec)
 void config_BSP(char *commandp, int size)
 {
        mcf_disableall();
-
-#ifdef CONFIG_BOOTPARAM
-       strncpy(commandp, CONFIG_BOOTPARAM_STRING, size);
-       commandp[size-1] = 0;
-#else
-       memset(commandp, 0, size);
-#endif
-
        mach_sched_init = coldfire_pit_init;
        mach_tick = coldfire_pit_tick;
        mach_gettimeoffset = coldfire_pit_offset;
-       mach_trap_init = coldfire_trap_init;
        mach_reset = coldfire_reset;
 }
 
index d670607..dc2c362 100644 (file)
@@ -27,7 +27,6 @@
 void coldfire_tick(void);
 void coldfire_timer_init(irq_handler_t handler);
 unsigned long coldfire_timer_offset(void);
-void coldfire_trap_init(void);
 void coldfire_reset(void);
 
 /***************************************************************************/
@@ -96,18 +95,9 @@ int mcf_timerirqpending(int timer)
 void config_BSP(char *commandp, int size)
 {
        mcf_setimr(MCFSIM_IMR_MASKALL);
-
-#if defined(CONFIG_BOOTPARAM)
-       strncpy(commandp, CONFIG_BOOTPARAM_STRING, size);
-       commandp[size-1] = 0;
-#else
-       memset(commandp, 0, size);
-#endif
-
        mach_sched_init = coldfire_timer_init;
        mach_tick = coldfire_tick;
        mach_gettimeoffset = coldfire_timer_offset;
-       mach_trap_init = coldfire_trap_init;
        mach_reset = coldfire_reset;
 }
 
index 6b437cc..1365a83 100644 (file)
@@ -28,7 +28,6 @@
 void coldfire_tick(void);
 void coldfire_timer_init(irq_handler_t handler);
 unsigned long coldfire_timer_offset(void);
-void coldfire_trap_init(void);
 void coldfire_reset(void);
 
 extern unsigned int mcf_timervector;
@@ -113,10 +112,7 @@ void config_BSP(char *commandp, int size)
 
        mcf_disableall();
 
-#if defined(CONFIG_BOOTPARAM)
-       strncpy(commandp, CONFIG_BOOTPARAM_STRING, size);
-       commandp[size-1] = 0;
-#elif defined(CONFIG_NETtel) || defined(CONFIG_SCALES)
+#if defined(CONFIG_NETtel) || defined(CONFIG_SCALES)
        /* Copy command line from FLASH to local buffer... */
        memcpy(commandp, (char *) 0xf0004000, size);
        commandp[size-1] = 0;
@@ -128,8 +124,6 @@ void config_BSP(char *commandp, int size)
        /* Copy command line from FLASH to local buffer... */
        memcpy(commandp, (char *) 0xf0010000, size);
        commandp[size-1] = 0;
-#else
-       memset(commandp, 0, size);
 #endif
 
        mcf_timervector = 69;
@@ -137,7 +131,6 @@ void config_BSP(char *commandp, int size)
        mach_sched_init = coldfire_timer_init;
        mach_tick = coldfire_tick;
        mach_gettimeoffset = coldfire_timer_offset;
-       mach_trap_init = coldfire_trap_init;
        mach_reset = coldfire_reset;
 }