ia64/xen-unstable

changeset 9476:d75a6cc5e68a

merge with xen-unstable.hg
author awilliam@xenbuild.aw
date Tue Mar 28 08:54:58 2006 -0700 (2006-03-28)
parents 7e3cbc409676 4109c4e7804a
children b579cf0ad753
files extras/mini-os/xenbus/Makefile extras/mini-os/xenbus/xenbus_comms.c extras/mini-os/xenbus/xenbus_comms.h extras/mini-os/xenbus/xenbus_xs.c
line diff
     1.1 --- a/.hgtags	Mon Mar 27 15:36:47 2006 -0700
     1.2 +++ b/.hgtags	Tue Mar 28 08:54:58 2006 -0700
     1.3 @@ -13,3 +13,4 @@ 9afec5bc14aeb197ef37ea54a57eacd427463fc3
     1.4  30c521db4c71960b0cf1d9c9e1b658e77b535a3e split-1.0
     1.5  3d330e41f41ce1bc118c02346e18949ad5d67f6b split-1.1
     1.6  c8fdb0caa77b429cf47f9707926e83947778cb48 RELEASE-3.0.0
     1.7 +af0573e9e5258db0a9d28aa954dd302ddd2c2d23 3.0.2-rc
     2.1 --- a/Makefile	Mon Mar 27 15:36:47 2006 -0700
     2.2 +++ b/Makefile	Tue Mar 28 08:54:58 2006 -0700
     2.3 @@ -2,7 +2,7 @@
     2.4  # Grand Unified Makefile for Xen.
     2.5  #
     2.6  
     2.7 -KERNELS ?= linux-2.6-xen0 linux-2.6-xenU
     2.8 +KERNELS ?= linux-2.6-xen
     2.9  # You may use wildcards in the above e.g. KERNELS=*2.6*
    2.10  
    2.11  XKERNELS := $(foreach kernel, $(KERNELS), $(patsubst buildconfigs/mk.%,%,$(wildcard buildconfigs/mk.$(kernel))) )
     3.1 --- a/buildconfigs/linux-defconfig_xen0_ia64	Mon Mar 27 15:36:47 2006 -0700
     3.2 +++ b/buildconfigs/linux-defconfig_xen0_ia64	Tue Mar 28 08:54:58 2006 -0700
     3.3 @@ -1,7 +1,7 @@
     3.4  #
     3.5  # Automatically generated make config: don't edit
     3.6 -# Linux kernel version: 2.6.16-rc3-xen0
     3.7 -# Thu Feb 16 13:20:46 2006
     3.8 +# Linux kernel version: 2.6.16-xen0
     3.9 +# Mon Mar 27 14:46:03 2006
    3.10  #
    3.11  
    3.12  #
    3.13 @@ -95,8 +95,7 @@ CONFIG_ARCH_XEN=y
    3.14  CONFIG_XEN_PRIVILEGED_GUEST=y
    3.15  CONFIG_XEN_BLKDEV_GRANT=y
    3.16  CONFIG_XEN_BLKDEV_FRONTEND=y
    3.17 -CONFIG_XEN_VT=y
    3.18 -CONFIG_VT=y
    3.19 +CONFIG_XEN_BLKDEV_BACKEND=y
    3.20  CONFIG_XEN_SYSFS=y
    3.21  CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
    3.22  CONFIG_DMA_IS_DMA32=y
    3.23 @@ -378,7 +377,7 @@ CONFIG_BLK_DEV_IDESCSI=y
    3.24  #
    3.25  # IDE chipset support/bugfixes
    3.26  #
    3.27 -CONFIG_IDE_GENERIC=y
    3.28 +# CONFIG_IDE_GENERIC is not set
    3.29  CONFIG_BLK_DEV_IDEPCI=y
    3.30  # CONFIG_IDEPCI_SHARE_IRQ is not set
    3.31  # CONFIG_BLK_DEV_OFFBOARD is not set
    3.32 @@ -706,6 +705,7 @@ CONFIG_GAMEPORT=y
    3.33  #
    3.34  # Character devices
    3.35  #
    3.36 +CONFIG_VT=y
    3.37  CONFIG_VT_CONSOLE=y
    3.38  CONFIG_HW_CONSOLE=y
    3.39  CONFIG_SERIAL_NONSTANDARD=y
    3.40 @@ -1252,11 +1252,7 @@ CONFIG_USB_MON=y
    3.41  # CONFIG_INFINIBAND is not set
    3.42  
    3.43  #
    3.44 -# SN Devices
    3.45 -#
    3.46 -
    3.47 -#
    3.48 -# EDAC - error detection and reporting (RAS)
    3.49 +# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
    3.50  #
    3.51  
    3.52  #
     4.1 --- a/buildconfigs/linux-defconfig_xenU_ia64	Mon Mar 27 15:36:47 2006 -0700
     4.2 +++ b/buildconfigs/linux-defconfig_xenU_ia64	Tue Mar 28 08:54:58 2006 -0700
     4.3 @@ -1,7 +1,7 @@
     4.4  #
     4.5  # Automatically generated make config: don't edit
     4.6 -# Linux kernel version: 2.6.16-rc3-xenU
     4.7 -# Thu Feb 16 13:47:59 2006
     4.8 +# Linux kernel version: 2.6.16-xenU
     4.9 +# Mon Mar 27 14:01:13 2006
    4.10  #
    4.11  
    4.12  #
    4.13 @@ -92,8 +92,7 @@ CONFIG_ARCH_XEN=y
    4.14  CONFIG_XEN_PRIVILEGED_GUEST=y
    4.15  CONFIG_XEN_BLKDEV_GRANT=y
    4.16  CONFIG_XEN_BLKDEV_FRONTEND=y
    4.17 -# CONFIG_XEN_VT is not set
    4.18 -# CONFIG_VT is not set
    4.19 +CONFIG_XEN_BLKDEV_BACKEND=y
    4.20  CONFIG_XEN_SYSFS=y
    4.21  CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
    4.22  CONFIG_DMA_IS_DMA32=y
    4.23 @@ -607,6 +606,9 @@ CONFIG_SERIO=y
    4.24  #
    4.25  # Character devices
    4.26  #
    4.27 +CONFIG_VT=y
    4.28 +CONFIG_VT_CONSOLE=y
    4.29 +CONFIG_HW_CONSOLE=y
    4.30  # CONFIG_SERIAL_NONSTANDARD is not set
    4.31  
    4.32  #
    4.33 @@ -865,6 +867,13 @@ CONFIG_FB_RADEON_DEBUG=y
    4.34  # CONFIG_FB_VIRTUAL is not set
    4.35  
    4.36  #
    4.37 +# Console display driver support
    4.38 +#
    4.39 +CONFIG_VGA_CONSOLE=y
    4.40 +CONFIG_DUMMY_CONSOLE=y
    4.41 +# CONFIG_FRAMEBUFFER_CONSOLE is not set
    4.42 +
    4.43 +#
    4.44  # Logo configuration
    4.45  #
    4.46  CONFIG_LOGO=y
    4.47 @@ -1122,11 +1131,7 @@ CONFIG_USB_MON=y
    4.48  # CONFIG_INFINIBAND is not set
    4.49  
    4.50  #
    4.51 -# SN Devices
    4.52 -#
    4.53 -
    4.54 -#
    4.55 -# EDAC - error detection and reporting (RAS)
    4.56 +# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
    4.57  #
    4.58  
    4.59  #
     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/buildconfigs/linux-defconfig_xen_ia64	Tue Mar 28 08:54:58 2006 -0700
     5.3 @@ -0,0 +1,1523 @@
     5.4 +#
     5.5 +# Automatically generated make config: don't edit
     5.6 +# Linux kernel version: 2.6.16-xen
     5.7 +# Mon Mar 27 14:36:21 2006
     5.8 +#
     5.9 +
    5.10 +#
    5.11 +# Code maturity level options
    5.12 +#
    5.13 +CONFIG_EXPERIMENTAL=y
    5.14 +CONFIG_LOCK_KERNEL=y
    5.15 +CONFIG_INIT_ENV_ARG_LIMIT=32
    5.16 +
    5.17 +#
    5.18 +# General setup
    5.19 +#
    5.20 +CONFIG_LOCALVERSION=""
    5.21 +CONFIG_LOCALVERSION_AUTO=y
    5.22 +CONFIG_SWAP=y
    5.23 +CONFIG_SYSVIPC=y
    5.24 +CONFIG_POSIX_MQUEUE=y
    5.25 +CONFIG_BSD_PROCESS_ACCT=y
    5.26 +# CONFIG_BSD_PROCESS_ACCT_V3 is not set
    5.27 +CONFIG_SYSCTL=y
    5.28 +# CONFIG_AUDIT is not set
    5.29 +CONFIG_IKCONFIG=y
    5.30 +CONFIG_IKCONFIG_PROC=y
    5.31 +# CONFIG_CPUSETS is not set
    5.32 +CONFIG_INITRAMFS_SOURCE=""
    5.33 +CONFIG_CC_OPTIMIZE_FOR_SIZE=y
    5.34 +# CONFIG_EMBEDDED is not set
    5.35 +CONFIG_KALLSYMS=y
    5.36 +CONFIG_KALLSYMS_ALL=y
    5.37 +CONFIG_KALLSYMS_EXTRA_PASS=y
    5.38 +CONFIG_HOTPLUG=y
    5.39 +CONFIG_PRINTK=y
    5.40 +CONFIG_BUG=y
    5.41 +CONFIG_ELF_CORE=y
    5.42 +CONFIG_BASE_FULL=y
    5.43 +CONFIG_FUTEX=y
    5.44 +CONFIG_EPOLL=y
    5.45 +CONFIG_SHMEM=y
    5.46 +CONFIG_CC_ALIGN_FUNCTIONS=0
    5.47 +CONFIG_CC_ALIGN_LABELS=0
    5.48 +CONFIG_CC_ALIGN_LOOPS=0
    5.49 +CONFIG_CC_ALIGN_JUMPS=0
    5.50 +CONFIG_SLAB=y
    5.51 +# CONFIG_TINY_SHMEM is not set
    5.52 +CONFIG_BASE_SMALL=0
    5.53 +# CONFIG_SLOB is not set
    5.54 +
    5.55 +#
    5.56 +# Loadable module support
    5.57 +#
    5.58 +CONFIG_MODULES=y
    5.59 +CONFIG_MODULE_UNLOAD=y
    5.60 +# CONFIG_MODULE_FORCE_UNLOAD is not set
    5.61 +CONFIG_OBSOLETE_MODPARM=y
    5.62 +CONFIG_MODVERSIONS=y
    5.63 +CONFIG_MODULE_SRCVERSION_ALL=y
    5.64 +CONFIG_KMOD=y
    5.65 +CONFIG_STOP_MACHINE=y
    5.66 +
    5.67 +#
    5.68 +# Block layer
    5.69 +#
    5.70 +
    5.71 +#
    5.72 +# IO Schedulers
    5.73 +#
    5.74 +CONFIG_IOSCHED_NOOP=y
    5.75 +CONFIG_IOSCHED_AS=y
    5.76 +CONFIG_IOSCHED_DEADLINE=y
    5.77 +CONFIG_IOSCHED_CFQ=y
    5.78 +CONFIG_DEFAULT_AS=y
    5.79 +# CONFIG_DEFAULT_DEADLINE is not set
    5.80 +# CONFIG_DEFAULT_CFQ is not set
    5.81 +# CONFIG_DEFAULT_NOOP is not set
    5.82 +CONFIG_DEFAULT_IOSCHED="anticipatory"
    5.83 +
    5.84 +#
    5.85 +# Processor type and features
    5.86 +#
    5.87 +CONFIG_IA64=y
    5.88 +CONFIG_64BIT=y
    5.89 +CONFIG_MMU=y
    5.90 +CONFIG_SWIOTLB=y
    5.91 +CONFIG_RWSEM_XCHGADD_ALGORITHM=y
    5.92 +CONFIG_GENERIC_CALIBRATE_DELAY=y
    5.93 +CONFIG_TIME_INTERPOLATION=y
    5.94 +CONFIG_EFI=y
    5.95 +CONFIG_GENERIC_IOMAP=y
    5.96 +CONFIG_XEN=y
    5.97 +CONFIG_ARCH_XEN=y
    5.98 +CONFIG_XEN_PRIVILEGED_GUEST=y
    5.99 +CONFIG_XEN_BLKDEV_GRANT=y
   5.100 +CONFIG_XEN_BLKDEV_FRONTEND=y
   5.101 +CONFIG_XEN_BLKDEV_BACKEND=y
   5.102 +CONFIG_XEN_SYSFS=y
   5.103 +CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
   5.104 +CONFIG_DMA_IS_DMA32=y
   5.105 +# CONFIG_IA64_GENERIC is not set
   5.106 +CONFIG_IA64_DIG=y
   5.107 +# CONFIG_IA64_HP_ZX1 is not set
   5.108 +# CONFIG_IA64_HP_ZX1_SWIOTLB is not set
   5.109 +# CONFIG_IA64_SGI_SN2 is not set
   5.110 +# CONFIG_IA64_HP_SIM is not set
   5.111 +# CONFIG_ITANIUM is not set
   5.112 +CONFIG_MCKINLEY=y
   5.113 +# CONFIG_IA64_PAGE_SIZE_4KB is not set
   5.114 +# CONFIG_IA64_PAGE_SIZE_8KB is not set
   5.115 +CONFIG_IA64_PAGE_SIZE_16KB=y
   5.116 +# CONFIG_IA64_PAGE_SIZE_64KB is not set
   5.117 +CONFIG_PGTABLE_3=y
   5.118 +# CONFIG_PGTABLE_4 is not set
   5.119 +CONFIG_HZ_100=y
   5.120 +# CONFIG_HZ_250 is not set
   5.121 +# CONFIG_HZ_1000 is not set
   5.122 +CONFIG_HZ=100
   5.123 +CONFIG_IA64_L1_CACHE_SHIFT=7
   5.124 +CONFIG_IA64_CYCLONE=y
   5.125 +CONFIG_IOSAPIC=y
   5.126 +CONFIG_FORCE_MAX_ZONEORDER=11
   5.127 +CONFIG_SMP=y
   5.128 +CONFIG_NR_CPUS=4
   5.129 +CONFIG_HOTPLUG_CPU=y
   5.130 +# CONFIG_SCHED_SMT is not set
   5.131 +# CONFIG_PREEMPT is not set
   5.132 +CONFIG_SELECT_MEMORY_MODEL=y
   5.133 +CONFIG_FLATMEM_MANUAL=y
   5.134 +# CONFIG_DISCONTIGMEM_MANUAL is not set
   5.135 +# CONFIG_SPARSEMEM_MANUAL is not set
   5.136 +CONFIG_FLATMEM=y
   5.137 +CONFIG_FLAT_NODE_MEM_MAP=y
   5.138 +# CONFIG_SPARSEMEM_STATIC is not set
   5.139 +CONFIG_SPLIT_PTLOCK_CPUS=4
   5.140 +CONFIG_ARCH_SELECT_MEMORY_MODEL=y
   5.141 +CONFIG_ARCH_DISCONTIGMEM_ENABLE=y
   5.142 +CONFIG_ARCH_FLATMEM_ENABLE=y
   5.143 +CONFIG_ARCH_SPARSEMEM_ENABLE=y
   5.144 +# CONFIG_VIRTUAL_MEM_MAP is not set
   5.145 +# CONFIG_IA32_SUPPORT is not set
   5.146 +CONFIG_IA64_MCA_RECOVERY=y
   5.147 +CONFIG_PERFMON=y
   5.148 +CONFIG_IA64_PALINFO=y
   5.149 +
   5.150 +#
   5.151 +# Firmware Drivers
   5.152 +#
   5.153 +CONFIG_EFI_VARS=y
   5.154 +CONFIG_EFI_PCDP=y
   5.155 +CONFIG_BINFMT_ELF=y
   5.156 +CONFIG_BINFMT_MISC=y
   5.157 +
   5.158 +#
   5.159 +# Power management and ACPI
   5.160 +#
   5.161 +CONFIG_PM=y
   5.162 +CONFIG_PM_LEGACY=y
   5.163 +# CONFIG_PM_DEBUG is not set
   5.164 +
   5.165 +#
   5.166 +# ACPI (Advanced Configuration and Power Interface) Support
   5.167 +#
   5.168 +CONFIG_ACPI=y
   5.169 +CONFIG_ACPI_BUTTON=y
   5.170 +CONFIG_ACPI_FAN=y
   5.171 +CONFIG_ACPI_PROCESSOR=y
   5.172 +CONFIG_ACPI_HOTPLUG_CPU=y
   5.173 +CONFIG_ACPI_THERMAL=y
   5.174 +CONFIG_ACPI_BLACKLIST_YEAR=0
   5.175 +# CONFIG_ACPI_DEBUG is not set
   5.176 +CONFIG_ACPI_EC=y
   5.177 +CONFIG_ACPI_POWER=y
   5.178 +CONFIG_ACPI_SYSTEM=y
   5.179 +CONFIG_ACPI_CONTAINER=y
   5.180 +
   5.181 +#
   5.182 +# CPU Frequency scaling
   5.183 +#
   5.184 +# CONFIG_CPU_FREQ is not set
   5.185 +
   5.186 +#
   5.187 +# Bus options (PCI, PCMCIA)
   5.188 +#
   5.189 +CONFIG_PCI=y
   5.190 +CONFIG_PCI_DOMAINS=y
   5.191 +CONFIG_PCI_LEGACY_PROC=y
   5.192 +# CONFIG_PCI_DEBUG is not set
   5.193 +
   5.194 +#
   5.195 +# PCI Hotplug Support
   5.196 +#
   5.197 +CONFIG_HOTPLUG_PCI=y
   5.198 +# CONFIG_HOTPLUG_PCI_FAKE is not set
   5.199 +CONFIG_HOTPLUG_PCI_ACPI=y
   5.200 +# CONFIG_HOTPLUG_PCI_ACPI_IBM is not set
   5.201 +# CONFIG_HOTPLUG_PCI_CPCI is not set
   5.202 +# CONFIG_HOTPLUG_PCI_SHPC is not set
   5.203 +
   5.204 +#
   5.205 +# PCCARD (PCMCIA/CardBus) support
   5.206 +#
   5.207 +# CONFIG_PCCARD is not set
   5.208 +
   5.209 +#
   5.210 +# Networking
   5.211 +#
   5.212 +CONFIG_NET=y
   5.213 +
   5.214 +#
   5.215 +# Networking options
   5.216 +#
   5.217 +# CONFIG_NETDEBUG is not set
   5.218 +CONFIG_PACKET=y
   5.219 +# CONFIG_PACKET_MMAP is not set
   5.220 +CONFIG_UNIX=y
   5.221 +# CONFIG_NET_KEY is not set
   5.222 +CONFIG_INET=y
   5.223 +CONFIG_IP_MULTICAST=y
   5.224 +# CONFIG_IP_ADVANCED_ROUTER is not set
   5.225 +CONFIG_IP_FIB_HASH=y
   5.226 +# CONFIG_IP_PNP is not set
   5.227 +# CONFIG_NET_IPIP is not set
   5.228 +# CONFIG_NET_IPGRE is not set
   5.229 +# CONFIG_IP_MROUTE is not set
   5.230 +CONFIG_ARPD=y
   5.231 +CONFIG_SYN_COOKIES=y
   5.232 +# CONFIG_INET_AH is not set
   5.233 +# CONFIG_INET_ESP is not set
   5.234 +# CONFIG_INET_IPCOMP is not set
   5.235 +# CONFIG_INET_TUNNEL is not set
   5.236 +CONFIG_INET_DIAG=y
   5.237 +CONFIG_INET_TCP_DIAG=y
   5.238 +# CONFIG_TCP_CONG_ADVANCED is not set
   5.239 +CONFIG_TCP_CONG_BIC=y
   5.240 +
   5.241 +#
   5.242 +# IP: Virtual Server Configuration
   5.243 +#
   5.244 +# CONFIG_IP_VS is not set
   5.245 +# CONFIG_IPV6 is not set
   5.246 +CONFIG_NETFILTER=y
   5.247 +# CONFIG_NETFILTER_DEBUG is not set
   5.248 +CONFIG_BRIDGE_NETFILTER=y
   5.249 +
   5.250 +#
   5.251 +# Core Netfilter Configuration
   5.252 +#
   5.253 +# CONFIG_NETFILTER_NETLINK is not set
   5.254 +# CONFIG_NF_CONNTRACK is not set
   5.255 +# CONFIG_NETFILTER_XTABLES is not set
   5.256 +
   5.257 +#
   5.258 +# IP: Netfilter Configuration
   5.259 +#
   5.260 +# CONFIG_IP_NF_CONNTRACK is not set
   5.261 +# CONFIG_IP_NF_QUEUE is not set
   5.262 +
   5.263 +#
   5.264 +# Bridge: Netfilter Configuration
   5.265 +#
   5.266 +# CONFIG_BRIDGE_NF_EBTABLES is not set
   5.267 +
   5.268 +#
   5.269 +# DCCP Configuration (EXPERIMENTAL)
   5.270 +#
   5.271 +# CONFIG_IP_DCCP is not set
   5.272 +
   5.273 +#
   5.274 +# SCTP Configuration (EXPERIMENTAL)
   5.275 +#
   5.276 +# CONFIG_IP_SCTP is not set
   5.277 +
   5.278 +#
   5.279 +# TIPC Configuration (EXPERIMENTAL)
   5.280 +#
   5.281 +# CONFIG_TIPC is not set
   5.282 +# CONFIG_ATM is not set
   5.283 +CONFIG_BRIDGE=y
   5.284 +# CONFIG_VLAN_8021Q is not set
   5.285 +# CONFIG_DECNET is not set
   5.286 +# CONFIG_LLC2 is not set
   5.287 +# CONFIG_IPX is not set
   5.288 +# CONFIG_ATALK is not set
   5.289 +# CONFIG_X25 is not set
   5.290 +# CONFIG_LAPB is not set
   5.291 +# CONFIG_NET_DIVERT is not set
   5.292 +# CONFIG_ECONET is not set
   5.293 +# CONFIG_WAN_ROUTER is not set
   5.294 +
   5.295 +#
   5.296 +# QoS and/or fair queueing
   5.297 +#
   5.298 +# CONFIG_NET_SCHED is not set
   5.299 +
   5.300 +#
   5.301 +# Network testing
   5.302 +#
   5.303 +# CONFIG_NET_PKTGEN is not set
   5.304 +# CONFIG_HAMRADIO is not set
   5.305 +# CONFIG_IRDA is not set
   5.306 +# CONFIG_BT is not set
   5.307 +# CONFIG_IEEE80211 is not set
   5.308 +
   5.309 +#
   5.310 +# Device Drivers
   5.311 +#
   5.312 +
   5.313 +#
   5.314 +# Generic Driver Options
   5.315 +#
   5.316 +CONFIG_STANDALONE=y
   5.317 +CONFIG_PREVENT_FIRMWARE_BUILD=y
   5.318 +CONFIG_FW_LOADER=y
   5.319 +# CONFIG_DEBUG_DRIVER is not set
   5.320 +
   5.321 +#
   5.322 +# Connector - unified userspace <-> kernelspace linker
   5.323 +#
   5.324 +# CONFIG_CONNECTOR is not set
   5.325 +
   5.326 +#
   5.327 +# Memory Technology Devices (MTD)
   5.328 +#
   5.329 +# CONFIG_MTD is not set
   5.330 +
   5.331 +#
   5.332 +# Parallel port support
   5.333 +#
   5.334 +# CONFIG_PARPORT is not set
   5.335 +
   5.336 +#
   5.337 +# Plug and Play support
   5.338 +#
   5.339 +# CONFIG_PNP is not set
   5.340 +
   5.341 +#
   5.342 +# Block devices
   5.343 +#
   5.344 +# CONFIG_BLK_CPQ_DA is not set
   5.345 +# CONFIG_BLK_CPQ_CISS_DA is not set
   5.346 +# CONFIG_BLK_DEV_DAC960 is not set
   5.347 +# CONFIG_BLK_DEV_UMEM is not set
   5.348 +# CONFIG_BLK_DEV_COW_COMMON is not set
   5.349 +CONFIG_BLK_DEV_LOOP=y
   5.350 +CONFIG_BLK_DEV_CRYPTOLOOP=y
   5.351 +CONFIG_BLK_DEV_NBD=y
   5.352 +# CONFIG_BLK_DEV_SX8 is not set
   5.353 +# CONFIG_BLK_DEV_UB is not set
   5.354 +CONFIG_BLK_DEV_RAM=y
   5.355 +CONFIG_BLK_DEV_RAM_COUNT=16
   5.356 +CONFIG_BLK_DEV_RAM_SIZE=4096
   5.357 +CONFIG_BLK_DEV_INITRD=y
   5.358 +# CONFIG_CDROM_PKTCDVD is not set
   5.359 +# CONFIG_ATA_OVER_ETH is not set
   5.360 +
   5.361 +#
   5.362 +# ATA/ATAPI/MFM/RLL support
   5.363 +#
   5.364 +CONFIG_IDE=y
   5.365 +CONFIG_IDE_MAX_HWIFS=4
   5.366 +CONFIG_BLK_DEV_IDE=y
   5.367 +
   5.368 +#
   5.369 +# Please see Documentation/ide.txt for help/info on IDE drives
   5.370 +#
   5.371 +# CONFIG_BLK_DEV_IDE_SATA is not set
   5.372 +CONFIG_BLK_DEV_IDEDISK=y
   5.373 +# CONFIG_IDEDISK_MULTI_MODE is not set
   5.374 +CONFIG_BLK_DEV_IDECD=y
   5.375 +# CONFIG_BLK_DEV_IDETAPE is not set
   5.376 +CONFIG_BLK_DEV_IDEFLOPPY=y
   5.377 +CONFIG_BLK_DEV_IDESCSI=y
   5.378 +# CONFIG_IDE_TASK_IOCTL is not set
   5.379 +
   5.380 +#
   5.381 +# IDE chipset support/bugfixes
   5.382 +#
   5.383 +# CONFIG_IDE_GENERIC is not set
   5.384 +CONFIG_BLK_DEV_IDEPCI=y
   5.385 +# CONFIG_IDEPCI_SHARE_IRQ is not set
   5.386 +# CONFIG_BLK_DEV_OFFBOARD is not set
   5.387 +CONFIG_BLK_DEV_GENERIC=y
   5.388 +# CONFIG_BLK_DEV_OPTI621 is not set
   5.389 +CONFIG_BLK_DEV_IDEDMA_PCI=y
   5.390 +# CONFIG_BLK_DEV_IDEDMA_FORCED is not set
   5.391 +CONFIG_IDEDMA_PCI_AUTO=y
   5.392 +# CONFIG_IDEDMA_ONLYDISK is not set
   5.393 +# CONFIG_BLK_DEV_AEC62XX is not set
   5.394 +# CONFIG_BLK_DEV_ALI15X3 is not set
   5.395 +# CONFIG_BLK_DEV_AMD74XX is not set
   5.396 +CONFIG_BLK_DEV_CMD64X=y
   5.397 +# CONFIG_BLK_DEV_TRIFLEX is not set
   5.398 +# CONFIG_BLK_DEV_CY82C693 is not set
   5.399 +# CONFIG_BLK_DEV_CS5520 is not set
   5.400 +# CONFIG_BLK_DEV_CS5530 is not set
   5.401 +# CONFIG_BLK_DEV_HPT34X is not set
   5.402 +# CONFIG_BLK_DEV_HPT366 is not set
   5.403 +# CONFIG_BLK_DEV_SC1200 is not set
   5.404 +CONFIG_BLK_DEV_PIIX=y
   5.405 +# CONFIG_BLK_DEV_IT821X is not set
   5.406 +# CONFIG_BLK_DEV_NS87415 is not set
   5.407 +# CONFIG_BLK_DEV_PDC202XX_OLD is not set
   5.408 +# CONFIG_BLK_DEV_PDC202XX_NEW is not set
   5.409 +# CONFIG_BLK_DEV_SVWKS is not set
   5.410 +# CONFIG_BLK_DEV_SIIMAGE is not set
   5.411 +# CONFIG_BLK_DEV_SLC90E66 is not set
   5.412 +# CONFIG_BLK_DEV_TRM290 is not set
   5.413 +# CONFIG_BLK_DEV_VIA82CXXX is not set
   5.414 +# CONFIG_IDE_ARM is not set
   5.415 +CONFIG_BLK_DEV_IDEDMA=y
   5.416 +# CONFIG_IDEDMA_IVB is not set
   5.417 +CONFIG_IDEDMA_AUTO=y
   5.418 +# CONFIG_BLK_DEV_HD is not set
   5.419 +
   5.420 +#
   5.421 +# SCSI device support
   5.422 +#
   5.423 +# CONFIG_RAID_ATTRS is not set
   5.424 +CONFIG_SCSI=y
   5.425 +CONFIG_SCSI_PROC_FS=y
   5.426 +
   5.427 +#
   5.428 +# SCSI support type (disk, tape, CD-ROM)
   5.429 +#
   5.430 +CONFIG_BLK_DEV_SD=y
   5.431 +CONFIG_CHR_DEV_ST=y
   5.432 +CONFIG_CHR_DEV_OSST=y
   5.433 +CONFIG_BLK_DEV_SR=y
   5.434 +CONFIG_BLK_DEV_SR_VENDOR=y
   5.435 +CONFIG_CHR_DEV_SG=y
   5.436 +# CONFIG_CHR_DEV_SCH is not set
   5.437 +
   5.438 +#
   5.439 +# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
   5.440 +#
   5.441 +CONFIG_SCSI_MULTI_LUN=y
   5.442 +CONFIG_SCSI_CONSTANTS=y
   5.443 +CONFIG_SCSI_LOGGING=y
   5.444 +
   5.445 +#
   5.446 +# SCSI Transport Attributes
   5.447 +#
   5.448 +CONFIG_SCSI_SPI_ATTRS=y
   5.449 +CONFIG_SCSI_FC_ATTRS=y
   5.450 +# CONFIG_SCSI_ISCSI_ATTRS is not set
   5.451 +CONFIG_SCSI_SAS_ATTRS=y
   5.452 +
   5.453 +#
   5.454 +# SCSI low-level drivers
   5.455 +#
   5.456 +# CONFIG_ISCSI_TCP is not set
   5.457 +# CONFIG_BLK_DEV_3W_XXXX_RAID is not set
   5.458 +# CONFIG_SCSI_3W_9XXX is not set
   5.459 +# CONFIG_SCSI_ACARD is not set
   5.460 +# CONFIG_SCSI_AACRAID is not set
   5.461 +# CONFIG_SCSI_AIC7XXX is not set
   5.462 +# CONFIG_SCSI_AIC7XXX_OLD is not set
   5.463 +# CONFIG_SCSI_AIC79XX is not set
   5.464 +# CONFIG_MEGARAID_NEWGEN is not set
   5.465 +# CONFIG_MEGARAID_LEGACY is not set
   5.466 +# CONFIG_MEGARAID_SAS is not set
   5.467 +# CONFIG_SCSI_SATA is not set
   5.468 +# CONFIG_SCSI_DMX3191D is not set
   5.469 +# CONFIG_SCSI_FUTURE_DOMAIN is not set
   5.470 +# CONFIG_SCSI_IPS is not set
   5.471 +# CONFIG_SCSI_INITIO is not set
   5.472 +# CONFIG_SCSI_INIA100 is not set
   5.473 +CONFIG_SCSI_SYM53C8XX_2=y
   5.474 +CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=1
   5.475 +CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16
   5.476 +CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
   5.477 +# CONFIG_SCSI_SYM53C8XX_IOMAPPED is not set
   5.478 +# CONFIG_SCSI_IPR is not set
   5.479 +CONFIG_SCSI_QLOGIC_FC=y
   5.480 +# CONFIG_SCSI_QLOGIC_FC_FIRMWARE is not set
   5.481 +CONFIG_SCSI_QLOGIC_1280=y
   5.482 +# CONFIG_SCSI_QLA_FC is not set
   5.483 +# CONFIG_SCSI_LPFC is not set
   5.484 +# CONFIG_SCSI_DC395x is not set
   5.485 +# CONFIG_SCSI_DC390T is not set
   5.486 +# CONFIG_SCSI_DEBUG is not set
   5.487 +
   5.488 +#
   5.489 +# Multi-device support (RAID and LVM)
   5.490 +#
   5.491 +CONFIG_MD=y
   5.492 +# CONFIG_BLK_DEV_MD is not set
   5.493 +# CONFIG_BLK_DEV_DM is not set
   5.494 +
   5.495 +#
   5.496 +# Fusion MPT device support
   5.497 +#
   5.498 +CONFIG_FUSION=y
   5.499 +CONFIG_FUSION_SPI=y
   5.500 +# CONFIG_FUSION_FC is not set
   5.501 +CONFIG_FUSION_SAS=y
   5.502 +CONFIG_FUSION_MAX_SGE=128
   5.503 +# CONFIG_FUSION_CTL is not set
   5.504 +
   5.505 +#
   5.506 +# IEEE 1394 (FireWire) support
   5.507 +#
   5.508 +# CONFIG_IEEE1394 is not set
   5.509 +
   5.510 +#
   5.511 +# I2O device support
   5.512 +#
   5.513 +# CONFIG_I2O is not set
   5.514 +
   5.515 +#
   5.516 +# Network device support
   5.517 +#
   5.518 +CONFIG_NETDEVICES=y
   5.519 +CONFIG_DUMMY=y
   5.520 +# CONFIG_BONDING is not set
   5.521 +# CONFIG_EQUALIZER is not set
   5.522 +CONFIG_TUN=y
   5.523 +
   5.524 +#
   5.525 +# ARCnet devices
   5.526 +#
   5.527 +CONFIG_ARCNET=y
   5.528 +# CONFIG_ARCNET_1201 is not set
   5.529 +# CONFIG_ARCNET_1051 is not set
   5.530 +# CONFIG_ARCNET_RAW is not set
   5.531 +# CONFIG_ARCNET_CAP is not set
   5.532 +# CONFIG_ARCNET_COM90xx is not set
   5.533 +# CONFIG_ARCNET_COM90xxIO is not set
   5.534 +# CONFIG_ARCNET_RIM_I is not set
   5.535 +# CONFIG_ARCNET_COM20020 is not set
   5.536 +
   5.537 +#
   5.538 +# PHY device support
   5.539 +#
   5.540 +# CONFIG_PHYLIB is not set
   5.541 +
   5.542 +#
   5.543 +# Ethernet (10 or 100Mbit)
   5.544 +#
   5.545 +CONFIG_NET_ETHERNET=y
   5.546 +CONFIG_MII=y
   5.547 +# CONFIG_HAPPYMEAL is not set
   5.548 +# CONFIG_SUNGEM is not set
   5.549 +# CONFIG_CASSINI is not set
   5.550 +# CONFIG_NET_VENDOR_3COM is not set
   5.551 +
   5.552 +#
   5.553 +# Tulip family network device support
   5.554 +#
   5.555 +CONFIG_NET_TULIP=y
   5.556 +# CONFIG_DE2104X is not set
   5.557 +CONFIG_TULIP=y
   5.558 +CONFIG_TULIP_MWI=y
   5.559 +CONFIG_TULIP_MMIO=y
   5.560 +CONFIG_TULIP_NAPI=y
   5.561 +CONFIG_TULIP_NAPI_HW_MITIGATION=y
   5.562 +# CONFIG_DE4X5 is not set
   5.563 +# CONFIG_WINBOND_840 is not set
   5.564 +# CONFIG_DM9102 is not set
   5.565 +# CONFIG_ULI526X is not set
   5.566 +# CONFIG_HP100 is not set
   5.567 +CONFIG_NET_PCI=y
   5.568 +# CONFIG_PCNET32 is not set
   5.569 +# CONFIG_AMD8111_ETH is not set
   5.570 +# CONFIG_ADAPTEC_STARFIRE is not set
   5.571 +# CONFIG_B44 is not set
   5.572 +# CONFIG_FORCEDETH is not set
   5.573 +# CONFIG_DGRS is not set
   5.574 +CONFIG_EEPRO100=y
   5.575 +CONFIG_E100=y
   5.576 +# CONFIG_FEALNX is not set
   5.577 +# CONFIG_NATSEMI is not set
   5.578 +# CONFIG_NE2K_PCI is not set
   5.579 +# CONFIG_8139CP is not set
   5.580 +# CONFIG_8139TOO is not set
   5.581 +# CONFIG_SIS900 is not set
   5.582 +# CONFIG_EPIC100 is not set
   5.583 +# CONFIG_SUNDANCE is not set
   5.584 +# CONFIG_VIA_RHINE is not set
   5.585 +
   5.586 +#
   5.587 +# Ethernet (1000 Mbit)
   5.588 +#
   5.589 +# CONFIG_ACENIC is not set
   5.590 +# CONFIG_DL2K is not set
   5.591 +CONFIG_E1000=y
   5.592 +# CONFIG_E1000_NAPI is not set
   5.593 +# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
   5.594 +# CONFIG_NS83820 is not set
   5.595 +# CONFIG_HAMACHI is not set
   5.596 +# CONFIG_YELLOWFIN is not set
   5.597 +# CONFIG_R8169 is not set
   5.598 +# CONFIG_SIS190 is not set
   5.599 +# CONFIG_SKGE is not set
   5.600 +# CONFIG_SKY2 is not set
   5.601 +# CONFIG_SK98LIN is not set
   5.602 +# CONFIG_VIA_VELOCITY is not set
   5.603 +CONFIG_TIGON3=y
   5.604 +# CONFIG_BNX2 is not set
   5.605 +
   5.606 +#
   5.607 +# Ethernet (10000 Mbit)
   5.608 +#
   5.609 +# CONFIG_CHELSIO_T1 is not set
   5.610 +# CONFIG_IXGB is not set
   5.611 +# CONFIG_S2IO is not set
   5.612 +
   5.613 +#
   5.614 +# Token Ring devices
   5.615 +#
   5.616 +# CONFIG_TR is not set
   5.617 +
   5.618 +#
   5.619 +# Wireless LAN (non-hamradio)
   5.620 +#
   5.621 +# CONFIG_NET_RADIO is not set
   5.622 +
   5.623 +#
   5.624 +# Wan interfaces
   5.625 +#
   5.626 +# CONFIG_WAN is not set
   5.627 +# CONFIG_FDDI is not set
   5.628 +# CONFIG_HIPPI is not set
   5.629 +# CONFIG_PPP is not set
   5.630 +# CONFIG_SLIP is not set
   5.631 +# CONFIG_NET_FC is not set
   5.632 +# CONFIG_SHAPER is not set
   5.633 +CONFIG_NETCONSOLE=y
   5.634 +CONFIG_NETPOLL=y
   5.635 +# CONFIG_NETPOLL_RX is not set
   5.636 +# CONFIG_NETPOLL_TRAP is not set
   5.637 +CONFIG_NET_POLL_CONTROLLER=y
   5.638 +
   5.639 +#
   5.640 +# ISDN subsystem
   5.641 +#
   5.642 +CONFIG_ISDN=m
   5.643 +
   5.644 +#
   5.645 +# Old ISDN4Linux
   5.646 +#
   5.647 +# CONFIG_ISDN_I4L is not set
   5.648 +
   5.649 +#
   5.650 +# CAPI subsystem
   5.651 +#
   5.652 +# CONFIG_ISDN_CAPI is not set
   5.653 +
   5.654 +#
   5.655 +# Telephony Support
   5.656 +#
   5.657 +# CONFIG_PHONE is not set
   5.658 +
   5.659 +#
   5.660 +# Input device support
   5.661 +#
   5.662 +CONFIG_INPUT=y
   5.663 +
   5.664 +#
   5.665 +# Userland interfaces
   5.666 +#
   5.667 +CONFIG_INPUT_MOUSEDEV=y
   5.668 +CONFIG_INPUT_MOUSEDEV_PSAUX=y
   5.669 +CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
   5.670 +CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
   5.671 +CONFIG_INPUT_JOYDEV=y
   5.672 +# CONFIG_INPUT_TSDEV is not set
   5.673 +CONFIG_INPUT_EVDEV=y
   5.674 +# CONFIG_INPUT_EVBUG is not set
   5.675 +
   5.676 +#
   5.677 +# Input Device Drivers
   5.678 +#
   5.679 +CONFIG_INPUT_KEYBOARD=y
   5.680 +CONFIG_KEYBOARD_ATKBD=y
   5.681 +# CONFIG_KEYBOARD_SUNKBD is not set
   5.682 +# CONFIG_KEYBOARD_LKKBD is not set
   5.683 +# CONFIG_KEYBOARD_XTKBD is not set
   5.684 +# CONFIG_KEYBOARD_NEWTON is not set
   5.685 +CONFIG_INPUT_MOUSE=y
   5.686 +CONFIG_MOUSE_PS2=y
   5.687 +# CONFIG_MOUSE_SERIAL is not set
   5.688 +# CONFIG_MOUSE_VSXXXAA is not set
   5.689 +# CONFIG_INPUT_JOYSTICK is not set
   5.690 +# CONFIG_INPUT_TOUCHSCREEN is not set
   5.691 +# CONFIG_INPUT_MISC is not set
   5.692 +
   5.693 +#
   5.694 +# Hardware I/O ports
   5.695 +#
   5.696 +CONFIG_SERIO=y
   5.697 +CONFIG_SERIO_I8042=y
   5.698 +# CONFIG_SERIO_SERPORT is not set
   5.699 +# CONFIG_SERIO_PCIPS2 is not set
   5.700 +CONFIG_SERIO_LIBPS2=y
   5.701 +# CONFIG_SERIO_RAW is not set
   5.702 +CONFIG_GAMEPORT=y
   5.703 +# CONFIG_GAMEPORT_NS558 is not set
   5.704 +# CONFIG_GAMEPORT_L4 is not set
   5.705 +# CONFIG_GAMEPORT_EMU10K1 is not set
   5.706 +# CONFIG_GAMEPORT_FM801 is not set
   5.707 +
   5.708 +#
   5.709 +# Character devices
   5.710 +#
   5.711 +CONFIG_VT=y
   5.712 +CONFIG_VT_CONSOLE=y
   5.713 +CONFIG_HW_CONSOLE=y
   5.714 +CONFIG_SERIAL_NONSTANDARD=y
   5.715 +# CONFIG_COMPUTONE is not set
   5.716 +# CONFIG_ROCKETPORT is not set
   5.717 +# CONFIG_CYCLADES is not set
   5.718 +# CONFIG_DIGIEPCA is not set
   5.719 +# CONFIG_MOXA_INTELLIO is not set
   5.720 +# CONFIG_MOXA_SMARTIO is not set
   5.721 +# CONFIG_ISI is not set
   5.722 +# CONFIG_SYNCLINKMP is not set
   5.723 +# CONFIG_SYNCLINK_GT is not set
   5.724 +# CONFIG_N_HDLC is not set
   5.725 +# CONFIG_SPECIALIX is not set
   5.726 +# CONFIG_SX is not set
   5.727 +# CONFIG_STALDRV is not set
   5.728 +
   5.729 +#
   5.730 +# Serial drivers
   5.731 +#
   5.732 +CONFIG_SERIAL_8250=y
   5.733 +CONFIG_SERIAL_8250_CONSOLE=y
   5.734 +CONFIG_SERIAL_8250_ACPI=y
   5.735 +CONFIG_SERIAL_8250_NR_UARTS=6
   5.736 +CONFIG_SERIAL_8250_RUNTIME_UARTS=4
   5.737 +CONFIG_SERIAL_8250_EXTENDED=y
   5.738 +CONFIG_SERIAL_8250_SHARE_IRQ=y
   5.739 +# CONFIG_SERIAL_8250_DETECT_IRQ is not set
   5.740 +# CONFIG_SERIAL_8250_RSA is not set
   5.741 +
   5.742 +#
   5.743 +# Non-8250 serial port support
   5.744 +#
   5.745 +CONFIG_SERIAL_CORE=y
   5.746 +CONFIG_SERIAL_CORE_CONSOLE=y
   5.747 +# CONFIG_SERIAL_JSM is not set
   5.748 +CONFIG_UNIX98_PTYS=y
   5.749 +CONFIG_LEGACY_PTYS=y
   5.750 +CONFIG_LEGACY_PTY_COUNT=256
   5.751 +
   5.752 +#
   5.753 +# IPMI
   5.754 +#
   5.755 +# CONFIG_IPMI_HANDLER is not set
   5.756 +
   5.757 +#
   5.758 +# Watchdog Cards
   5.759 +#
   5.760 +# CONFIG_WATCHDOG is not set
   5.761 +# CONFIG_HW_RANDOM is not set
   5.762 +CONFIG_EFI_RTC=y
   5.763 +# CONFIG_DTLK is not set
   5.764 +# CONFIG_R3964 is not set
   5.765 +# CONFIG_APPLICOM is not set
   5.766 +
   5.767 +#
   5.768 +# Ftape, the floppy tape device driver
   5.769 +#
   5.770 +CONFIG_AGP=y
   5.771 +CONFIG_AGP_I460=y
   5.772 +CONFIG_DRM=y
   5.773 +# CONFIG_DRM_TDFX is not set
   5.774 +# CONFIG_DRM_R128 is not set
   5.775 +# CONFIG_DRM_RADEON is not set
   5.776 +# CONFIG_DRM_MGA is not set
   5.777 +# CONFIG_DRM_SIS is not set
   5.778 +# CONFIG_DRM_VIA is not set
   5.779 +# CONFIG_DRM_SAVAGE is not set
   5.780 +# CONFIG_RAW_DRIVER is not set
   5.781 +# CONFIG_HPET is not set
   5.782 +# CONFIG_HANGCHECK_TIMER is not set
   5.783 +
   5.784 +#
   5.785 +# TPM devices
   5.786 +#
   5.787 +# CONFIG_TCG_TPM is not set
   5.788 +# CONFIG_TELCLOCK is not set
   5.789 +
   5.790 +#
   5.791 +# I2C support
   5.792 +#
   5.793 +CONFIG_I2C=y
   5.794 +CONFIG_I2C_CHARDEV=y
   5.795 +
   5.796 +#
   5.797 +# I2C Algorithms
   5.798 +#
   5.799 +CONFIG_I2C_ALGOBIT=y
   5.800 +CONFIG_I2C_ALGOPCF=y
   5.801 +# CONFIG_I2C_ALGOPCA is not set
   5.802 +
   5.803 +#
   5.804 +# I2C Hardware Bus support
   5.805 +#
   5.806 +# CONFIG_I2C_ALI1535 is not set
   5.807 +# CONFIG_I2C_ALI1563 is not set
   5.808 +# CONFIG_I2C_ALI15X3 is not set
   5.809 +# CONFIG_I2C_AMD756 is not set
   5.810 +# CONFIG_I2C_AMD8111 is not set
   5.811 +# CONFIG_I2C_I801 is not set
   5.812 +# CONFIG_I2C_I810 is not set
   5.813 +# CONFIG_I2C_PIIX4 is not set
   5.814 +# CONFIG_I2C_NFORCE2 is not set
   5.815 +# CONFIG_I2C_PARPORT_LIGHT is not set
   5.816 +# CONFIG_I2C_PROSAVAGE is not set
   5.817 +# CONFIG_I2C_SAVAGE4 is not set
   5.818 +# CONFIG_SCx200_ACB is not set
   5.819 +# CONFIG_I2C_SIS5595 is not set
   5.820 +# CONFIG_I2C_SIS630 is not set
   5.821 +# CONFIG_I2C_SIS96X is not set
   5.822 +# CONFIG_I2C_STUB is not set
   5.823 +# CONFIG_I2C_VIA is not set
   5.824 +# CONFIG_I2C_VIAPRO is not set
   5.825 +# CONFIG_I2C_VOODOO3 is not set
   5.826 +# CONFIG_I2C_PCA_ISA is not set
   5.827 +
   5.828 +#
   5.829 +# Miscellaneous I2C Chip support
   5.830 +#
   5.831 +# CONFIG_SENSORS_DS1337 is not set
   5.832 +# CONFIG_SENSORS_DS1374 is not set
   5.833 +# CONFIG_SENSORS_EEPROM is not set
   5.834 +# CONFIG_SENSORS_PCF8574 is not set
   5.835 +# CONFIG_SENSORS_PCA9539 is not set
   5.836 +# CONFIG_SENSORS_PCF8591 is not set
   5.837 +# CONFIG_SENSORS_RTC8564 is not set
   5.838 +# CONFIG_SENSORS_MAX6875 is not set
   5.839 +# CONFIG_RTC_X1205_I2C is not set
   5.840 +# CONFIG_I2C_DEBUG_CORE is not set
   5.841 +# CONFIG_I2C_DEBUG_ALGO is not set
   5.842 +# CONFIG_I2C_DEBUG_BUS is not set
   5.843 +# CONFIG_I2C_DEBUG_CHIP is not set
   5.844 +
   5.845 +#
   5.846 +# SPI support
   5.847 +#
   5.848 +# CONFIG_SPI is not set
   5.849 +# CONFIG_SPI_MASTER is not set
   5.850 +
   5.851 +#
   5.852 +# Dallas's 1-wire bus
   5.853 +#
   5.854 +# CONFIG_W1 is not set
   5.855 +
   5.856 +#
   5.857 +# Hardware Monitoring support
   5.858 +#
   5.859 +CONFIG_HWMON=y
   5.860 +# CONFIG_HWMON_VID is not set
   5.861 +# CONFIG_SENSORS_ADM1021 is not set
   5.862 +# CONFIG_SENSORS_ADM1025 is not set
   5.863 +# CONFIG_SENSORS_ADM1026 is not set
   5.864 +# CONFIG_SENSORS_ADM1031 is not set
   5.865 +# CONFIG_SENSORS_ADM9240 is not set
   5.866 +# CONFIG_SENSORS_ASB100 is not set
   5.867 +# CONFIG_SENSORS_ATXP1 is not set
   5.868 +# CONFIG_SENSORS_DS1621 is not set
   5.869 +# CONFIG_SENSORS_F71805F is not set
   5.870 +# CONFIG_SENSORS_FSCHER is not set
   5.871 +# CONFIG_SENSORS_FSCPOS is not set
   5.872 +# CONFIG_SENSORS_GL518SM is not set
   5.873 +# CONFIG_SENSORS_GL520SM is not set
   5.874 +# CONFIG_SENSORS_IT87 is not set
   5.875 +# CONFIG_SENSORS_LM63 is not set
   5.876 +# CONFIG_SENSORS_LM75 is not set
   5.877 +# CONFIG_SENSORS_LM77 is not set
   5.878 +# CONFIG_SENSORS_LM78 is not set
   5.879 +# CONFIG_SENSORS_LM80 is not set
   5.880 +# CONFIG_SENSORS_LM83 is not set
   5.881 +# CONFIG_SENSORS_LM85 is not set
   5.882 +# CONFIG_SENSORS_LM87 is not set
   5.883 +# CONFIG_SENSORS_LM90 is not set
   5.884 +# CONFIG_SENSORS_LM92 is not set
   5.885 +# CONFIG_SENSORS_MAX1619 is not set
   5.886 +# CONFIG_SENSORS_PC87360 is not set
   5.887 +# CONFIG_SENSORS_SIS5595 is not set
   5.888 +# CONFIG_SENSORS_SMSC47M1 is not set
   5.889 +# CONFIG_SENSORS_SMSC47B397 is not set
   5.890 +# CONFIG_SENSORS_VIA686A is not set
   5.891 +# CONFIG_SENSORS_VT8231 is not set
   5.892 +# CONFIG_SENSORS_W83781D is not set
   5.893 +# CONFIG_SENSORS_W83792D is not set
   5.894 +# CONFIG_SENSORS_W83L785TS is not set
   5.895 +# CONFIG_SENSORS_W83627HF is not set
   5.896 +# CONFIG_SENSORS_W83627EHF is not set
   5.897 +# CONFIG_HWMON_DEBUG_CHIP is not set
   5.898 +
   5.899 +#
   5.900 +# Misc devices
   5.901 +#
   5.902 +
   5.903 +#
   5.904 +# Multimedia Capabilities Port drivers
   5.905 +#
   5.906 +
   5.907 +#
   5.908 +# Multimedia devices
   5.909 +#
   5.910 +CONFIG_VIDEO_DEV=y
   5.911 +
   5.912 +#
   5.913 +# Video For Linux
   5.914 +#
   5.915 +
   5.916 +#
   5.917 +# Video Adapters
   5.918 +#
   5.919 +# CONFIG_VIDEO_ADV_DEBUG is not set
   5.920 +# CONFIG_VIDEO_BT848 is not set
   5.921 +# CONFIG_VIDEO_CPIA is not set
   5.922 +# CONFIG_VIDEO_SAA5246A is not set
   5.923 +# CONFIG_VIDEO_SAA5249 is not set
   5.924 +# CONFIG_TUNER_3036 is not set
   5.925 +# CONFIG_VIDEO_STRADIS is not set
   5.926 +# CONFIG_VIDEO_ZORAN is not set
   5.927 +# CONFIG_VIDEO_SAA7134 is not set
   5.928 +# CONFIG_VIDEO_MXB is not set
   5.929 +# CONFIG_VIDEO_DPC is not set
   5.930 +# CONFIG_VIDEO_HEXIUM_ORION is not set
   5.931 +# CONFIG_VIDEO_HEXIUM_GEMINI is not set
   5.932 +# CONFIG_VIDEO_CX88 is not set
   5.933 +# CONFIG_VIDEO_EM28XX is not set
   5.934 +# CONFIG_VIDEO_OVCAMCHIP is not set
   5.935 +# CONFIG_VIDEO_AUDIO_DECODER is not set
   5.936 +# CONFIG_VIDEO_DECODER is not set
   5.937 +
   5.938 +#
   5.939 +# Radio Adapters
   5.940 +#
   5.941 +# CONFIG_RADIO_GEMTEK_PCI is not set
   5.942 +# CONFIG_RADIO_MAXIRADIO is not set
   5.943 +# CONFIG_RADIO_MAESTRO is not set
   5.944 +
   5.945 +#
   5.946 +# Digital Video Broadcasting Devices
   5.947 +#
   5.948 +# CONFIG_DVB is not set
   5.949 +
   5.950 +#
   5.951 +# Graphics support
   5.952 +#
   5.953 +CONFIG_FB=y
   5.954 +CONFIG_FB_CFB_FILLRECT=y
   5.955 +CONFIG_FB_CFB_COPYAREA=y
   5.956 +CONFIG_FB_CFB_IMAGEBLIT=y
   5.957 +# CONFIG_FB_MACMODES is not set
   5.958 +CONFIG_FB_MODE_HELPERS=y
   5.959 +# CONFIG_FB_TILEBLITTING is not set
   5.960 +# CONFIG_FB_CIRRUS is not set
   5.961 +# CONFIG_FB_PM2 is not set
   5.962 +# CONFIG_FB_CYBER2000 is not set
   5.963 +# CONFIG_FB_ASILIANT is not set
   5.964 +# CONFIG_FB_IMSTT is not set
   5.965 +# CONFIG_FB_S1D13XXX is not set
   5.966 +# CONFIG_FB_NVIDIA is not set
   5.967 +# CONFIG_FB_RIVA is not set
   5.968 +# CONFIG_FB_MATROX is not set
   5.969 +# CONFIG_FB_RADEON_OLD is not set
   5.970 +CONFIG_FB_RADEON=y
   5.971 +CONFIG_FB_RADEON_I2C=y
   5.972 +CONFIG_FB_RADEON_DEBUG=y
   5.973 +# CONFIG_FB_ATY128 is not set
   5.974 +# CONFIG_FB_ATY is not set
   5.975 +# CONFIG_FB_SAVAGE is not set
   5.976 +# CONFIG_FB_SIS is not set
   5.977 +# CONFIG_FB_NEOMAGIC is not set
   5.978 +# CONFIG_FB_KYRO is not set
   5.979 +# CONFIG_FB_3DFX is not set
   5.980 +# CONFIG_FB_VOODOO1 is not set
   5.981 +# CONFIG_FB_TRIDENT is not set
   5.982 +# CONFIG_FB_VIRTUAL is not set
   5.983 +
   5.984 +#
   5.985 +# Console display driver support
   5.986 +#
   5.987 +CONFIG_VGA_CONSOLE=y
   5.988 +CONFIG_DUMMY_CONSOLE=y
   5.989 +# CONFIG_FRAMEBUFFER_CONSOLE is not set
   5.990 +
   5.991 +#
   5.992 +# Logo configuration
   5.993 +#
   5.994 +CONFIG_LOGO=y
   5.995 +# CONFIG_LOGO_LINUX_MONO is not set
   5.996 +# CONFIG_LOGO_LINUX_VGA16 is not set
   5.997 +CONFIG_LOGO_LINUX_CLUT224=y
   5.998 +# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
   5.999 +
  5.1000 +#
  5.1001 +# Sound
  5.1002 +#
  5.1003 +CONFIG_SOUND=y
  5.1004 +
  5.1005 +#
  5.1006 +# Advanced Linux Sound Architecture
  5.1007 +#
  5.1008 +CONFIG_SND=y
  5.1009 +CONFIG_SND_TIMER=y
  5.1010 +CONFIG_SND_PCM=y
  5.1011 +CONFIG_SND_HWDEP=y
  5.1012 +CONFIG_SND_RAWMIDI=y
  5.1013 +CONFIG_SND_SEQUENCER=y
  5.1014 +CONFIG_SND_SEQ_DUMMY=y
  5.1015 +CONFIG_SND_OSSEMUL=y
  5.1016 +CONFIG_SND_MIXER_OSS=y
  5.1017 +CONFIG_SND_PCM_OSS=y
  5.1018 +CONFIG_SND_SEQUENCER_OSS=y
  5.1019 +# CONFIG_SND_DYNAMIC_MINORS is not set
  5.1020 +CONFIG_SND_SUPPORT_OLD_API=y
  5.1021 +# CONFIG_SND_VERBOSE_PRINTK is not set
  5.1022 +# CONFIG_SND_DEBUG is not set
  5.1023 +
  5.1024 +#
  5.1025 +# Generic devices
  5.1026 +#
  5.1027 +CONFIG_SND_MPU401_UART=y
  5.1028 +CONFIG_SND_OPL3_LIB=y
  5.1029 +CONFIG_SND_AC97_CODEC=y
  5.1030 +CONFIG_SND_AC97_BUS=y
  5.1031 +CONFIG_SND_DUMMY=y
  5.1032 +CONFIG_SND_VIRMIDI=y
  5.1033 +CONFIG_SND_MTPAV=y
  5.1034 +CONFIG_SND_SERIAL_U16550=y
  5.1035 +CONFIG_SND_MPU401=y
  5.1036 +
  5.1037 +#
  5.1038 +# PCI devices
  5.1039 +#
  5.1040 +# CONFIG_SND_AD1889 is not set
  5.1041 +# CONFIG_SND_ALI5451 is not set
  5.1042 +CONFIG_SND_ATIIXP=y
  5.1043 +# CONFIG_SND_ATIIXP_MODEM is not set
  5.1044 +# CONFIG_SND_AU8810 is not set
  5.1045 +# CONFIG_SND_AU8820 is not set
  5.1046 +# CONFIG_SND_AU8830 is not set
  5.1047 +# CONFIG_SND_AZT3328 is not set
  5.1048 +# CONFIG_SND_BT87X is not set
  5.1049 +# CONFIG_SND_CA0106 is not set
  5.1050 +# CONFIG_SND_CMIPCI is not set
  5.1051 +# CONFIG_SND_CS4281 is not set
  5.1052 +# CONFIG_SND_CS46XX is not set
  5.1053 +# CONFIG_SND_EMU10K1 is not set
  5.1054 +# CONFIG_SND_EMU10K1X is not set
  5.1055 +# CONFIG_SND_ENS1370 is not set
  5.1056 +# CONFIG_SND_ENS1371 is not set
  5.1057 +# CONFIG_SND_ES1938 is not set
  5.1058 +# CONFIG_SND_ES1968 is not set
  5.1059 +CONFIG_SND_FM801=y
  5.1060 +CONFIG_SND_FM801_TEA575X=y
  5.1061 +# CONFIG_SND_HDA_INTEL is not set
  5.1062 +# CONFIG_SND_HDSP is not set
  5.1063 +# CONFIG_SND_HDSPM is not set
  5.1064 +# CONFIG_SND_ICE1712 is not set
  5.1065 +# CONFIG_SND_ICE1724 is not set
  5.1066 +# CONFIG_SND_INTEL8X0 is not set
  5.1067 +# CONFIG_SND_INTEL8X0M is not set
  5.1068 +# CONFIG_SND_KORG1212 is not set
  5.1069 +# CONFIG_SND_MAESTRO3 is not set
  5.1070 +# CONFIG_SND_MIXART is not set
  5.1071 +# CONFIG_SND_NM256 is not set
  5.1072 +# CONFIG_SND_PCXHR is not set
  5.1073 +# CONFIG_SND_RME32 is not set
  5.1074 +# CONFIG_SND_RME96 is not set
  5.1075 +# CONFIG_SND_RME9652 is not set
  5.1076 +# CONFIG_SND_SONICVIBES is not set
  5.1077 +# CONFIG_SND_TRIDENT is not set
  5.1078 +# CONFIG_SND_VIA82XX is not set
  5.1079 +# CONFIG_SND_VIA82XX_MODEM is not set
  5.1080 +# CONFIG_SND_VX222 is not set
  5.1081 +# CONFIG_SND_YMFPCI is not set
  5.1082 +
  5.1083 +#
  5.1084 +# USB devices
  5.1085 +#
  5.1086 +# CONFIG_SND_USB_AUDIO is not set
  5.1087 +
  5.1088 +#
  5.1089 +# Open Sound System
  5.1090 +#
  5.1091 +CONFIG_SOUND_PRIME=y
  5.1092 +# CONFIG_OBSOLETE_OSS_DRIVER is not set
  5.1093 +# CONFIG_SOUND_FUSION is not set
  5.1094 +# CONFIG_SOUND_ICH is not set
  5.1095 +# CONFIG_SOUND_TRIDENT is not set
  5.1096 +# CONFIG_SOUND_MSNDCLAS is not set
  5.1097 +# CONFIG_SOUND_MSNDPIN is not set
  5.1098 +# CONFIG_SOUND_TVMIXER is not set
  5.1099 +
  5.1100 +#
  5.1101 +# USB support
  5.1102 +#
  5.1103 +CONFIG_USB_ARCH_HAS_HCD=y
  5.1104 +CONFIG_USB_ARCH_HAS_OHCI=y
  5.1105 +CONFIG_USB=y
  5.1106 +# CONFIG_USB_DEBUG is not set
  5.1107 +
  5.1108 +#
  5.1109 +# Miscellaneous USB options
  5.1110 +#
  5.1111 +CONFIG_USB_DEVICEFS=y
  5.1112 +CONFIG_USB_BANDWIDTH=y
  5.1113 +# CONFIG_USB_DYNAMIC_MINORS is not set
  5.1114 +# CONFIG_USB_SUSPEND is not set
  5.1115 +# CONFIG_USB_OTG is not set
  5.1116 +
  5.1117 +#
  5.1118 +# USB Host Controller Drivers
  5.1119 +#
  5.1120 +CONFIG_USB_EHCI_HCD=y
  5.1121 +# CONFIG_USB_EHCI_SPLIT_ISO is not set
  5.1122 +# CONFIG_USB_EHCI_ROOT_HUB_TT is not set
  5.1123 +# CONFIG_USB_ISP116X_HCD is not set
  5.1124 +CONFIG_USB_OHCI_HCD=y
  5.1125 +# CONFIG_USB_OHCI_BIG_ENDIAN is not set
  5.1126 +CONFIG_USB_OHCI_LITTLE_ENDIAN=y
  5.1127 +CONFIG_USB_UHCI_HCD=y
  5.1128 +# CONFIG_USB_SL811_HCD is not set
  5.1129 +
  5.1130 +#
  5.1131 +# USB Device Class drivers
  5.1132 +#
  5.1133 +# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
  5.1134 +# CONFIG_USB_ACM is not set
  5.1135 +# CONFIG_USB_PRINTER is not set
  5.1136 +
  5.1137 +#
  5.1138 +# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
  5.1139 +#
  5.1140 +
  5.1141 +#
  5.1142 +# may also be needed; see USB_STORAGE Help for more information
  5.1143 +#
  5.1144 +CONFIG_USB_STORAGE=y
  5.1145 +# CONFIG_USB_STORAGE_DEBUG is not set
  5.1146 +# CONFIG_USB_STORAGE_DATAFAB is not set
  5.1147 +# CONFIG_USB_STORAGE_FREECOM is not set
  5.1148 +# CONFIG_USB_STORAGE_ISD200 is not set
  5.1149 +# CONFIG_USB_STORAGE_DPCM is not set
  5.1150 +# CONFIG_USB_STORAGE_USBAT is not set
  5.1151 +# CONFIG_USB_STORAGE_SDDR09 is not set
  5.1152 +# CONFIG_USB_STORAGE_SDDR55 is not set
  5.1153 +# CONFIG_USB_STORAGE_JUMPSHOT is not set
  5.1154 +# CONFIG_USB_STORAGE_ALAUDA is not set
  5.1155 +# CONFIG_USB_LIBUSUAL is not set
  5.1156 +
  5.1157 +#
  5.1158 +# USB Input Devices
  5.1159 +#
  5.1160 +CONFIG_USB_HID=y
  5.1161 +CONFIG_USB_HIDINPUT=y
  5.1162 +# CONFIG_USB_HIDINPUT_POWERBOOK is not set
  5.1163 +# CONFIG_HID_FF is not set
  5.1164 +CONFIG_USB_HIDDEV=y
  5.1165 +# CONFIG_USB_AIPTEK is not set
  5.1166 +# CONFIG_USB_WACOM is not set
  5.1167 +# CONFIG_USB_ACECAD is not set
  5.1168 +# CONFIG_USB_KBTAB is not set
  5.1169 +# CONFIG_USB_POWERMATE is not set
  5.1170 +# CONFIG_USB_MTOUCH is not set
  5.1171 +# CONFIG_USB_ITMTOUCH is not set
  5.1172 +# CONFIG_USB_EGALAX is not set
  5.1173 +# CONFIG_USB_YEALINK is not set
  5.1174 +# CONFIG_USB_XPAD is not set
  5.1175 +# CONFIG_USB_ATI_REMOTE is not set
  5.1176 +# CONFIG_USB_ATI_REMOTE2 is not set
  5.1177 +# CONFIG_USB_KEYSPAN_REMOTE is not set
  5.1178 +# CONFIG_USB_APPLETOUCH is not set
  5.1179 +
  5.1180 +#
  5.1181 +# USB Imaging devices
  5.1182 +#
  5.1183 +# CONFIG_USB_MDC800 is not set
  5.1184 +# CONFIG_USB_MICROTEK is not set
  5.1185 +
  5.1186 +#
  5.1187 +# USB Multimedia devices
  5.1188 +#
  5.1189 +# CONFIG_USB_DABUSB is not set
  5.1190 +# CONFIG_USB_VICAM is not set
  5.1191 +# CONFIG_USB_DSBR is not set
  5.1192 +# CONFIG_USB_ET61X251 is not set
  5.1193 +# CONFIG_USB_IBMCAM is not set
  5.1194 +# CONFIG_USB_KONICAWC is not set
  5.1195 +# CONFIG_USB_OV511 is not set
  5.1196 +# CONFIG_USB_SE401 is not set
  5.1197 +# CONFIG_USB_SN9C102 is not set
  5.1198 +# CONFIG_USB_STV680 is not set
  5.1199 +# CONFIG_USB_PWC is not set
  5.1200 +
  5.1201 +#
  5.1202 +# USB Network Adapters
  5.1203 +#
  5.1204 +# CONFIG_USB_CATC is not set
  5.1205 +# CONFIG_USB_KAWETH is not set
  5.1206 +# CONFIG_USB_PEGASUS is not set
  5.1207 +# CONFIG_USB_RTL8150 is not set
  5.1208 +# CONFIG_USB_USBNET is not set
  5.1209 +CONFIG_USB_MON=y
  5.1210 +
  5.1211 +#
  5.1212 +# USB port drivers
  5.1213 +#
  5.1214 +
  5.1215 +#
  5.1216 +# USB Serial Converter support
  5.1217 +#
  5.1218 +# CONFIG_USB_SERIAL is not set
  5.1219 +
  5.1220 +#
  5.1221 +# USB Miscellaneous drivers
  5.1222 +#
  5.1223 +# CONFIG_USB_EMI62 is not set
  5.1224 +# CONFIG_USB_EMI26 is not set
  5.1225 +# CONFIG_USB_AUERSWALD is not set
  5.1226 +# CONFIG_USB_RIO500 is not set
  5.1227 +# CONFIG_USB_LEGOTOWER is not set
  5.1228 +# CONFIG_USB_LCD is not set
  5.1229 +# CONFIG_USB_LED is not set
  5.1230 +# CONFIG_USB_CYTHERM is not set
  5.1231 +# CONFIG_USB_PHIDGETKIT is not set
  5.1232 +# CONFIG_USB_PHIDGETSERVO is not set
  5.1233 +# CONFIG_USB_IDMOUSE is not set
  5.1234 +# CONFIG_USB_SISUSBVGA is not set
  5.1235 +# CONFIG_USB_LD is not set
  5.1236 +# CONFIG_USB_TEST is not set
  5.1237 +
  5.1238 +#
  5.1239 +# USB DSL modem support
  5.1240 +#
  5.1241 +
  5.1242 +#
  5.1243 +# USB Gadget Support
  5.1244 +#
  5.1245 +# CONFIG_USB_GADGET is not set
  5.1246 +
  5.1247 +#
  5.1248 +# MMC/SD Card support
  5.1249 +#
  5.1250 +# CONFIG_MMC is not set
  5.1251 +
  5.1252 +#
  5.1253 +# InfiniBand support
  5.1254 +#
  5.1255 +# CONFIG_INFINIBAND is not set
  5.1256 +
  5.1257 +#
  5.1258 +# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
  5.1259 +#
  5.1260 +
  5.1261 +#
  5.1262 +# File systems
  5.1263 +#
  5.1264 +CONFIG_EXT2_FS=y
  5.1265 +CONFIG_EXT2_FS_XATTR=y
  5.1266 +CONFIG_EXT2_FS_POSIX_ACL=y
  5.1267 +CONFIG_EXT2_FS_SECURITY=y
  5.1268 +# CONFIG_EXT2_FS_XIP is not set
  5.1269 +CONFIG_EXT3_FS=y
  5.1270 +CONFIG_EXT3_FS_XATTR=y
  5.1271 +CONFIG_EXT3_FS_POSIX_ACL=y
  5.1272 +CONFIG_EXT3_FS_SECURITY=y
  5.1273 +CONFIG_JBD=y
  5.1274 +# CONFIG_JBD_DEBUG is not set
  5.1275 +CONFIG_FS_MBCACHE=y
  5.1276 +CONFIG_REISERFS_FS=y
  5.1277 +# CONFIG_REISERFS_CHECK is not set
  5.1278 +# CONFIG_REISERFS_PROC_INFO is not set
  5.1279 +CONFIG_REISERFS_FS_XATTR=y
  5.1280 +CONFIG_REISERFS_FS_POSIX_ACL=y
  5.1281 +CONFIG_REISERFS_FS_SECURITY=y
  5.1282 +# CONFIG_JFS_FS is not set
  5.1283 +CONFIG_FS_POSIX_ACL=y
  5.1284 +CONFIG_XFS_FS=y
  5.1285 +CONFIG_XFS_EXPORT=y
  5.1286 +# CONFIG_XFS_QUOTA is not set
  5.1287 +# CONFIG_XFS_SECURITY is not set
  5.1288 +# CONFIG_XFS_POSIX_ACL is not set
  5.1289 +# CONFIG_XFS_RT is not set
  5.1290 +# CONFIG_OCFS2_FS is not set
  5.1291 +# CONFIG_MINIX_FS is not set
  5.1292 +# CONFIG_ROMFS_FS is not set
  5.1293 +CONFIG_INOTIFY=y
  5.1294 +# CONFIG_QUOTA is not set
  5.1295 +CONFIG_DNOTIFY=y
  5.1296 +CONFIG_AUTOFS_FS=y
  5.1297 +CONFIG_AUTOFS4_FS=y
  5.1298 +# CONFIG_FUSE_FS is not set
  5.1299 +
  5.1300 +#
  5.1301 +# CD-ROM/DVD Filesystems
  5.1302 +#
  5.1303 +CONFIG_ISO9660_FS=y
  5.1304 +CONFIG_JOLIET=y
  5.1305 +# CONFIG_ZISOFS is not set
  5.1306 +CONFIG_UDF_FS=y
  5.1307 +CONFIG_UDF_NLS=y
  5.1308 +
  5.1309 +#
  5.1310 +# DOS/FAT/NT Filesystems
  5.1311 +#
  5.1312 +CONFIG_FAT_FS=y
  5.1313 +CONFIG_MSDOS_FS=y
  5.1314 +CONFIG_VFAT_FS=y
  5.1315 +CONFIG_FAT_DEFAULT_CODEPAGE=437
  5.1316 +CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
  5.1317 +# CONFIG_NTFS_FS is not set
  5.1318 +
  5.1319 +#
  5.1320 +# Pseudo filesystems
  5.1321 +#
  5.1322 +CONFIG_PROC_FS=y
  5.1323 +CONFIG_PROC_KCORE=y
  5.1324 +CONFIG_SYSFS=y
  5.1325 +CONFIG_TMPFS=y
  5.1326 +# CONFIG_HUGETLB_PAGE is not set
  5.1327 +CONFIG_RAMFS=y
  5.1328 +# CONFIG_RELAYFS_FS is not set
  5.1329 +# CONFIG_CONFIGFS_FS is not set
  5.1330 +
  5.1331 +#
  5.1332 +# Miscellaneous filesystems
  5.1333 +#
  5.1334 +# CONFIG_ADFS_FS is not set
  5.1335 +# CONFIG_AFFS_FS is not set
  5.1336 +# CONFIG_HFS_FS is not set
  5.1337 +# CONFIG_HFSPLUS_FS is not set
  5.1338 +# CONFIG_BEFS_FS is not set
  5.1339 +# CONFIG_BFS_FS is not set
  5.1340 +# CONFIG_EFS_FS is not set
  5.1341 +# CONFIG_CRAMFS is not set
  5.1342 +# CONFIG_VXFS_FS is not set
  5.1343 +# CONFIG_HPFS_FS is not set
  5.1344 +# CONFIG_QNX4FS_FS is not set
  5.1345 +# CONFIG_SYSV_FS is not set
  5.1346 +# CONFIG_UFS_FS is not set
  5.1347 +
  5.1348 +#
  5.1349 +# Network File Systems
  5.1350 +#
  5.1351 +CONFIG_NFS_FS=y
  5.1352 +CONFIG_NFS_V3=y
  5.1353 +# CONFIG_NFS_V3_ACL is not set
  5.1354 +CONFIG_NFS_V4=y
  5.1355 +CONFIG_NFS_DIRECTIO=y
  5.1356 +CONFIG_NFSD=y
  5.1357 +CONFIG_NFSD_V3=y
  5.1358 +# CONFIG_NFSD_V3_ACL is not set
  5.1359 +CONFIG_NFSD_V4=y
  5.1360 +CONFIG_NFSD_TCP=y
  5.1361 +CONFIG_LOCKD=y
  5.1362 +CONFIG_LOCKD_V4=y
  5.1363 +CONFIG_EXPORTFS=y
  5.1364 +CONFIG_NFS_COMMON=y
  5.1365 +CONFIG_SUNRPC=y
  5.1366 +CONFIG_SUNRPC_GSS=y
  5.1367 +CONFIG_RPCSEC_GSS_KRB5=y
  5.1368 +# CONFIG_RPCSEC_GSS_SPKM3 is not set
  5.1369 +CONFIG_SMB_FS=y
  5.1370 +CONFIG_SMB_NLS_DEFAULT=y
  5.1371 +CONFIG_SMB_NLS_REMOTE="cp437"
  5.1372 +CONFIG_CIFS=y
  5.1373 +# CONFIG_CIFS_STATS is not set
  5.1374 +# CONFIG_CIFS_XATTR is not set
  5.1375 +# CONFIG_CIFS_EXPERIMENTAL is not set
  5.1376 +# CONFIG_NCP_FS is not set
  5.1377 +# CONFIG_CODA_FS is not set
  5.1378 +# CONFIG_AFS_FS is not set
  5.1379 +# CONFIG_9P_FS is not set
  5.1380 +
  5.1381 +#
  5.1382 +# Partition Types
  5.1383 +#
  5.1384 +CONFIG_PARTITION_ADVANCED=y
  5.1385 +# CONFIG_ACORN_PARTITION is not set
  5.1386 +# CONFIG_OSF_PARTITION is not set
  5.1387 +# CONFIG_AMIGA_PARTITION is not set
  5.1388 +# CONFIG_ATARI_PARTITION is not set
  5.1389 +# CONFIG_MAC_PARTITION is not set
  5.1390 +CONFIG_MSDOS_PARTITION=y
  5.1391 +# CONFIG_BSD_DISKLABEL is not set
  5.1392 +# CONFIG_MINIX_SUBPARTITION is not set
  5.1393 +# CONFIG_SOLARIS_X86_PARTITION is not set
  5.1394 +# CONFIG_UNIXWARE_DISKLABEL is not set
  5.1395 +# CONFIG_LDM_PARTITION is not set
  5.1396 +CONFIG_SGI_PARTITION=y
  5.1397 +# CONFIG_ULTRIX_PARTITION is not set
  5.1398 +# CONFIG_SUN_PARTITION is not set
  5.1399 +# CONFIG_KARMA_PARTITION is not set
  5.1400 +CONFIG_EFI_PARTITION=y
  5.1401 +
  5.1402 +#
  5.1403 +# Native Language Support
  5.1404 +#
  5.1405 +CONFIG_NLS=y
  5.1406 +CONFIG_NLS_DEFAULT="iso8859-1"
  5.1407 +CONFIG_NLS_CODEPAGE_437=y
  5.1408 +CONFIG_NLS_CODEPAGE_737=y
  5.1409 +CONFIG_NLS_CODEPAGE_775=y
  5.1410 +CONFIG_NLS_CODEPAGE_850=y
  5.1411 +CONFIG_NLS_CODEPAGE_852=y
  5.1412 +CONFIG_NLS_CODEPAGE_855=y
  5.1413 +CONFIG_NLS_CODEPAGE_857=y
  5.1414 +CONFIG_NLS_CODEPAGE_860=y
  5.1415 +CONFIG_NLS_CODEPAGE_861=y
  5.1416 +CONFIG_NLS_CODEPAGE_862=y
  5.1417 +CONFIG_NLS_CODEPAGE_863=y
  5.1418 +CONFIG_NLS_CODEPAGE_864=y
  5.1419 +CONFIG_NLS_CODEPAGE_865=y
  5.1420 +CONFIG_NLS_CODEPAGE_866=y
  5.1421 +CONFIG_NLS_CODEPAGE_869=y
  5.1422 +CONFIG_NLS_CODEPAGE_936=y
  5.1423 +CONFIG_NLS_CODEPAGE_950=y
  5.1424 +CONFIG_NLS_CODEPAGE_932=y
  5.1425 +CONFIG_NLS_CODEPAGE_949=y
  5.1426 +CONFIG_NLS_CODEPAGE_874=y
  5.1427 +CONFIG_NLS_ISO8859_8=y
  5.1428 +# CONFIG_NLS_CODEPAGE_1250 is not set
  5.1429 +CONFIG_NLS_CODEPAGE_1251=y
  5.1430 +# CONFIG_NLS_ASCII is not set
  5.1431 +CONFIG_NLS_ISO8859_1=y
  5.1432 +CONFIG_NLS_ISO8859_2=y
  5.1433 +CONFIG_NLS_ISO8859_3=y
  5.1434 +CONFIG_NLS_ISO8859_4=y
  5.1435 +CONFIG_NLS_ISO8859_5=y
  5.1436 +CONFIG_NLS_ISO8859_6=y
  5.1437 +CONFIG_NLS_ISO8859_7=y
  5.1438 +CONFIG_NLS_ISO8859_9=y
  5.1439 +CONFIG_NLS_ISO8859_13=y
  5.1440 +CONFIG_NLS_ISO8859_14=y
  5.1441 +CONFIG_NLS_ISO8859_15=y
  5.1442 +CONFIG_NLS_KOI8_R=y
  5.1443 +CONFIG_NLS_KOI8_U=y
  5.1444 +CONFIG_NLS_UTF8=y
  5.1445 +
  5.1446 +#
  5.1447 +# Library routines
  5.1448 +#
  5.1449 +# CONFIG_CRC_CCITT is not set
  5.1450 +# CONFIG_CRC16 is not set
  5.1451 +CONFIG_CRC32=y
  5.1452 +# CONFIG_LIBCRC32C is not set
  5.1453 +CONFIG_GENERIC_HARDIRQS=y
  5.1454 +CONFIG_GENERIC_IRQ_PROBE=y
  5.1455 +CONFIG_GENERIC_PENDING_IRQ=y
  5.1456 +
  5.1457 +#
  5.1458 +# Instrumentation Support
  5.1459 +#
  5.1460 +# CONFIG_PROFILING is not set
  5.1461 +# CONFIG_KPROBES is not set
  5.1462 +
  5.1463 +#
  5.1464 +# Kernel hacking
  5.1465 +#
  5.1466 +# CONFIG_PRINTK_TIME is not set
  5.1467 +CONFIG_MAGIC_SYSRQ=y
  5.1468 +CONFIG_DEBUG_KERNEL=y
  5.1469 +CONFIG_LOG_BUF_SHIFT=20
  5.1470 +CONFIG_DETECT_SOFTLOCKUP=y
  5.1471 +# CONFIG_SCHEDSTATS is not set
  5.1472 +# CONFIG_DEBUG_SLAB is not set
  5.1473 +CONFIG_DEBUG_MUTEXES=y
  5.1474 +# CONFIG_DEBUG_SPINLOCK is not set
  5.1475 +# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
  5.1476 +# CONFIG_DEBUG_KOBJECT is not set
  5.1477 +# CONFIG_DEBUG_INFO is not set
  5.1478 +# CONFIG_DEBUG_FS is not set
  5.1479 +# CONFIG_DEBUG_VM is not set
  5.1480 +CONFIG_FORCED_INLINING=y
  5.1481 +# CONFIG_RCU_TORTURE_TEST is not set
  5.1482 +CONFIG_IA64_GRANULE_16MB=y
  5.1483 +# CONFIG_IA64_GRANULE_64MB is not set
  5.1484 +CONFIG_IA64_PRINT_HAZARDS=y
  5.1485 +# CONFIG_DISABLE_VHPT is not set
  5.1486 +# CONFIG_IA64_DEBUG_CMPXCHG is not set
  5.1487 +# CONFIG_IA64_DEBUG_IRQ is not set
  5.1488 +
  5.1489 +#
  5.1490 +# Security options
  5.1491 +#
  5.1492 +# CONFIG_KEYS is not set
  5.1493 +# CONFIG_SECURITY is not set
  5.1494 +
  5.1495 +#
  5.1496 +# Cryptographic options
  5.1497 +#
  5.1498 +CONFIG_CRYPTO=y
  5.1499 +# CONFIG_CRYPTO_HMAC is not set
  5.1500 +# CONFIG_CRYPTO_NULL is not set
  5.1501 +# CONFIG_CRYPTO_MD4 is not set
  5.1502 +CONFIG_CRYPTO_MD5=y
  5.1503 +# CONFIG_CRYPTO_SHA1 is not set
  5.1504 +# CONFIG_CRYPTO_SHA256 is not set
  5.1505 +# CONFIG_CRYPTO_SHA512 is not set
  5.1506 +# CONFIG_CRYPTO_WP512 is not set
  5.1507 +# CONFIG_CRYPTO_TGR192 is not set
  5.1508 +CONFIG_CRYPTO_DES=y
  5.1509 +# CONFIG_CRYPTO_BLOWFISH is not set
  5.1510 +# CONFIG_CRYPTO_TWOFISH is not set
  5.1511 +# CONFIG_CRYPTO_SERPENT is not set
  5.1512 +# CONFIG_CRYPTO_AES is not set
  5.1513 +# CONFIG_CRYPTO_CAST5 is not set
  5.1514 +# CONFIG_CRYPTO_CAST6 is not set
  5.1515 +# CONFIG_CRYPTO_TEA is not set
  5.1516 +# CONFIG_CRYPTO_ARC4 is not set
  5.1517 +# CONFIG_CRYPTO_KHAZAD is not set
  5.1518 +# CONFIG_CRYPTO_ANUBIS is not set
  5.1519 +# CONFIG_CRYPTO_DEFLATE is not set
  5.1520 +# CONFIG_CRYPTO_MICHAEL_MIC is not set
  5.1521 +# CONFIG_CRYPTO_CRC32C is not set
  5.1522 +# CONFIG_CRYPTO_TEST is not set
  5.1523 +
  5.1524 +#
  5.1525 +# Hardware crypto devices
  5.1526 +#
     6.1 --- a/buildconfigs/linux-defconfig_xen_x86_64	Mon Mar 27 15:36:47 2006 -0700
     6.2 +++ b/buildconfigs/linux-defconfig_xen_x86_64	Tue Mar 28 08:54:58 2006 -0700
     6.3 @@ -1,7 +1,7 @@
     6.4  #
     6.5  # Automatically generated make config: don't edit
     6.6 -# Linux kernel version: 2.6.16-rc3-xen
     6.7 -# Mon Feb 20 11:37:11 2006
     6.8 +# Linux kernel version: 2.6.16-xen
     6.9 +# Mon Mar 27 09:43:44 2006
    6.10  #
    6.11  CONFIG_X86_64=y
    6.12  CONFIG_64BIT=y
    6.13 @@ -102,6 +102,8 @@ CONFIG_X86_PC=y
    6.14  # CONFIG_MPSC is not set
    6.15  CONFIG_GENERIC_CPU=y
    6.16  CONFIG_X86_64_XEN=y
    6.17 +CONFIG_X86_NO_TSS=y
    6.18 +CONFIG_X86_NO_IDT=y
    6.19  CONFIG_X86_L1_CACHE_BYTES=128
    6.20  CONFIG_X86_L1_CACHE_SHIFT=7
    6.21  CONFIG_X86_GOOD_APIC=y
    6.22 @@ -1138,7 +1140,7 @@ CONFIG_AMD8111_ETH=m
    6.23  CONFIG_AMD8111E_NAPI=y
    6.24  CONFIG_ADAPTEC_STARFIRE=m
    6.25  CONFIG_ADAPTEC_STARFIRE_NAPI=y
    6.26 -CONFIG_B44=m
    6.27 +# CONFIG_B44 is not set
    6.28  CONFIG_FORCEDETH=m
    6.29  CONFIG_DGRS=m
    6.30  CONFIG_EEPRO100=m
    6.31 @@ -1782,8 +1784,8 @@ CONFIG_VIDEO_DPC=m
    6.32  CONFIG_VIDEO_HEXIUM_ORION=m
    6.33  CONFIG_VIDEO_HEXIUM_GEMINI=m
    6.34  CONFIG_VIDEO_CX88=m
    6.35 +CONFIG_VIDEO_CX88_ALSA=m
    6.36  CONFIG_VIDEO_CX88_DVB=m
    6.37 -CONFIG_VIDEO_CX88_ALSA=m
    6.38  CONFIG_VIDEO_CX88_DVB_ALL_FRONTENDS=y
    6.39  CONFIG_VIDEO_CX88_VP3054=m
    6.40  CONFIG_VIDEO_EM28XX=m
    6.41 @@ -2331,11 +2333,7 @@ CONFIG_INFINIBAND_IPOIB=m
    6.42  CONFIG_INFINIBAND_SRP=m
    6.43  
    6.44  #
    6.45 -# SN Devices
    6.46 -#
    6.47 -
    6.48 -#
    6.49 -# EDAC - error detection and reporting (RAS)
    6.50 +# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
    6.51  #
    6.52  CONFIG_EDAC=m
    6.53  
     7.1 --- a/docs/src/user.tex	Mon Mar 27 15:36:47 2006 -0700
     7.2 +++ b/docs/src/user.tex	Tue Mar 28 08:54:58 2006 -0700
     7.3 @@ -52,6 +52,40 @@ are licensed under the terms of the GNU 
     7.4  Zope Public License 2.0, or under ``BSD-style'' licenses.  Please refer to the
     7.5  COPYING file for details.
     7.6  
     7.7 +Xen includes software by Christopher Clark.  This software is covered by the
     7.8 +following licence:
     7.9 +
    7.10 +\begin{quote}
    7.11 +Copyright (c) 2002, Christopher Clark.  All rights reserved.
    7.12 +
    7.13 +Redistribution and use in source and binary forms, with or without
    7.14 +modification, are permitted provided that the following conditions are met:
    7.15 +
    7.16 +\begin{itemize}
    7.17 +\item Redistributions of source code must retain the above copyright notice,
    7.18 +this list of conditions and the following disclaimer.
    7.19 +
    7.20 +\item Redistributions in binary form must reproduce the above copyright
    7.21 +notice, this list of conditions and the following disclaimer in the
    7.22 +documentation and/or other materials provided with the distribution.
    7.23 +
    7.24 +\item Neither the name of the original author; nor the names of any
    7.25 +contributors may be used to endorse or promote products derived from this
    7.26 +software without specific prior written permission.
    7.27 +\end{itemize}
    7.28 +
    7.29 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    7.30 +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    7.31 +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    7.32 +DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
    7.33 +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    7.34 +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    7.35 +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    7.36 +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    7.37 +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    7.38 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    7.39 +\end{quote}
    7.40 +
    7.41  \cleardoublepage
    7.42  
    7.43  
     8.1 --- a/extras/mini-os/Makefile	Mon Mar 27 15:36:47 2006 -0700
     8.2 +++ b/extras/mini-os/Makefile	Tue Mar 28 08:54:58 2006 -0700
     8.3 @@ -41,8 +41,7 @@ default: $(TARGET)
     8.4  
     8.5  links:
     8.6  	[ -e include/xen ] || ln -sf ../../../xen/include/public include/xen
     8.7 -	[ -e xenbus/xenstored.h ] || ln -sf ../../../tools/xenstore/xenstored.h xenbus/xenstored.h
     8.8 -	
     8.9 +
    8.10  $(TARGET): links $(OBJS)
    8.11  	$(LD) -N -T minios-$(TARGET_ARCH).lds $(OBJS) -o $@.elf
    8.12  	gzip -f -9 -c $@.elf >$@.gz
     9.1 --- a/extras/mini-os/console/console.c	Mon Mar 27 15:36:47 2006 -0700
     9.2 +++ b/extras/mini-os/console/console.c	Tue Mar 28 08:54:58 2006 -0700
     9.3 @@ -116,12 +116,12 @@ void print(int direct, const char *fmt, 
     9.4      {
     9.5          (void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(buf), buf);
     9.6          return;
     9.7 +    } else {
     9.8 +        if(!console_initialised)
     9.9 +            (void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(buf), buf);
    9.10 +        
    9.11 +        console_print(buf, strlen(buf));
    9.12      }
    9.13 -    
    9.14 -    if(!console_initialised)
    9.15 -        (void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(buf), buf);
    9.16 -        
    9.17 -    console_print(buf, strlen(buf));
    9.18  }
    9.19  
    9.20  void printk(const char *fmt, ...)
    10.1 --- a/extras/mini-os/console/xencons_ring.c	Mon Mar 27 15:36:47 2006 -0700
    10.2 +++ b/extras/mini-os/console/xencons_ring.c	Tue Mar 28 08:54:58 2006 -0700
    10.3 @@ -10,7 +10,6 @@
    10.4  
    10.5  
    10.6  /* TODO - need to define BUG_ON for whole mini-os, need crash-dump as well */
    10.7 -extern void do_exit(void);
    10.8  #define BUG_ON(_cond)   do{if(_cond) do_exit();} while(0);
    10.9  
   10.10  static inline struct xencons_interface *xencons_interface(void)
   10.11 @@ -29,7 +28,6 @@ int xencons_ring_send_no_notify(const ch
   10.12      int sent = 0;
   10.13  	struct xencons_interface *intf = xencons_interface();
   10.14  	XENCONS_RING_IDX cons, prod;
   10.15 -
   10.16  	cons = intf->out_cons;
   10.17  	prod = intf->out_prod;
   10.18  	mb();
    11.1 --- a/extras/mini-os/events.c	Mon Mar 27 15:36:47 2006 -0700
    11.2 +++ b/extras/mini-os/events.c	Tue Mar 28 08:54:58 2006 -0700
    11.3 @@ -74,9 +74,9 @@ int bind_evtchn( u32 port, void (*handle
    11.4  
    11.5  void unbind_evtchn( u32 port )
    11.6  {
    11.7 -	if (ev_actions[port].handler)
    11.8 +	if (ev_actions[port].handler == default_handler)
    11.9  		printk("WARN: No handler for port %d when unbinding\n", port);
   11.10 -	ev_actions[port].handler = NULL;
   11.11 +	ev_actions[port].handler = default_handler;
   11.12  	ev_actions[port].status |= EVS_DISABLED;
   11.13  }
   11.14  
    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/extras/mini-os/include/console.h	Tue Mar 28 08:54:58 2006 -0700
    12.3 @@ -0,0 +1,49 @@
    12.4 +/* 
    12.5 + ****************************************************************************
    12.6 + * (C) 2006 - Grzegorz Milos - Cambridge University
    12.7 + ****************************************************************************
    12.8 + *
    12.9 + *        File: console.h
   12.10 + *      Author: Grzegorz Milos
   12.11 + *     Changes: 
   12.12 + *              
   12.13 + *        Date: Mar 2006
   12.14 + * 
   12.15 + * Environment: Xen Minimal OS
   12.16 + * Description: Console interface.
   12.17 + *
   12.18 + * Handles console I/O. Defines printk.
   12.19 + *
   12.20 + ****************************************************************************
   12.21 + * Permission is hereby granted, free of charge, to any person obtaining a copy
   12.22 + * of this software and associated documentation files (the "Software"), to
   12.23 + * deal in the Software without restriction, including without limitation the
   12.24 + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   12.25 + * sell copies of the Software, and to permit persons to whom the Software is
   12.26 + * furnished to do so, subject to the following conditions:
   12.27 + * 
   12.28 + * The above copyright notice and this permission notice shall be included in
   12.29 + * all copies or substantial portions of the Software.
   12.30 + * 
   12.31 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
   12.32 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
   12.33 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
   12.34 + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
   12.35 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
   12.36 + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
   12.37 + * DEALINGS IN THE SOFTWARE.
   12.38 + */
   12.39 +#ifndef _LIB_CONSOLE_H_
   12.40 +#define _LIB_CONSOLE_H_
   12.41 +
   12.42 +#include<traps.h>
   12.43 +
   12.44 +void printk(const char *fmt, ...);
   12.45 +void xprintk(const char *fmt, ...);
   12.46 +
   12.47 +void xencons_rx(char *buf, unsigned len, struct pt_regs *regs);
   12.48 +void xencons_tx(void);
   12.49 +
   12.50 +void init_console(void);
   12.51 +
   12.52 +#endif /* _LIB_CONSOLE_H_ */
    13.1 --- a/extras/mini-os/include/os.h	Mon Mar 27 15:36:47 2006 -0700
    13.2 +++ b/extras/mini-os/include/os.h	Tue Mar 28 08:54:58 2006 -0700
    13.3 @@ -9,6 +9,7 @@
    13.4  
    13.5  #define NULL 0
    13.6  
    13.7 +
    13.8  #if __GNUC__ == 2 && __GNUC_MINOR__ < 96
    13.9  #define __builtin_expect(x, expected_value) (x)
   13.10  #endif
   13.11 @@ -20,6 +21,10 @@
   13.12  #ifndef __ASSEMBLY__
   13.13  #include <types.h>
   13.14  #include <hypervisor.h>
   13.15 +
   13.16 +extern void do_exit(void);
   13.17 +#define BUG do_exit
   13.18 +
   13.19  #endif
   13.20  #include <xen/xen.h>
   13.21  
    14.1 --- a/extras/mini-os/include/wait.h	Mon Mar 27 15:36:47 2006 -0700
    14.2 +++ b/extras/mini-os/include/wait.h	Tue Mar 28 08:54:58 2006 -0700
    14.3 @@ -66,6 +66,14 @@ static inline void wake_up(struct wait_q
    14.4      }
    14.5  }
    14.6  
    14.7 +#define add_waiter(w, wq) do {  \
    14.8 +    unsigned long flags;        \
    14.9 +    local_irq_save(flags);      \
   14.10 +    add_wait_queue(&wq, &w);    \
   14.11 +    block(current);             \
   14.12 +    local_irq_restore(flags);   \
   14.13 +} while (0)
   14.14 +
   14.15  #define wait_event(wq, condition) do{             \
   14.16      unsigned long flags;                          \
   14.17      if(condition)                                 \
    15.1 --- a/extras/mini-os/include/xenbus.h	Mon Mar 27 15:36:47 2006 -0700
    15.2 +++ b/extras/mini-os/include/xenbus.h	Tue Mar 28 08:54:58 2006 -0700
    15.3 @@ -1,224 +1,6 @@
    15.4 -/******************************************************************************
    15.5 - * xenbus.h
    15.6 - *
    15.7 - * Talks to Xen Store to figure out what devices we have.
    15.8 - *
    15.9 - * Copyright (C) 2005 Rusty Russell, IBM Corporation
   15.10 - * Copyright (C) 2005 XenSource Ltd.
   15.11 - * 
   15.12 - * This file may be distributed separately from the Linux kernel, or
   15.13 - * incorporated into other software packages, subject to the following license:
   15.14 - * 
   15.15 - * Permission is hereby granted, free of charge, to any person obtaining a copy
   15.16 - * of this source file (the "Software"), to deal in the Software without
   15.17 - * restriction, including without limitation the rights to use, copy, modify,
   15.18 - * merge, publish, distribute, sublicense, and/or sell copies of the Software,
   15.19 - * and to permit persons to whom the Software is furnished to do so, subject to
   15.20 - * the following conditions:
   15.21 - * 
   15.22 - * The above copyright notice and this permission notice shall be included in
   15.23 - * all copies or substantial portions of the Software.
   15.24 - * 
   15.25 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   15.26 - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   15.27 - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   15.28 - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   15.29 - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   15.30 - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   15.31 - * IN THE SOFTWARE.
   15.32 - */
   15.33 -
   15.34 -#ifndef _ASM_XEN_XENBUS_H
   15.35 -#define _ASM_XEN_XENBUS_H
   15.36 -
   15.37 -#include <errno.h>
   15.38 -#include <xen/io/xenbus.h>
   15.39 -#include <xen/io/xs_wire.h>
   15.40 -
   15.41 -/* Register callback to watch this node. */
   15.42 -struct xenbus_watch
   15.43 -{
   15.44 -	struct list_head list;
   15.45 -
   15.46 -	/* Path being watched. */
   15.47 -	const char *node;
   15.48 -
   15.49 -	/* Callback (executed in a process context with no locks held). */
   15.50 -	void (*callback)(struct xenbus_watch *,
   15.51 -			 const char **vec, unsigned int len);
   15.52 -};
   15.53 -
   15.54 -
   15.55 -/* A xenbus device. */
   15.56 -struct xenbus_device {
   15.57 -	const char *devicetype;
   15.58 -	const char *nodename;
   15.59 -	const char *otherend;
   15.60 -	int otherend_id;
   15.61 -	struct xenbus_watch otherend_watch;
   15.62 -	int has_error;
   15.63 -	void *data;
   15.64 -};
   15.65 -
   15.66 -struct xenbus_device_id
   15.67 -{
   15.68 -	/* .../device/<device_type>/<identifier> */
   15.69 -	char devicetype[32]; 	/* General class of device. */
   15.70 -};
   15.71 -
   15.72 -/* A xenbus driver. */
   15.73 -struct xenbus_driver {
   15.74 -	char *name;
   15.75 -	struct module *owner;
   15.76 -	const struct xenbus_device_id *ids;
   15.77 -	int (*probe)(struct xenbus_device *dev,
   15.78 -		     const struct xenbus_device_id *id);
   15.79 -	void (*otherend_changed)(struct xenbus_device *dev,
   15.80 -				 XenbusState backend_state);
   15.81 -	int (*remove)(struct xenbus_device *dev);
   15.82 -	int (*suspend)(struct xenbus_device *dev);
   15.83 -	int (*resume)(struct xenbus_device *dev);
   15.84 -	int (*hotplug)(struct xenbus_device *, char **, int, char *, int);
   15.85 -	int (*read_otherend_details)(struct xenbus_device *dev);
   15.86 -};
   15.87 -
   15.88 -int xenbus_register_frontend(struct xenbus_driver *drv);
   15.89 -int xenbus_register_backend(struct xenbus_driver *drv);
   15.90 -void xenbus_unregister_driver(struct xenbus_driver *drv);
   15.91 -
   15.92 -struct xenbus_transaction;
   15.93 -
   15.94 -char **xenbus_directory(struct xenbus_transaction *t,
   15.95 -			const char *dir, const char *node, unsigned int *num);
   15.96 -void *xenbus_read(struct xenbus_transaction *t,
   15.97 -		  const char *dir, const char *node, unsigned int *len);
   15.98 -int xenbus_write(struct xenbus_transaction *t,
   15.99 -		 const char *dir, const char *node, const char *string);
  15.100 -int xenbus_mkdir(struct xenbus_transaction *t,
  15.101 -		 const char *dir, const char *node);
  15.102 -int xenbus_exists(struct xenbus_transaction *t,
  15.103 -		  const char *dir, const char *node);
  15.104 -int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node);
  15.105 -struct xenbus_transaction *xenbus_transaction_start(void);
  15.106 -int xenbus_transaction_end(struct xenbus_transaction *t, int abort);
  15.107 -
  15.108 -/* Single read and scanf: returns -errno or num scanned if > 0. */
  15.109 -int xenbus_scanf(struct xenbus_transaction *t,
  15.110 -		 const char *dir, const char *node, const char *fmt, ...)
  15.111 -	__attribute__((format(scanf, 4, 5)));
  15.112 +#ifndef XENBUS_H__
  15.113 +#define XENBUS_H__
  15.114  
  15.115 -/* Single printf and write: returns -errno or 0. */
  15.116 -int xenbus_printf(struct xenbus_transaction *t,
  15.117 -		  const char *dir, const char *node, const char *fmt, ...)
  15.118 -	__attribute__((format(printf, 4, 5)));
  15.119 -
  15.120 -/* Generic read function: NULL-terminated triples of name,
  15.121 - * sprintf-style type string, and pointer. Returns 0 or errno.*/
  15.122 -int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...);
  15.123 -
  15.124 -int register_xenbus_watch(struct xenbus_watch *watch);
  15.125 -void unregister_xenbus_watch(struct xenbus_watch *watch);
  15.126 -void xs_suspend(void);
  15.127 -void xs_resume(void);
  15.128 -
  15.129 -/* Used by xenbus_dev to borrow kernel's store connection. */
  15.130 -void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg);
  15.131 -
  15.132 -/* Called from xen core code. */
  15.133 -void xenbus_suspend(void);
  15.134 -void xenbus_resume(void);
  15.135 -
  15.136 -#define XENBUS_IS_ERR_READ(str) ({			\
  15.137 -	if (!IS_ERR(str) && strlen(str) == 0) {		\
  15.138 -		kfree(str);				\
  15.139 -		str = ERR_PTR(-ERANGE);			\
  15.140 -	}						\
  15.141 -	IS_ERR(str);					\
  15.142 -})
  15.143 -
  15.144 -#define XENBUS_EXIST_ERR(err) ((err) == -ENOENT || (err) == -ERANGE)
  15.145 -
  15.146 -
  15.147 -/**
  15.148 - * Register a watch on the given path, using the given xenbus_watch structure
  15.149 - * for storage, and the given callback function as the callback.  Return 0 on
  15.150 - * success, or -errno on error.  On success, the given path will be saved as
  15.151 - * watch->node, and remains the caller's to free.  On error, watch->node will
  15.152 - * be NULL, the device will switch to XenbusStateClosing, and the error will
  15.153 - * be saved in the store.
  15.154 - */
  15.155 -int xenbus_watch_path(struct xenbus_device *dev, const char *path,
  15.156 -		      struct xenbus_watch *watch, 
  15.157 -		      void (*callback)(struct xenbus_watch *,
  15.158 -				       const char **, unsigned int));
  15.159 -
  15.160 +void init_xenbus(void);
  15.161  
  15.162 -/**
  15.163 - * Register a watch on the given path/path2, using the given xenbus_watch
  15.164 - * structure for storage, and the given callback function as the callback.
  15.165 - * Return 0 on success, or -errno on error.  On success, the watched path
  15.166 - * (path/path2) will be saved as watch->node, and becomes the caller's to
  15.167 - * kfree().  On error, watch->node will be NULL, so the caller has nothing to
  15.168 - * free, the device will switch to XenbusStateClosing, and the error will be
  15.169 - * saved in the store.
  15.170 - */
  15.171 -int xenbus_watch_path2(struct xenbus_device *dev, const char *path,
  15.172 -		       const char *path2, struct xenbus_watch *watch, 
  15.173 -		       void (*callback)(struct xenbus_watch *,
  15.174 -					const char **, unsigned int));
  15.175 -
  15.176 -
  15.177 -/**
  15.178 - * Advertise in the store a change of the given driver to the given new_state.
  15.179 - * Perform the change inside the given transaction xbt.  xbt may be NULL, in
  15.180 - * which case this is performed inside its own transaction.  Return 0 on
  15.181 - * success, or -errno on error.  On error, the device will switch to
  15.182 - * XenbusStateClosing, and the error will be saved in the store.
  15.183 - */
  15.184 -int xenbus_switch_state(struct xenbus_device *dev,
  15.185 -			struct xenbus_transaction *xbt,
  15.186 -			XenbusState new_state);
  15.187 -
  15.188 -
  15.189 -/**
  15.190 - * Grant access to the given ring_mfn to the peer of the given device.  Return
  15.191 - * 0 on success, or -errno on error.  On error, the device will switch to
  15.192 - * XenbusStateClosing, and the error will be saved in the store.
  15.193 - */
  15.194 -int xenbus_grant_ring(struct xenbus_device *dev, unsigned long ring_mfn);
  15.195 -
  15.196 -
  15.197 -/**
  15.198 - * Allocate an event channel for the given xenbus_device, assigning the newly
  15.199 - * created local port to *port.  Return 0 on success, or -errno on error.  On
  15.200 - * error, the device will switch to XenbusStateClosing, and the error will be
  15.201 - * saved in the store.
  15.202 - */
  15.203 -int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port);
  15.204 -
  15.205 -
  15.206 -/**
  15.207 - * Return the state of the driver rooted at the given store path, or
  15.208 - * XenbusStateClosed if no state can be read.
  15.209 - */
  15.210 -XenbusState xenbus_read_driver_state(const char *path);
  15.211 -
  15.212 -
  15.213 -/***
  15.214 - * Report the given negative errno into the store, along with the given
  15.215 - * formatted message.
  15.216 - */
  15.217 -void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt,
  15.218 -		      ...);
  15.219 -
  15.220 -
  15.221 -/***
  15.222 - * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
  15.223 - * xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly
  15.224 - * closedown of this driver and its peer.
  15.225 - */
  15.226 -void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt,
  15.227 -		      ...);
  15.228 -
  15.229 -
  15.230 -#endif /* _ASM_XEN_XENBUS_H */
  15.231 +#endif /* XENBUS_H__ */
    16.1 --- a/extras/mini-os/kernel.c	Mon Mar 27 15:36:47 2006 -0700
    16.2 +++ b/extras/mini-os/kernel.c	Tue Mar 28 08:54:58 2006 -0700
    16.3 @@ -35,7 +35,6 @@
    16.4  #include <lib.h>
    16.5  #include <sched.h>
    16.6  #include <xenbus.h>
    16.7 -#include "xenbus/xenbus_comms.h"
    16.8  
    16.9  /*
   16.10   * Shared page for communicating with the hypervisor.
   16.11 @@ -76,7 +75,15 @@ static shared_info_t *map_shared_info(un
   16.12  }
   16.13  
   16.14  
   16.15 -extern void init_console(void);
   16.16 +void test_xenbus(void);
   16.17 +
   16.18 +/* Do initialisation from a thread once the scheduler's available */
   16.19 +static void init_xs(void *ign)
   16.20 +{
   16.21 +    init_xenbus();
   16.22 +
   16.23 +    test_xenbus();
   16.24 +}
   16.25  
   16.26  /*
   16.27   * INITIAL C ENTRY POINT.
   16.28 @@ -84,11 +91,13 @@ extern void init_console(void);
   16.29  void start_kernel(start_info_t *si)
   16.30  {
   16.31      static char hello[] = "Bootstrapping...\n";
   16.32 +
   16.33      (void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(hello), hello);
   16.34  
   16.35      /* Copy the start_info struct to a globally-accessible area. */
   16.36 +    /* WARN: don't do printk before here, it uses information from
   16.37 +       shared_info. Use xprintk instead. */
   16.38      memcpy(&start_info, si, sizeof(*si));
   16.39 -
   16.40      /* Grab the shared_info pointer and put it in a safe place. */
   16.41      HYPERVISOR_shared_info = map_shared_info(start_info.shared_info);
   16.42  
   16.43 @@ -120,28 +129,24 @@ void start_kernel(start_info_t *si)
   16.44             si->cmd_line ? (const char *)si->cmd_line : "NULL");
   16.45  
   16.46  
   16.47 -    /*
   16.48 -     * If used for porting another OS, start here to figure out your
   16.49 -     * guest os entry point. Otherwise continue below...
   16.50 -     */
   16.51 -    /* init memory management */
   16.52 +    /* Init memory management. */
   16.53      init_mm();
   16.54  
   16.55 -    /* set up events */
   16.56 +    /* Set up events. */
   16.57      init_events();
   16.58      
   16.59 -    /* init time and timers */
   16.60 +    /* Init time and timers. */
   16.61      init_time();
   16.62  
   16.63 -    /* init the console driver */
   16.64 +    /* Init the console driver. */
   16.65      init_console();
   16.66 -
   16.67 -    /* init scheduler */
   16.68 + 
   16.69 +   /* Init scheduler. */
   16.70      init_sched();
   16.71 -
   16.72 -    /* init xenbus */
   16.73 -    xs_init();
   16.74 -   
   16.75 + 
   16.76 +    /* Init XenBus from a separate thread */
   16.77 +    create_thread("init_xs", init_xs, NULL);
   16.78 +    
   16.79      /* Everything initialised, start idle thread */
   16.80      run_idle_thread();
   16.81  }
   16.82 @@ -156,6 +161,6 @@ void start_kernel(start_info_t *si)
   16.83  
   16.84  void do_exit(void)
   16.85  {
   16.86 -    printk("do_exit called!\n");
   16.87 +    printk("Do_exit called!\n");
   16.88      for ( ;; ) HYPERVISOR_sched_op(SCHEDOP_shutdown, SHUTDOWN_crash);
   16.89  }
    17.1 --- a/extras/mini-os/minios-x86_32.lds	Mon Mar 27 15:36:47 2006 -0700
    17.2 +++ b/extras/mini-os/minios-x86_32.lds	Tue Mar 28 08:54:58 2006 -0700
    17.3 @@ -21,15 +21,6 @@ SECTIONS
    17.4  
    17.5    _edata = .;			/* End of data section */
    17.6  
    17.7 -  . = ALIGN(8192);		/* init_task */
    17.8 -  .data.init_task : { *(.data.init_task) }
    17.9 -
   17.10 -  . = ALIGN(4096);
   17.11 -  .data.page_aligned : { *(.data.idt) }
   17.12 -
   17.13 -  . = ALIGN(32);
   17.14 -  .data.cacheline_aligned : { *(.data.cacheline_aligned) }
   17.15 -
   17.16    __bss_start = .;		/* BSS */
   17.17    .bss : {
   17.18  	*(.bss)
    18.1 --- a/extras/mini-os/mm.c	Mon Mar 27 15:36:47 2006 -0700
    18.2 +++ b/extras/mini-os/mm.c	Tue Mar 28 08:54:58 2006 -0700
    18.3 @@ -51,7 +51,6 @@
    18.4  unsigned long *phys_to_machine_mapping;
    18.5  extern char *stack;
    18.6  extern char _text, _etext, _edata, _end;
    18.7 -extern void do_exit(void);
    18.8  extern void page_walk(unsigned long virt_addr);
    18.9  
   18.10  /*********************
   18.11 @@ -373,7 +372,7 @@ void new_pt_frame(unsigned long *pt_pfn,
   18.12      unsigned long *tab = (unsigned long *)start_info.pt_base;
   18.13      unsigned long pt_page = (unsigned long)pfn_to_virt(*pt_pfn); 
   18.14      unsigned long prot_e, prot_t, pincmd;
   18.15 -    mmu_update_t mmu_updates[0];
   18.16 +    mmu_update_t mmu_updates[1];
   18.17      struct mmuext_op pin_request;
   18.18      
   18.19      DEBUG("Allocating new L%d pt frame for pt_pfn=%lx, "
    19.1 --- a/extras/mini-os/sched.c	Mon Mar 27 15:36:47 2006 -0700
    19.2 +++ b/extras/mini-os/sched.c	Tue Mar 28 08:54:58 2006 -0700
    19.3 @@ -65,6 +65,8 @@
    19.4  struct thread *idle_thread = NULL;
    19.5  LIST_HEAD(exited_threads);
    19.6  
    19.7 +void idle_thread_fn(void *unused);
    19.8 +
    19.9  void dump_stack(struct thread *thread)
   19.10  {
   19.11      unsigned long *bottom = (unsigned long *)thread->stack + 2048; 
   19.12 @@ -132,7 +134,7 @@ void schedule(void)
   19.13              xfree(thread);
   19.14          }
   19.15      }
   19.16 -    next = idle_thread;    
   19.17 +    next = idle_thread;   
   19.18      /* Thread list needs to be protected */
   19.19      list_for_each(iterator, &idle_thread->thread_list)
   19.20      {
   19.21 @@ -203,8 +205,13 @@ struct thread* create_thread(char *name,
   19.22      set_runnable(thread);
   19.23      
   19.24      local_irq_save(flags);
   19.25 -    if(idle_thread != NULL)
   19.26 +    if(idle_thread != NULL) {
   19.27          list_add_tail(&thread->thread_list, &idle_thread->thread_list); 
   19.28 +    } else if(function != idle_thread_fn)
   19.29 +    {
   19.30 +        printk("BUG: Not allowed to create thread before initialising scheduler.\n");
   19.31 +        BUG();
   19.32 +    }
   19.33      local_irq_restore(flags);
   19.34  
   19.35      return thread;
   19.36 @@ -282,19 +289,9 @@ void th_f2(void *data)
   19.37  
   19.38  void init_sched(void)
   19.39  {
   19.40 -    printk("Initialising scheduler\n");
   19.41 -       
   19.42 +    printk("Initialising scheduler, idle_thread %p\n", idle_thread);
   19.43 +
   19.44      idle_thread = create_thread("Idle", idle_thread_fn, NULL);
   19.45      INIT_LIST_HEAD(&idle_thread->thread_list);
   19.46 -
   19.47 -    
   19.48 -/*    create_thread("1", th_f1, (void *)0x1234);    
   19.49 -    create_thread("2", th_f1, (void *)0x1234);    
   19.50 -    create_thread("3", th_f1, (void *)0x1234);    
   19.51 -    create_thread("4", th_f1, (void *)0x1234);    
   19.52 -    create_thread("5", th_f1, (void *)0x1234);    
   19.53 -    create_thread("6", th_f1, (void *)0x1234);    
   19.54 -    create_thread("second", th_f2, NULL);
   19.55 -*/   
   19.56  }
   19.57  
    20.1 --- a/extras/mini-os/traps.c	Mon Mar 27 15:36:47 2006 -0700
    20.2 +++ b/extras/mini-os/traps.c	Tue Mar 28 08:54:58 2006 -0700
    20.3 @@ -29,11 +29,18 @@ void spurious_interrupt_bug(void);
    20.4  void machine_check(void);
    20.5  
    20.6  
    20.7 -extern void do_exit(void);
    20.8 -
    20.9  void dump_regs(struct pt_regs *regs)
   20.10  {
   20.11 -    printk("FIXME: proper register dump (with the stack dump)\n");
   20.12 +    printk("EIP: %x, EFLAGS %x.\n", regs->eip, regs->eflags);
   20.13 +    printk("EBX: %08x ECX: %08x EDX: %08x\n",
   20.14 +	   regs->ebx, regs->ecx, regs->edx);
   20.15 +    printk("ESI: %08x EDI: %08x EBP: %08x EAX: %08x\n",
   20.16 +	   regs->esi, regs->edi, regs->ebp, regs->eax);
   20.17 +    printk("DS: %04x ES: %04x orig_eax: %08x, eip: %08x\n",
   20.18 +	   regs->xds, regs->xes, regs->orig_eax, regs->eip);
   20.19 +    printk("CS: %04x EFLAGS: %08x esp: %08x ss: %04x\n",
   20.20 +	   regs->xcs, regs->eflags, regs->esp, regs->xss);
   20.21 +
   20.22  }	
   20.23  
   20.24  
   20.25 @@ -94,10 +101,14 @@ void page_walk(unsigned long virt_addres
   20.26  
   20.27  }
   20.28  
   20.29 -void do_page_fault(struct pt_regs *regs, unsigned long error_code,
   20.30 -								                     unsigned long addr)
   20.31 +#define read_cr2() \
   20.32 +        (HYPERVISOR_shared_info->vcpu_info[smp_processor_id()].arch.cr2)
   20.33 +
   20.34 +void do_page_fault(struct pt_regs *regs, unsigned long error_code)
   20.35  {
   20.36 -    printk("Page fault at linear address %p\n", addr);
   20.37 +    unsigned long addr = read_cr2();
   20.38 +    printk("Page fault at linear address %p, regs %p, code %lx\n", addr, regs,
   20.39 +	   error_code);
   20.40      dump_regs(regs);
   20.41  #ifdef __x86_64__
   20.42      /* FIXME: _PAGE_PSE */
    21.1 --- a/extras/mini-os/x86_32.S	Mon Mar 27 15:36:47 2006 -0700
    21.2 +++ b/extras/mini-os/x86_32.S	Tue Mar 28 08:54:58 2006 -0700
    21.3 @@ -30,10 +30,10 @@ shared_info:
    21.4  hypercall_page:
    21.5          .org 0x3000
    21.6  
    21.7 -ES		= 0x20
    21.8 -ORIG_EAX	= 0x24
    21.9 -EIP		= 0x28
   21.10 -CS		= 0x2C
   21.11 +ES		= 0x1c
   21.12 +ORIG_EAX	= 0x20
   21.13 +EIP		= 0x24
   21.14 +CS		= 0x28
   21.15  
   21.16  #define ENTRY(X) .globl X ; X :
   21.17  
   21.18 @@ -94,32 +94,6 @@ do_exception:
   21.19  	call *%edi
   21.20      addl $8,%esp
   21.21      
   21.22 -/*    pushl %ds
   21.23 -	pushl %eax
   21.24 -	xorl %eax,%eax
   21.25 -	pushl %ebp
   21.26 -	pushl %edi
   21.27 -	pushl %esi
   21.28 -	pushl %edx
   21.29 -	decl %eax			# eax = -1
   21.30 -	pushl %ecx
   21.31 -	pushl %ebx
   21.32 -	cld
   21.33 -	movl %es,%ecx
   21.34 -	movl ORIG_EAX(%esp), %esi	# get the error code
   21.35 -	movl ES(%esp), %edi		# get the function address
   21.36 -	movl %eax, ORIG_EAX(%esp)
   21.37 -	movl %ecx, ES(%esp)
   21.38 -	movl %esp,%edx
   21.39 -	pushl %esi			# push the error code
   21.40 -	pushl %edx			# push the pt_regs pointer
   21.41 -	movl $(__KERNEL_DS),%edx
   21.42 -	movl %edx,%ds
   21.43 -	movl %edx,%es
   21.44 -	call *%edi
   21.45 -	addl $8,%esp  */
   21.46 -
   21.47 -        
   21.48  ret_from_exception:
   21.49          movb CS(%esp),%cl
   21.50  	test $2,%cl          # slow return to ring 2 or 3
   21.51 @@ -290,15 +264,16 @@ ENTRY(page_fault)
   21.52  	pushl %ecx
   21.53  	pushl %ebx
   21.54  	cld
   21.55 -	movl %es,%edi
   21.56 -	movl ES(%esp), %ecx		/* get the faulting address */
   21.57 -	movl ORIG_EAX(%esp), %edx	/* get the error code */
   21.58 +	movl ORIG_EAX(%esp), %edi
   21.59  	movl %eax, ORIG_EAX(%esp)
   21.60 -	movl %edi, ES(%esp)
   21.61 +	movl %es, %ecx
   21.62 +	movl %ecx, ES(%esp)
   21.63  	movl $(__KERNEL_DS),%eax
   21.64  	movl %eax, %ds
   21.65  	movl %eax, %es
   21.66 -	movl %esp,%eax			/* pt_regs pointer */
   21.67 +	pushl %edi
   21.68 +	movl %esp, %eax
   21.69 +	pushl %eax
   21.70  	call do_page_fault
   21.71  	jmp ret_from_exception
   21.72  
    22.1 --- a/extras/mini-os/xenbus/Makefile	Mon Mar 27 15:36:47 2006 -0700
    22.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.3 @@ -1,9 +0,0 @@
    22.4 -all: xenstore.h xenbus_comms.o xenbus_xs.o xenbus_probe.o
    22.5 -
    22.6 -xenstore.h:
    22.7 -	[ -e xenstored.h ] || ln -sf ../../../tools/xenstore/xenstored.h xenstored.h
    22.8 -
    22.9 -clean:
   22.10 -	#Taken care of by main Makefile
   22.11 -	#rm xenstored.h
   22.12 -	#rm *.o
    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/extras/mini-os/xenbus/xenbus.c	Tue Mar 28 08:54:58 2006 -0700
    23.3 @@ -0,0 +1,387 @@
    23.4 +/* 
    23.5 + ****************************************************************************
    23.6 + * (C) 2006 - Cambridge University
    23.7 + ****************************************************************************
    23.8 + *
    23.9 + *        File: mm.c
   23.10 + *      Author: Steven Smith (sos22@cam.ac.uk) 
   23.11 + *     Changes: Grzegorz Milos (gm281@cam.ac.uk)
   23.12 + *              
   23.13 + *        Date: Mar 2006, chages Aug 2005
   23.14 + * 
   23.15 + * Environment: Xen Minimal OS
   23.16 + * Description: Minimal implementation of xenbus
   23.17 + *
   23.18 + ****************************************************************************
   23.19 + **/
   23.20 +#include <os.h>
   23.21 +#include <mm.h>
   23.22 +#include <traps.h>
   23.23 +#include <lib.h>
   23.24 +#include <xenbus.h>
   23.25 +#include <events.h>
   23.26 +#include <errno.h>
   23.27 +#include <sched.h>
   23.28 +#include <wait.h>
   23.29 +#include <xen/io/xs_wire.h>
   23.30 +#include <spinlock.h>
   23.31 +#include <xmalloc.h>
   23.32 +
   23.33 +#define BUG_ON(x) do { \
   23.34 +    if (x) {printk("BUG at %s:%d\n", __FILE__, __LINE__); BUG(); } \
   23.35 +} while (0)
   23.36 +
   23.37 +#define min(x,y) ({                       \
   23.38 +        typeof(x) tmpx = (x);                 \
   23.39 +        typeof(y) tmpy = (y);                 \
   23.40 +        tmpx < tmpy ? tmpx : tmpy;            \
   23.41 +        })
   23.42 +
   23.43 +#ifdef XENBUS_DEBUG
   23.44 +#define DEBUG(_f, _a...) \
   23.45 +    printk("MINI_OS(file=xenbus.c, line=%d) " _f , __LINE__, ## _a)
   23.46 +#else
   23.47 +#define DEBUG(_f, _a...)    ((void)0)
   23.48 +#endif
   23.49 +
   23.50 +
   23.51 +static struct xenstore_domain_interface *xenstore_buf;
   23.52 +static DECLARE_WAIT_QUEUE_HEAD(xb_waitq);
   23.53 +struct xenbus_req_info 
   23.54 +{
   23.55 +    int in_use:1;
   23.56 +    struct wait_queue_head waitq;
   23.57 +    void *reply;
   23.58 +};
   23.59 +
   23.60 +#define NR_REQS 32
   23.61 +static struct xenbus_req_info req_info[NR_REQS];
   23.62 +
   23.63 +static void memcpy_from_ring(const void *Ring,
   23.64 +        void *Dest,
   23.65 +        int off,
   23.66 +        int len)
   23.67 +{
   23.68 +    int c1, c2;
   23.69 +    const char *ring = Ring;
   23.70 +    char *dest = Dest;
   23.71 +    c1 = min(len, XENSTORE_RING_SIZE - off);
   23.72 +    c2 = len - c1;
   23.73 +    memcpy(dest, ring + off, c1);
   23.74 +    memcpy(dest + c1, ring, c2);
   23.75 +}
   23.76 +
   23.77 +static void xenbus_thread_func(void *ign)
   23.78 +{
   23.79 +    struct xsd_sockmsg msg;
   23.80 +    unsigned prod;
   23.81 +
   23.82 +    for (;;) 
   23.83 +    {
   23.84 +        wait_event(xb_waitq, prod != xenstore_buf->rsp_prod);
   23.85 +        while (1) 
   23.86 +        {
   23.87 +            prod = xenstore_buf->rsp_prod;
   23.88 +            DEBUG("Rsp_cons %d, rsp_prod %d.\n", xenstore_buf->rsp_cons,
   23.89 +                    xenstore_buf->rsp_prod);
   23.90 +            if (xenstore_buf->rsp_prod - xenstore_buf->rsp_cons < sizeof(msg))
   23.91 +                break;
   23.92 +            rmb();
   23.93 +            memcpy_from_ring(xenstore_buf->rsp,
   23.94 +                    &msg,
   23.95 +                    MASK_XENSTORE_IDX(xenstore_buf->rsp_cons),
   23.96 +                    sizeof(msg));
   23.97 +            DEBUG("Msg len %d, %d avail, id %d.\n",
   23.98 +                    msg.len + sizeof(msg),
   23.99 +                    xenstore_buf->rsp_prod - xenstore_buf->rsp_cons,
  23.100 +                    msg.req_id);
  23.101 +            if (xenstore_buf->rsp_prod - xenstore_buf->rsp_cons <
  23.102 +                    sizeof(msg) + msg.len)
  23.103 +                break;
  23.104 +
  23.105 +            DEBUG("Message is good.\n");
  23.106 +            req_info[msg.req_id].reply = malloc(sizeof(msg) + msg.len);
  23.107 +            memcpy_from_ring(xenstore_buf->rsp,
  23.108 +                    req_info[msg.req_id].reply,
  23.109 +                    MASK_XENSTORE_IDX(xenstore_buf->rsp_cons),
  23.110 +                    msg.len + sizeof(msg));
  23.111 +            wake_up(&req_info[msg.req_id].waitq);
  23.112 +            xenstore_buf->rsp_cons += msg.len + sizeof(msg);
  23.113 +        }
  23.114 +    }
  23.115 +}
  23.116 +
  23.117 +static void xenbus_evtchn_handler(int port, struct pt_regs *regs)
  23.118 +{
  23.119 +    wake_up(&xb_waitq);
  23.120 +}
  23.121 +
  23.122 +static int nr_live_reqs;
  23.123 +static spinlock_t req_lock = SPIN_LOCK_UNLOCKED;
  23.124 +static DECLARE_WAIT_QUEUE_HEAD(req_wq);
  23.125 +
  23.126 +/* Release a xenbus identifier */
  23.127 +static void release_xenbus_id(int id)
  23.128 +{
  23.129 +    BUG_ON(!req_info[id].in_use);
  23.130 +    spin_lock(&req_lock);
  23.131 +    nr_live_reqs--;
  23.132 +    if (nr_live_reqs == NR_REQS - 1)
  23.133 +        wake_up(&req_wq);
  23.134 +    spin_unlock(&req_lock);
  23.135 +}
  23.136 +
  23.137 +/* Allocate an identifier for a xenbus request.  Blocks if none are
  23.138 +   available. */
  23.139 +static int allocate_xenbus_id(void)
  23.140 +{
  23.141 +    static int probe;
  23.142 +    int o_probe;
  23.143 +
  23.144 +    while (1) 
  23.145 +    {
  23.146 +        spin_lock(&req_lock);
  23.147 +        if (nr_live_reqs < NR_REQS)
  23.148 +            break;
  23.149 +        spin_unlock(&req_lock);
  23.150 +        wait_event(req_wq, (nr_live_reqs < NR_REQS));
  23.151 +    }
  23.152 +
  23.153 +    o_probe = probe;
  23.154 +    for (;;) 
  23.155 +    {
  23.156 +        if (!req_info[o_probe].in_use)
  23.157 +            break;
  23.158 +        o_probe = (o_probe + 1) % NR_REQS;
  23.159 +        BUG_ON(o_probe == probe);
  23.160 +    }
  23.161 +    nr_live_reqs++;
  23.162 +    req_info[o_probe].in_use = 1;
  23.163 +    probe = o_probe + 1;
  23.164 +    spin_unlock(&req_lock);
  23.165 +    init_waitqueue_head(&req_info[o_probe].waitq);
  23.166 +    return o_probe;
  23.167 +}
  23.168 +
  23.169 +/* Initialise xenbus. */
  23.170 +void init_xenbus(void)
  23.171 +{
  23.172 +    int err;
  23.173 +    DEBUG("init_xenbus called.\n");
  23.174 +    xenstore_buf = mfn_to_virt(start_info.store_mfn);
  23.175 +    create_thread("xenstore", xenbus_thread_func, NULL);
  23.176 +    DEBUG("buf at %p.\n", xenstore_buf);
  23.177 +    err = bind_evtchn(start_info.store_evtchn,
  23.178 +            xenbus_evtchn_handler);
  23.179 +    DEBUG("xenbus on irq %d\n", err);
  23.180 +}
  23.181 +
  23.182 +struct write_req {
  23.183 +    const void *data;
  23.184 +    unsigned len;
  23.185 +};
  23.186 +
  23.187 +/* Send data to xenbus.  This can block.  All of the requests are seen
  23.188 +   by xenbus as if sent atomically.  The header is added
  23.189 +   automatically, using type %type, req_id %req_id, and trans_id
  23.190 +   %trans_id. */
  23.191 +static void xb_write(int type, int req_id, int trans_id,
  23.192 +        const struct write_req *req, int nr_reqs)
  23.193 +{
  23.194 +    XENSTORE_RING_IDX prod;
  23.195 +    int r;
  23.196 +    int len = 0;
  23.197 +    const struct write_req *cur_req;
  23.198 +    int req_off;
  23.199 +    int total_off;
  23.200 +    int this_chunk;
  23.201 +    struct xsd_sockmsg m = {.type = type, .req_id = req_id,
  23.202 +        .tx_id = trans_id };
  23.203 +    struct write_req header_req = { &m, sizeof(m) };
  23.204 +
  23.205 +    for (r = 0; r < nr_reqs; r++)
  23.206 +        len += req[r].len;
  23.207 +    m.len = len;
  23.208 +    len += sizeof(m);
  23.209 +
  23.210 +    cur_req = &header_req;
  23.211 +
  23.212 +    BUG_ON(len > XENSTORE_RING_SIZE);
  23.213 +    /* Wait for the ring to drain to the point where we can send the
  23.214 +       message. */
  23.215 +    prod = xenstore_buf->req_prod;
  23.216 +    if (prod + len - xenstore_buf->req_cons > XENSTORE_RING_SIZE) 
  23.217 +    {
  23.218 +        /* Wait for there to be space on the ring */
  23.219 +        DEBUG("prod %d, len %d, cons %d, size %d; waiting.\n",
  23.220 +                prod, len, xenstore_buf->req_cons, XENSTORE_RING_SIZE);
  23.221 +        wait_event(xb_waitq,
  23.222 +                xenstore_buf->req_prod + len - xenstore_buf->req_cons <=
  23.223 +                XENSTORE_RING_SIZE);
  23.224 +        DEBUG("Back from wait.\n");
  23.225 +        prod = xenstore_buf->req_prod;
  23.226 +    }
  23.227 +
  23.228 +    /* We're now guaranteed to be able to send the message without
  23.229 +       overflowing the ring.  Do so. */
  23.230 +    total_off = 0;
  23.231 +    req_off = 0;
  23.232 +    while (total_off < len) 
  23.233 +    {
  23.234 +        this_chunk = min(cur_req->len - req_off,
  23.235 +                XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod));
  23.236 +        memcpy((char *)xenstore_buf->req + MASK_XENSTORE_IDX(prod),
  23.237 +                (char *)cur_req->data + req_off, this_chunk);
  23.238 +        prod += this_chunk;
  23.239 +        req_off += this_chunk;
  23.240 +        total_off += this_chunk;
  23.241 +        if (req_off == cur_req->len) 
  23.242 +        {
  23.243 +            req_off = 0;
  23.244 +            if (cur_req == &header_req)
  23.245 +                cur_req = req;
  23.246 +            else
  23.247 +                cur_req++;
  23.248 +        }
  23.249 +    }
  23.250 +
  23.251 +    DEBUG("Complete main loop of xb_write.\n");
  23.252 +    BUG_ON(req_off != 0);
  23.253 +    BUG_ON(total_off != len);
  23.254 +    BUG_ON(prod > xenstore_buf->req_cons + XENSTORE_RING_SIZE);
  23.255 +
  23.256 +    /* Remote must see entire message before updating indexes */
  23.257 +    wmb();
  23.258 +
  23.259 +    xenstore_buf->req_prod += len;
  23.260 +
  23.261 +    /* Send evtchn to notify remote */
  23.262 +    notify_remote_via_evtchn(start_info.store_evtchn);
  23.263 +}
  23.264 +
  23.265 +/* Send a mesasge to xenbus, in the same fashion as xb_write, and
  23.266 +   block waiting for a reply.  The reply is malloced and should be
  23.267 +   freed by the caller. */
  23.268 +static void *xenbus_msg_reply(int type,
  23.269 +        int trans,
  23.270 +        struct write_req *io,
  23.271 +        int nr_reqs)
  23.272 +{
  23.273 +    int id;
  23.274 +    DEFINE_WAIT(w);
  23.275 +    void *rep;
  23.276 +    struct xsd_sockmsg *repmsg;
  23.277 +
  23.278 +    id = allocate_xenbus_id();
  23.279 +    add_waiter(w, req_info[id].waitq);
  23.280 +
  23.281 +    xb_write(type, id, trans, io, nr_reqs);
  23.282 +
  23.283 +    schedule();
  23.284 +    wake(current);
  23.285 +
  23.286 +    rep = req_info[id].reply;
  23.287 +    repmsg = rep;
  23.288 +    BUG_ON(repmsg->req_id != id);
  23.289 +    release_xenbus_id(id);
  23.290 +
  23.291 +    return rep;
  23.292 +}
  23.293 +
  23.294 +/* Send a debug message to xenbus.  Can block. */
  23.295 +static void xenbus_debug_msg(const char *msg)
  23.296 +{
  23.297 +    int len = strlen(msg);
  23.298 +    struct write_req req[] = {
  23.299 +        { "print", sizeof("print") },
  23.300 +        { msg, len },
  23.301 +        { "", 1 }};
  23.302 +    void *reply;
  23.303 +    struct xsd_sockmsg *repmsg;
  23.304 +
  23.305 +    reply = xenbus_msg_reply(XS_DEBUG, 0, req, 3);
  23.306 +    repmsg = reply;
  23.307 +    DEBUG("Got a reply, type %d, id %d, len %d.\n",
  23.308 +            repmsg->type, repmsg->req_id, repmsg->len);
  23.309 +}
  23.310 +
  23.311 +/* List the contents of a directory.  Returns a malloc()ed array of
  23.312 +   pointers to malloc()ed strings.  The array is NULL terminated.  May
  23.313 +   block. */
  23.314 +static char **xenbus_ls(const char *pre)
  23.315 +{
  23.316 +    void *reply;
  23.317 +    struct xsd_sockmsg *repmsg;
  23.318 +    struct write_req req[] = { { pre, strlen(pre)+1 } };
  23.319 +    int nr_elems, x, i;
  23.320 +    char **res;
  23.321 +
  23.322 +    repmsg = xenbus_msg_reply(XS_DIRECTORY, 0, req, 1);
  23.323 +    reply = repmsg + 1;
  23.324 +    for (x = nr_elems = 0; x < repmsg->len; x++)
  23.325 +        nr_elems += (((char *)reply)[x] == 0);
  23.326 +    res = malloc(sizeof(res[0]) * (nr_elems + 1));
  23.327 +    for (x = i = 0; i < nr_elems; i++) {
  23.328 +        int l = strlen((char *)reply + x);
  23.329 +        res[i] = malloc(l + 1);
  23.330 +        memcpy(res[i], (char *)reply + x, l + 1);
  23.331 +        x += l + 1;
  23.332 +    }
  23.333 +    res[i] = NULL;
  23.334 +    free(repmsg);
  23.335 +    return res;
  23.336 +}
  23.337 +
  23.338 +static char *xenbus_read(const char *path)
  23.339 +{
  23.340 +    struct write_req req[] = { {path, strlen(path) + 1}};
  23.341 +    struct xsd_sockmsg *rep;
  23.342 +    char *res;
  23.343 +    rep = xenbus_msg_reply(XS_READ, 0, req, 1);
  23.344 +    res = malloc(rep->len + 1);
  23.345 +    memcpy(res, rep + 1, rep->len);
  23.346 +    res[rep->len] = 0;
  23.347 +    free(rep);
  23.348 +    return res;
  23.349 +}
  23.350 +
  23.351 +static void do_ls_test(const char *pre)
  23.352 +{
  23.353 +    char **dirs;
  23.354 +    int x;
  23.355 +
  23.356 +    DEBUG("ls %s...\n", pre);
  23.357 +    dirs = xenbus_ls(pre);
  23.358 +    for (x = 0; dirs[x]; x++) 
  23.359 +    {
  23.360 +        DEBUG("ls %s[%d] -> %s\n", pre, x, dirs[x]);
  23.361 +        free(dirs[x]);
  23.362 +    }
  23.363 +    free(dirs);
  23.364 +}
  23.365 +
  23.366 +static void do_read_test(const char *path)
  23.367 +{
  23.368 +    char *res;
  23.369 +    DEBUG("Read %s...\n", path);
  23.370 +    res = xenbus_read(path);
  23.371 +    DEBUG("Read %s -> %s.\n", path, res);
  23.372 +    free(res);
  23.373 +}
  23.374 +
  23.375 +/* Simple testing thing */
  23.376 +void test_xenbus(void)
  23.377 +{
  23.378 +    DEBUG("Doing xenbus test.\n");
  23.379 +    xenbus_debug_msg("Testing xenbus...\n");
  23.380 +
  23.381 +    DEBUG("Doing ls test.\n");
  23.382 +    do_ls_test("device");
  23.383 +    do_ls_test("device/vif");
  23.384 +    do_ls_test("device/vif/0");
  23.385 +
  23.386 +    DEBUG("Doing read test.\n");
  23.387 +    do_read_test("device/vif/0/mac");
  23.388 +    do_read_test("device/vif/0/backend");
  23.389 +    printk("Xenbus initialised.\n");
  23.390 +}
    24.1 --- a/extras/mini-os/xenbus/xenbus_comms.c	Mon Mar 27 15:36:47 2006 -0700
    24.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.3 @@ -1,184 +0,0 @@
    24.4 -/******************************************************************************
    24.5 - * xenbus_comms.c
    24.6 - *
    24.7 - * Low level code to talks to Xen Store: ringbuffer and event channel.
    24.8 - *
    24.9 - * Copyright (C) 2005 Rusty Russell, IBM Corporation
   24.10 - * 
   24.11 - * This file may be distributed separately from the Linux kernel, or
   24.12 - * incorporated into other software packages, subject to the following license:
   24.13 - * 
   24.14 - * Permission is hereby granted, free of charge, to any person obtaining a copy
   24.15 - * of this source file (the "Software"), to deal in the Software without
   24.16 - * restriction, including without limitation the rights to use, copy, modify,
   24.17 - * merge, publish, distribute, sublicense, and/or sell copies of the Software,
   24.18 - * and to permit persons to whom the Software is furnished to do so, subject to
   24.19 - * the following conditions:
   24.20 - * 
   24.21 - * The above copyright notice and this permission notice shall be included in
   24.22 - * all copies or substantial portions of the Software.
   24.23 - * 
   24.24 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   24.25 - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   24.26 - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   24.27 - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   24.28 - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   24.29 - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   24.30 - * IN THE SOFTWARE.
   24.31 - */
   24.32 -#include <types.h>
   24.33 -#include <wait.h>
   24.34 -#include <mm.h>
   24.35 -#include <hypervisor.h>
   24.36 -#include <events.h>
   24.37 -#include <os.h>
   24.38 -#include <lib.h>
   24.39 -#include <xenbus.h>
   24.40 -#include "xenbus_comms.h"
   24.41 -
   24.42 -static int xenbus_irq;
   24.43 -
   24.44 -extern void xenbus_probe(void *);
   24.45 -extern int xenstored_ready;
   24.46 -
   24.47 -DECLARE_WAIT_QUEUE_HEAD(xb_waitq);
   24.48 -
   24.49 -static inline struct xenstore_domain_interface *xenstore_domain_interface(void)
   24.50 -{
   24.51 -	return mfn_to_virt(start_info.store_mfn);
   24.52 -}
   24.53 -
   24.54 -static void wake_waiting(int port, struct pt_regs *regs)
   24.55 -{
   24.56 -	wake_up(&xb_waitq);
   24.57 -}
   24.58 -
   24.59 -static int check_indexes(XENSTORE_RING_IDX cons, XENSTORE_RING_IDX prod)
   24.60 -{
   24.61 -	return ((prod - cons) <= XENSTORE_RING_SIZE);
   24.62 -}
   24.63 -
   24.64 -static void *get_output_chunk(XENSTORE_RING_IDX cons,
   24.65 -			      XENSTORE_RING_IDX prod,
   24.66 -			      char *buf, uint32_t *len)
   24.67 -{
   24.68 -	*len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod);
   24.69 -	if ((XENSTORE_RING_SIZE - (prod - cons)) < *len)
   24.70 -		*len = XENSTORE_RING_SIZE - (prod - cons);
   24.71 -	return buf + MASK_XENSTORE_IDX(prod);
   24.72 -}
   24.73 -
   24.74 -static const void *get_input_chunk(XENSTORE_RING_IDX cons,
   24.75 -				   XENSTORE_RING_IDX prod,
   24.76 -				   const char *buf, uint32_t *len)
   24.77 -{
   24.78 -	*len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(cons);
   24.79 -	if ((prod - cons) < *len)
   24.80 -		*len = prod - cons;
   24.81 -	return buf + MASK_XENSTORE_IDX(cons);
   24.82 -}
   24.83 -
   24.84 -int xb_write(const void *data, unsigned len)
   24.85 -{
   24.86 -	struct xenstore_domain_interface *intf = xenstore_domain_interface();
   24.87 -	XENSTORE_RING_IDX cons, prod;
   24.88 -
   24.89 -	while (len != 0) {
   24.90 -		void *dst;
   24.91 -		unsigned int avail;
   24.92 -
   24.93 -		wait_event(xb_waitq, (intf->req_prod - intf->req_cons) !=
   24.94 -			   XENSTORE_RING_SIZE);
   24.95 -
   24.96 -		/* Read indexes, then verify. */
   24.97 -		cons = intf->req_cons;
   24.98 -		prod = intf->req_prod;
   24.99 -		mb();
  24.100 -		if (!check_indexes(cons, prod))
  24.101 -			return -EIO;
  24.102 -
  24.103 -		dst = get_output_chunk(cons, prod, intf->req, &avail);
  24.104 -		if (avail == 0)
  24.105 -			continue;
  24.106 -		if (avail > len)
  24.107 -			avail = len;
  24.108 -
  24.109 -		memcpy(dst, data, avail);
  24.110 -		data = (void*) ( (unsigned long)data + avail );
  24.111 -		len -= avail;
  24.112 -
  24.113 -		/* Other side must not see new header until data is there. */
  24.114 -		wmb();
  24.115 -		intf->req_prod += avail;
  24.116 -
  24.117 -		/* This implies mb() before other side sees interrupt. */
  24.118 -		notify_remote_via_evtchn(start_info.store_evtchn);
  24.119 -	}
  24.120 -
  24.121 -	return 0;
  24.122 -}
  24.123 -
  24.124 -int xb_read(void *data, unsigned len)
  24.125 -{
  24.126 -	struct xenstore_domain_interface *intf = xenstore_domain_interface();
  24.127 -	XENSTORE_RING_IDX cons, prod;
  24.128 -
  24.129 -	while (len != 0) {
  24.130 -		unsigned int avail;
  24.131 -		const char *src;
  24.132 -
  24.133 -		wait_event(xb_waitq,
  24.134 -			   intf->rsp_cons != intf->rsp_prod);
  24.135 -
  24.136 -		/* Read indexes, then verify. */
  24.137 -		cons = intf->rsp_cons;
  24.138 -		prod = intf->rsp_prod;
  24.139 -		mb();
  24.140 -		if (!check_indexes(cons, prod))
  24.141 -			return -EIO;
  24.142 -
  24.143 -		src = get_input_chunk(cons, prod, intf->rsp, &avail);
  24.144 -		if (avail == 0)
  24.145 -			continue;
  24.146 -		if (avail > len)
  24.147 -			avail = len;
  24.148 -
  24.149 -		/* We must read header before we read data. */
  24.150 -		rmb();
  24.151 -
  24.152 -		memcpy(data, src, avail);
  24.153 -		data = (void*) ( (unsigned long)data + avail );
  24.154 -		len -= avail;
  24.155 -
  24.156 -		/* Other side must not see free space until we've copied out */
  24.157 -		mb();
  24.158 -		intf->rsp_cons += avail;
  24.159 -
  24.160 -		printk("Finished read of %i bytes (%i to go)\n", avail, len);
  24.161 -
  24.162 -		/* Implies mb(): they will see new header. */
  24.163 -		notify_remote_via_evtchn(start_info.store_evtchn);
  24.164 -	}
  24.165 -
  24.166 -	return 0;
  24.167 -}
  24.168 -
  24.169 -/* Set up interrupt handler off store event channel. */
  24.170 -int xb_init_comms(void)
  24.171 -{
  24.172 -	int err;
  24.173 -
  24.174 -	if (xenbus_irq)
  24.175 -		unbind_evtchn(xenbus_irq);
  24.176 -
  24.177 -	err = bind_evtchn(
  24.178 -		start_info.store_evtchn, wake_waiting);
  24.179 -	if (err <= 0) {
  24.180 -		printk("XENBUS request irq failed %i\n", err);
  24.181 -		return err;
  24.182 -	}
  24.183 -
  24.184 -	xenbus_irq = err;
  24.185 -
  24.186 -	return 0;
  24.187 -}
    25.1 --- a/extras/mini-os/xenbus/xenbus_comms.h	Mon Mar 27 15:36:47 2006 -0700
    25.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    25.3 @@ -1,40 +0,0 @@
    25.4 -/*
    25.5 - * Private include for xenbus communications.
    25.6 - * 
    25.7 - * Copyright (C) 2005 Rusty Russell, IBM Corporation
    25.8 - *
    25.9 - * This file may be distributed separately from the Linux kernel, or
   25.10 - * incorporated into other software packages, subject to the following license:
   25.11 - * 
   25.12 - * Permission is hereby granted, free of charge, to any person obtaining a copy
   25.13 - * of this source file (the "Software"), to deal in the Software without
   25.14 - * restriction, including without limitation the rights to use, copy, modify,
   25.15 - * merge, publish, distribute, sublicense, and/or sell copies of the Software,
   25.16 - * and to permit persons to whom the Software is furnished to do so, subject to
   25.17 - * the following conditions:
   25.18 - * 
   25.19 - * The above copyright notice and this permission notice shall be included in
   25.20 - * all copies or substantial portions of the Software.
   25.21 - * 
   25.22 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   25.23 - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   25.24 - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   25.25 - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   25.26 - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   25.27 - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   25.28 - * IN THE SOFTWARE.
   25.29 - */
   25.30 -
   25.31 -#ifndef _XENBUS_COMMS_H
   25.32 -#define _XENBUS_COMMS_H
   25.33 -
   25.34 -int xs_init(void);
   25.35 -int xb_init_comms(void);
   25.36 -
   25.37 -/* Low level routines. */
   25.38 -int xb_write(const void *data, unsigned len);
   25.39 -int xb_read(void *data, unsigned len);
   25.40 -int xs_input_avail(void);
   25.41 -extern struct wait_queue_head xb_waitq;
   25.42 -
   25.43 -#endif /* _XENBUS_COMMS_H */
    26.1 --- a/extras/mini-os/xenbus/xenbus_xs.c	Mon Mar 27 15:36:47 2006 -0700
    26.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    26.3 @@ -1,796 +0,0 @@
    26.4 -/******************************************************************************
    26.5 - * xenbus_xs.c
    26.6 - *
    26.7 - * This is the kernel equivalent of the "xs" library.  We don't need everything
    26.8 - * and we use xenbus_comms for communication.
    26.9 - *
   26.10 - * Copyright (C) 2005 Rusty Russell, IBM Corporation
   26.11 - * 
   26.12 - * This file may be distributed separately from the Linux kernel, or
   26.13 - * incorporated into other software packages, subject to the following license:
   26.14 - * 
   26.15 - * Permission is hereby granted, free of charge, to any person obtaining a copy
   26.16 - * of this source file (the "Software"), to deal in the Software without
   26.17 - * restriction, including without limitation the rights to use, copy, modify,
   26.18 - * merge, publish, distribute, sublicense, and/or sell copies of the Software,
   26.19 - * and to permit persons to whom the Software is furnished to do so, subject to
   26.20 - * the following conditions:
   26.21 - * 
   26.22 - * The above copyright notice and this permission notice shall be included in
   26.23 - * all copies or substantial portions of the Software.
   26.24 - * 
   26.25 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   26.26 - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   26.27 - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   26.28 - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   26.29 - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   26.30 - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   26.31 - * IN THE SOFTWARE.
   26.32 - */
   26.33 -#include <errno.h>
   26.34 -#include <types.h>
   26.35 -#include <list.h>
   26.36 -#include <lib.h>
   26.37 -#include <err.h>
   26.38 -#include <os.h>
   26.39 -#include <xmalloc.h>
   26.40 -#include <fcntl.h>
   26.41 -#include <xenbus.h>
   26.42 -#include <wait.h>
   26.43 -#include <sched.h>
   26.44 -#include <semaphore.h>
   26.45 -#include <spinlock.h>
   26.46 -#include <xen/io/xs_wire.h>
   26.47 -#include "xenbus_comms.h"
   26.48 -
   26.49 -#define streq(a, b) (strcmp((a), (b)) == 0)
   26.50 -
   26.51 -struct xs_stored_msg {
   26.52 -	struct list_head list;
   26.53 -
   26.54 -	struct xsd_sockmsg hdr;
   26.55 -
   26.56 -	union {
   26.57 -		/* Queued replies. */
   26.58 -		struct {
   26.59 -			char *body;
   26.60 -		} reply;
   26.61 -
   26.62 -		/* Queued watch events. */
   26.63 -		struct {
   26.64 -			struct xenbus_watch *handle;
   26.65 -			char **vec;
   26.66 -			unsigned int vec_size;
   26.67 -		} watch;
   26.68 -	} u;
   26.69 -};
   26.70 -
   26.71 -struct xs_handle {
   26.72 -	/* A list of replies. Currently only one will ever be outstanding. */
   26.73 -	struct list_head reply_list;
   26.74 -	spinlock_t reply_lock;
   26.75 -	struct wait_queue_head reply_waitq;
   26.76 -
   26.77 -	/* One request at a time. */
   26.78 -	struct semaphore request_mutex;
   26.79 -
   26.80 -	/* Protect transactions against save/restore. */
   26.81 -	struct rw_semaphore suspend_mutex;
   26.82 -};
   26.83 -
   26.84 -static struct xs_handle xs_state;
   26.85 -
   26.86 -/* List of registered watches, and a lock to protect it. */
   26.87 -static LIST_HEAD(watches);
   26.88 -static DEFINE_SPINLOCK(watches_lock);
   26.89 -
   26.90 -/* List of pending watch callback events, and a lock to protect it. */
   26.91 -static LIST_HEAD(watch_events);
   26.92 -static DEFINE_SPINLOCK(watch_events_lock);
   26.93 -
   26.94 -/*
   26.95 - * Details of the xenwatch callback kernel thread. The thread waits on the
   26.96 - * watch_events_waitq for work to do (queued on watch_events list). When it
   26.97 - * wakes up it acquires the xenwatch_mutex before reading the list and
   26.98 - * carrying out work.
   26.99 - */
  26.100 -/* static */ DECLARE_MUTEX(xenwatch_mutex);
  26.101 -static DECLARE_WAIT_QUEUE_HEAD(watch_events_waitq);
  26.102 -
  26.103 -static int get_error(const char *errorstring)
  26.104 -{
  26.105 -	unsigned int i;
  26.106 -
  26.107 -	for (i = 0; !streq(errorstring, xsd_errors[i].errstring); i++) {
  26.108 -		if (i == ARRAY_SIZE(xsd_errors) - 1) {
  26.109 -			printk("XENBUS xen store gave: unknown error %s",
  26.110 -			       errorstring);
  26.111 -			return EINVAL;
  26.112 -		}
  26.113 -	}
  26.114 -	return xsd_errors[i].errnum;
  26.115 -}
  26.116 -
  26.117 -static void *read_reply(enum xsd_sockmsg_type *type, unsigned int *len)
  26.118 -{
  26.119 -	struct xs_stored_msg *msg;
  26.120 -	char *body;
  26.121 -
  26.122 -	spin_lock(&xs_state.reply_lock);
  26.123 -
  26.124 -	while (list_empty(&xs_state.reply_list)) {
  26.125 -		spin_unlock(&xs_state.reply_lock);
  26.126 -		wait_event(xs_state.reply_waitq,
  26.127 -			   !list_empty(&xs_state.reply_list));
  26.128 -		spin_lock(&xs_state.reply_lock);
  26.129 -	}
  26.130 -
  26.131 -	msg = list_entry(xs_state.reply_list.next,
  26.132 -			 struct xs_stored_msg, list);
  26.133 -	list_del(&msg->list);
  26.134 -
  26.135 -	spin_unlock(&xs_state.reply_lock);
  26.136 -
  26.137 -	*type = msg->hdr.type;
  26.138 -	if (len)
  26.139 -		*len = msg->hdr.len;
  26.140 -	body = msg->u.reply.body;
  26.141 -
  26.142 -	free(msg);
  26.143 -
  26.144 -	return body;
  26.145 -}
  26.146 -
  26.147 -/* Emergency write. */
  26.148 -void xenbus_debug_write(const char *str, unsigned int count)
  26.149 -{
  26.150 -	struct xsd_sockmsg msg = { 0 };
  26.151 -
  26.152 -	msg.type = XS_DEBUG;
  26.153 -	msg.len = sizeof("print") + count + 1;
  26.154 -
  26.155 -	down(&xs_state.request_mutex);
  26.156 -	xb_write(&msg, sizeof(msg));
  26.157 -	xb_write("print", sizeof("print"));
  26.158 -	xb_write(str, count);
  26.159 -	xb_write("", 1);
  26.160 -	up(&xs_state.request_mutex);
  26.161 -}
  26.162 -
  26.163 -void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg)
  26.164 -{
  26.165 -	void *ret;
  26.166 -	struct xsd_sockmsg req_msg = *msg;
  26.167 -	int err;
  26.168 -
  26.169 -	if (req_msg.type == XS_TRANSACTION_START)
  26.170 -		down_read(&xs_state.suspend_mutex);
  26.171 -
  26.172 -	down(&xs_state.request_mutex);
  26.173 -
  26.174 -	err = xb_write(msg, sizeof(*msg) + msg->len);
  26.175 -	if (err) {
  26.176 -		msg->type = XS_ERROR;
  26.177 -		ret = ERR_PTR(err);
  26.178 -	} else {
  26.179 -		ret = read_reply(&msg->type, &msg->len);
  26.180 -	}
  26.181 -
  26.182 -	up(&xs_state.request_mutex);
  26.183 -
  26.184 -	if ((msg->type == XS_TRANSACTION_END) ||
  26.185 -	    ((req_msg.type == XS_TRANSACTION_START) &&
  26.186 -	     (msg->type == XS_ERROR)))
  26.187 -		up_read(&xs_state.suspend_mutex);
  26.188 -
  26.189 -	return ret;
  26.190 -}
  26.191 -
  26.192 -/* Send message to xs, get kmalloc'ed reply.  ERR_PTR() on error. */
  26.193 -static void *xs_talkv(struct xenbus_transaction *t,
  26.194 -		      enum xsd_sockmsg_type type,
  26.195 -		      const struct kvec *iovec,
  26.196 -		      unsigned int num_vecs,
  26.197 -		      unsigned int *len)
  26.198 -{
  26.199 -	struct xsd_sockmsg msg;
  26.200 -	void *ret = NULL;
  26.201 -	unsigned int i;
  26.202 -	int err;
  26.203 -
  26.204 -	msg.tx_id = (u32)(unsigned long)t;
  26.205 -	msg.req_id = 0;
  26.206 -	msg.type = type;
  26.207 -	msg.len = 0;
  26.208 -	for (i = 0; i < num_vecs; i++)
  26.209 -		msg.len += iovec[i].iov_len;
  26.210 -
  26.211 -	down(&xs_state.request_mutex);
  26.212 -
  26.213 -	err = xb_write(&msg, sizeof(msg));
  26.214 -	if (err) {
  26.215 -		up(&xs_state.request_mutex);
  26.216 -		return ERR_PTR(err);
  26.217 -	}
  26.218 -
  26.219 -	for (i = 0; i < num_vecs; i++) {
  26.220 -		err = xb_write(iovec[i].iov_base, iovec[i].iov_len);;
  26.221 -		if (err) {
  26.222 -			up(&xs_state.request_mutex);
  26.223 -			return ERR_PTR(err);
  26.224 -		}
  26.225 -	}
  26.226 -
  26.227 -	ret = read_reply(&msg.type, len);
  26.228 -
  26.229 -	up(&xs_state.request_mutex);
  26.230 -
  26.231 -	if (IS_ERR(ret))
  26.232 -		return ret;
  26.233 -
  26.234 -	if (msg.type == XS_ERROR) {
  26.235 -		err = get_error(ret);
  26.236 -		free(ret);
  26.237 -		return ERR_PTR(-err);
  26.238 -	}
  26.239 -
  26.240 -	//	BUG_ON(msg.type != type);
  26.241 -	return ret;
  26.242 -}
  26.243 -
  26.244 -/* Simplified version of xs_talkv: single message. */
  26.245 -static void *xs_single(struct xenbus_transaction *t,
  26.246 -		       enum xsd_sockmsg_type type,
  26.247 -		       const char *string,
  26.248 -		       unsigned int *len)
  26.249 -{
  26.250 -	struct kvec iovec;
  26.251 -
  26.252 -	iovec.iov_base = (void *)string;
  26.253 -	iovec.iov_len = strlen(string) + 1;
  26.254 -	return xs_talkv(t, type, &iovec, 1, len);
  26.255 -}
  26.256 -
  26.257 -/* Many commands only need an ack, don't care what it says. */
  26.258 -static int xs_error(char *reply)
  26.259 -{
  26.260 -	if (IS_ERR(reply))
  26.261 -		return PTR_ERR(reply);
  26.262 -	free(reply);
  26.263 -	return 0;
  26.264 -}
  26.265 -
  26.266 -static unsigned int count_strings(const char *strings, unsigned int len)
  26.267 -{
  26.268 -	unsigned int num;
  26.269 -	const char *p;
  26.270 -
  26.271 -	for (p = strings, num = 0; p < strings + len; p += strlen(p) + 1)
  26.272 -		num++;
  26.273 -
  26.274 -	return num;
  26.275 -}
  26.276 -
  26.277 -/* Return the path to dir with /name appended. Buffer must be kfree()'ed. */ 
  26.278 -static char *join(const char *dir, const char *name)
  26.279 -{
  26.280 -	char *buffer;
  26.281 -
  26.282 -	buffer = malloc(strlen(dir) + strlen("/") + strlen(name) + 1);
  26.283 -	if (buffer == NULL)
  26.284 -		return ERR_PTR(-ENOMEM);
  26.285 -
  26.286 -	strcpy(buffer, dir);
  26.287 -	if (!streq(name, "")) {
  26.288 -		strcat(buffer, "/");
  26.289 -		strcat(buffer, name);
  26.290 -	}
  26.291 -
  26.292 -	return buffer;
  26.293 -}
  26.294 -
  26.295 -static char **split(char *strings, unsigned int len, unsigned int *num)
  26.296 -{
  26.297 -	char *p, **ret;
  26.298 -
  26.299 -	/* Count the strings. */
  26.300 -	*num = count_strings(strings, len);
  26.301 -
  26.302 -	/* Transfer to one big alloc for easy freeing. */
  26.303 -	ret = malloc(*num * sizeof(char *) + len);
  26.304 -	if (!ret) {
  26.305 -		free(strings);
  26.306 -		return ERR_PTR(-ENOMEM);
  26.307 -	}
  26.308 -	memcpy(&ret[*num], strings, len);
  26.309 -	free(strings);
  26.310 -
  26.311 -	strings = (char *)&ret[*num];
  26.312 -	for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
  26.313 -		ret[(*num)++] = p;
  26.314 -
  26.315 -	return ret;
  26.316 -}
  26.317 -
  26.318 -char **xenbus_directory(struct xenbus_transaction *t,
  26.319 -			const char *dir, const char *node, unsigned int *num)
  26.320 -{
  26.321 -	char *strings, *path;
  26.322 -	unsigned int len;
  26.323 -
  26.324 -	path = join(dir, node);
  26.325 -	if (IS_ERR(path))
  26.326 -		return (char **)path;
  26.327 -
  26.328 -	strings = xs_single(t, XS_DIRECTORY, path, &len);
  26.329 -	free(path);
  26.330 -	if (IS_ERR(strings))
  26.331 -		return (char **)strings;
  26.332 -
  26.333 -	return split(strings, len, num);
  26.334 -}
  26.335 -
  26.336 -/* Check if a path exists. Return 1 if it does. */
  26.337 -int xenbus_exists(struct xenbus_transaction *t,
  26.338 -		  const char *dir, const char *node)
  26.339 -{
  26.340 -	char **d;
  26.341 -	int dir_n;
  26.342 -
  26.343 -	d = xenbus_directory(t, dir, node, &dir_n);
  26.344 -	if (IS_ERR(d))
  26.345 -		return 0;
  26.346 -	free(d);
  26.347 -	return 1;
  26.348 -}
  26.349 -
  26.350 -/* Get the value of a single file.
  26.351 - * Returns a kmalloced value: call free() on it after use.
  26.352 - * len indicates length in bytes.
  26.353 - */
  26.354 -void *xenbus_read(struct xenbus_transaction *t,
  26.355 -		  const char *dir, const char *node, unsigned int *len)
  26.356 -{
  26.357 -	char *path;
  26.358 -	void *ret;
  26.359 -
  26.360 -	path = join(dir, node);
  26.361 -	if (IS_ERR(path))
  26.362 -		return (void *)path;
  26.363 -
  26.364 -	ret = xs_single(t, XS_READ, path, len);
  26.365 -	free(path);
  26.366 -	return ret;
  26.367 -}
  26.368 -
  26.369 -/* Write the value of a single file.
  26.370 - * Returns -err on failure.
  26.371 - */
  26.372 -int xenbus_write(struct xenbus_transaction *t,
  26.373 -		 const char *dir, const char *node, const char *string)
  26.374 -{
  26.375 -	const char *path;
  26.376 -	struct kvec iovec[2];
  26.377 -	int ret;
  26.378 -
  26.379 -	path = join(dir, node);
  26.380 -	if (IS_ERR(path))
  26.381 -		return PTR_ERR(path);
  26.382 -
  26.383 -	iovec[0].iov_base = (void *)path;
  26.384 -	iovec[0].iov_len = strlen(path) + 1;
  26.385 -	iovec[1].iov_base = (void *)string;
  26.386 -	iovec[1].iov_len = strlen(string);
  26.387 -
  26.388 -	ret = xs_error(xs_talkv(t, XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL));
  26.389 -	free(path);
  26.390 -	return ret;
  26.391 -}
  26.392 -
  26.393 -/* Create a new directory. */
  26.394 -int xenbus_mkdir(struct xenbus_transaction *t,
  26.395 -		 const char *dir, const char *node)
  26.396 -{
  26.397 -	char *path;
  26.398 -	int ret;
  26.399 -
  26.400 -	path = join(dir, node);
  26.401 -	if (IS_ERR(path))
  26.402 -		return PTR_ERR(path);
  26.403 -
  26.404 -	ret = xs_error(xs_single(t, XS_MKDIR, path, NULL));
  26.405 -	free(path);
  26.406 -	return ret;
  26.407 -}
  26.408 -
  26.409 -/* Destroy a file or directory (directories must be empty). */
  26.410 -int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node)
  26.411 -{
  26.412 -	char *path;
  26.413 -	int ret;
  26.414 -
  26.415 -	path = join(dir, node);
  26.416 -	if (IS_ERR(path))
  26.417 -		return PTR_ERR(path);
  26.418 -
  26.419 -	ret = xs_error(xs_single(t, XS_RM, path, NULL));
  26.420 -	free(path);
  26.421 -	return ret;
  26.422 -}
  26.423 -
  26.424 -/* Start a transaction: changes by others will not be seen during this
  26.425 - * transaction, and changes will not be visible to others until end.
  26.426 - */
  26.427 -struct xenbus_transaction *xenbus_transaction_start(void)
  26.428 -{
  26.429 -	char *id_str;
  26.430 -	unsigned long id;
  26.431 -
  26.432 -	down_read(&xs_state.suspend_mutex);
  26.433 -
  26.434 -	id_str = xs_single(NULL, XS_TRANSACTION_START, "", NULL);
  26.435 -	if (IS_ERR(id_str)) {
  26.436 -		up_read(&xs_state.suspend_mutex);
  26.437 -		return (struct xenbus_transaction *)id_str;
  26.438 -	}
  26.439 -
  26.440 -	id = simple_strtoul(id_str, NULL, 0);
  26.441 -	free(id_str);
  26.442 -
  26.443 -	return (struct xenbus_transaction *)id;
  26.444 -}
  26.445 -
  26.446 -/* End a transaction.
  26.447 - * If abandon is true, transaction is discarded instead of committed.
  26.448 - */
  26.449 -int xenbus_transaction_end(struct xenbus_transaction *t, int abort)
  26.450 -{
  26.451 -	char abortstr[2];
  26.452 -	int err;
  26.453 -
  26.454 -	if (abort)
  26.455 -		strcpy(abortstr, "F");
  26.456 -	else
  26.457 -		strcpy(abortstr, "T");
  26.458 -
  26.459 -	err = xs_error(xs_single(t, XS_TRANSACTION_END, abortstr, NULL));
  26.460 -
  26.461 -	up_read(&xs_state.suspend_mutex);
  26.462 -
  26.463 -	return err;
  26.464 -}
  26.465 -
  26.466 -/* Single read and scanf: returns -errno or num scanned. */
  26.467 -int xenbus_scanf(struct xenbus_transaction *t,
  26.468 -		 const char *dir, const char *node, const char *fmt, ...)
  26.469 -{
  26.470 -	va_list ap;
  26.471 -	int ret;
  26.472 -	char *val;
  26.473 -
  26.474 -	val = xenbus_read(t, dir, node, NULL);
  26.475 -	if (IS_ERR(val))
  26.476 -		return PTR_ERR(val);
  26.477 -
  26.478 -	va_start(ap, fmt);
  26.479 -	ret = vsscanf(val, fmt, ap);
  26.480 -	va_end(ap);
  26.481 -	free(val);
  26.482 -	/* Distinctive errno. */
  26.483 -	if (ret == 0)
  26.484 -		return -ERANGE;
  26.485 -	return ret;
  26.486 -}
  26.487 -
  26.488 -/* Single printf and write: returns -errno or 0. */
  26.489 -int xenbus_printf(struct xenbus_transaction *t,
  26.490 -		  const char *dir, const char *node, const char *fmt, ...)
  26.491 -{
  26.492 -	va_list ap;
  26.493 -	int ret;
  26.494 -#define PRINTF_BUFFER_SIZE 4096
  26.495 -	char *printf_buffer;
  26.496 -
  26.497 -	printf_buffer = malloc(PRINTF_BUFFER_SIZE);
  26.498 -	if (printf_buffer == NULL)
  26.499 -		return -ENOMEM;
  26.500 -
  26.501 -	va_start(ap, fmt);
  26.502 -	ret = vsnprintf(printf_buffer, PRINTF_BUFFER_SIZE, fmt, ap);
  26.503 -	va_end(ap);
  26.504 -
  26.505 -	//	BUG_ON(ret > PRINTF_BUFFER_SIZE-1);
  26.506 -	ret = xenbus_write(t, dir, node, printf_buffer);
  26.507 -
  26.508 -	free(printf_buffer);
  26.509 -
  26.510 -	return ret;
  26.511 -}
  26.512 -
  26.513 -/* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
  26.514 -int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...)
  26.515 -{
  26.516 -	va_list ap;
  26.517 -	const char *name;
  26.518 -	int ret = 0;
  26.519 -
  26.520 -	va_start(ap, dir);
  26.521 -	while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
  26.522 -		const char *fmt = va_arg(ap, char *);
  26.523 -		void *result = va_arg(ap, void *);
  26.524 -		char *p;
  26.525 -
  26.526 -		p = xenbus_read(t, dir, name, NULL);
  26.527 -		if (IS_ERR(p)) {
  26.528 -			ret = PTR_ERR(p);
  26.529 -			break;
  26.530 -		}
  26.531 -		if (fmt) {
  26.532 -			if (sscanf(p, fmt, result) == 0)
  26.533 -				ret = -EINVAL;
  26.534 -			free(p);
  26.535 -		} else
  26.536 -			*(char **)result = p;
  26.537 -	}
  26.538 -	va_end(ap);
  26.539 -	return ret;
  26.540 -}
  26.541 -
  26.542 -static int xs_watch(const char *path, const char *token)
  26.543 -{
  26.544 -	struct kvec iov[2];
  26.545 -
  26.546 -	iov[0].iov_base = (void *)path;
  26.547 -	iov[0].iov_len = strlen(path) + 1;
  26.548 -	iov[1].iov_base = (void *)token;
  26.549 -	iov[1].iov_len = strlen(token) + 1;
  26.550 -
  26.551 -	return xs_error(xs_talkv(NULL, XS_WATCH, iov,
  26.552 -				 ARRAY_SIZE(iov), NULL));
  26.553 -}
  26.554 -
  26.555 -static int xs_unwatch(const char *path, const char *token)
  26.556 -{
  26.557 -	struct kvec iov[2];
  26.558 -
  26.559 -	iov[0].iov_base = (char *)path;
  26.560 -	iov[0].iov_len = strlen(path) + 1;
  26.561 -	iov[1].iov_base = (char *)token;
  26.562 -	iov[1].iov_len = strlen(token) + 1;
  26.563 -
  26.564 -	return xs_error(xs_talkv(NULL, XS_UNWATCH, iov,
  26.565 -				 ARRAY_SIZE(iov), NULL));
  26.566 -}
  26.567 -
  26.568 -static struct xenbus_watch *find_watch(const char *token)
  26.569 -{
  26.570 -	struct xenbus_watch *i, *cmp;
  26.571 -
  26.572 -	cmp = (void *)simple_strtoul(token, NULL, 16);
  26.573 -
  26.574 -	list_for_each_entry(i, &watches, list)
  26.575 -		if (i == cmp)
  26.576 -			return i;
  26.577 -
  26.578 -	return NULL;
  26.579 -}
  26.580 -
  26.581 -/* Register callback to watch this node. */
  26.582 -int register_xenbus_watch(struct xenbus_watch *watch)
  26.583 -{
  26.584 -	/* Pointer in ascii is the token. */
  26.585 -	char token[sizeof(watch) * 2 + 1];
  26.586 -	int err;
  26.587 -
  26.588 -	sprintf(token, "%lX", (long)watch);
  26.589 -
  26.590 -	down_read(&xs_state.suspend_mutex);
  26.591 -
  26.592 -	spin_lock(&watches_lock);
  26.593 -	//	BUG_ON(find_watch(token));
  26.594 -	list_add(&watch->list, &watches);
  26.595 -	spin_unlock(&watches_lock);
  26.596 -
  26.597 -	err = xs_watch(watch->node, token);
  26.598 -
  26.599 -	/* Ignore errors due to multiple registration. */
  26.600 -	if ((err != 0) && (err != -EEXIST)) {
  26.601 -		spin_lock(&watches_lock);
  26.602 -		list_del(&watch->list);
  26.603 -		spin_unlock(&watches_lock);
  26.604 -	}
  26.605 -
  26.606 -	up_read(&xs_state.suspend_mutex);
  26.607 -
  26.608 -	return err;
  26.609 -}
  26.610 -
  26.611 -void unregister_xenbus_watch(struct xenbus_watch *watch)
  26.612 -{
  26.613 -	struct xs_stored_msg *msg, *tmp;
  26.614 -	char token[sizeof(watch) * 2 + 1];
  26.615 -	int err;
  26.616 -
  26.617 -	sprintf(token, "%lX", (long)watch);
  26.618 -
  26.619 -	down_read(&xs_state.suspend_mutex);
  26.620 -
  26.621 -	spin_lock(&watches_lock);
  26.622 -	//	BUG_ON(!find_watch(token));
  26.623 -	list_del(&watch->list);
  26.624 -	spin_unlock(&watches_lock);
  26.625 -
  26.626 -	err = xs_unwatch(watch->node, token);
  26.627 -	if (err)
  26.628 -		printk("XENBUS Failed to release watch %s: %i\n",
  26.629 -		       watch->node, err);
  26.630 -
  26.631 -	up_read(&xs_state.suspend_mutex);
  26.632 -
  26.633 -	/* Cancel pending watch events. */
  26.634 -	spin_lock(&watch_events_lock);
  26.635 -	list_for_each_entry_safe(msg, tmp, &watch_events, list) {
  26.636 -		if (msg->u.watch.handle != watch)
  26.637 -			continue;
  26.638 -		list_del(&msg->list);
  26.639 -		free(msg->u.watch.vec);
  26.640 -		free(msg);
  26.641 -	}
  26.642 -	spin_unlock(&watch_events_lock);
  26.643 -}
  26.644 -
  26.645 -void xs_suspend(void)
  26.646 -{
  26.647 -	down_write(&xs_state.suspend_mutex);
  26.648 -	down(&xs_state.request_mutex);
  26.649 -}
  26.650 -
  26.651 -void xs_resume(void)
  26.652 -{
  26.653 -	struct xenbus_watch *watch;
  26.654 -	char token[sizeof(watch) * 2 + 1];
  26.655 -
  26.656 -	up(&xs_state.request_mutex);
  26.657 -
  26.658 -	/* No need for watches_lock: the suspend_mutex is sufficient. */
  26.659 -	list_for_each_entry(watch, &watches, list) {
  26.660 -		sprintf(token, "%lX", (long)watch);
  26.661 -		xs_watch(watch->node, token);
  26.662 -	}
  26.663 -
  26.664 -	up_write(&xs_state.suspend_mutex);
  26.665 -}
  26.666 -
  26.667 -static void xenwatch_thread(void *unused)
  26.668 -{
  26.669 -	struct list_head *ent;
  26.670 -	struct xs_stored_msg *msg;
  26.671 -
  26.672 -	for (;;) {
  26.673 -		wait_event(watch_events_waitq,
  26.674 -			   !list_empty(&watch_events));
  26.675 -
  26.676 -		down(&xenwatch_mutex);
  26.677 -
  26.678 -		spin_lock(&watch_events_lock);
  26.679 -		ent = watch_events.next;
  26.680 -		if (ent != &watch_events)
  26.681 -			list_del(ent);
  26.682 -		spin_unlock(&watch_events_lock);
  26.683 -
  26.684 -		if (ent != &watch_events) {
  26.685 -			msg = list_entry(ent, struct xs_stored_msg, list);
  26.686 -			msg->u.watch.handle->callback(
  26.687 -				msg->u.watch.handle,
  26.688 -				(const char **)msg->u.watch.vec,
  26.689 -				msg->u.watch.vec_size);
  26.690 -			free(msg->u.watch.vec);
  26.691 -			free(msg);
  26.692 -		}
  26.693 -
  26.694 -		up(&xenwatch_mutex);
  26.695 -	}
  26.696 -}
  26.697 -
  26.698 -static int process_msg(void)
  26.699 -{
  26.700 -	struct xs_stored_msg *msg;
  26.701 -	char *body;
  26.702 -	int err;
  26.703 -
  26.704 -	msg = malloc(sizeof(*msg));
  26.705 -	if (msg == NULL)
  26.706 -		return -ENOMEM;
  26.707 -
  26.708 -	err = xb_read(&msg->hdr, sizeof(msg->hdr));
  26.709 -	if (err) {
  26.710 -		free(msg);
  26.711 -		return err;
  26.712 -	}
  26.713 -
  26.714 -	body = malloc(msg->hdr.len + 1);
  26.715 -	if (body == NULL) {
  26.716 -		free(msg);
  26.717 -		return -ENOMEM;
  26.718 -	}
  26.719 -
  26.720 -	err = xb_read(body, msg->hdr.len);
  26.721 -	if (err) {
  26.722 -		free(body);
  26.723 -		free(msg);
  26.724 -		return err;
  26.725 -	}
  26.726 -	body[msg->hdr.len] = '\0';
  26.727 -
  26.728 -	if (msg->hdr.type == XS_WATCH_EVENT) {
  26.729 -		msg->u.watch.vec = split(body, msg->hdr.len,
  26.730 -					 &msg->u.watch.vec_size);
  26.731 -		if (IS_ERR(msg->u.watch.vec)) {
  26.732 -			free(msg);
  26.733 -			return PTR_ERR(msg->u.watch.vec);
  26.734 -		}
  26.735 -
  26.736 -		spin_lock(&watches_lock);
  26.737 -		msg->u.watch.handle = find_watch(
  26.738 -			msg->u.watch.vec[XS_WATCH_TOKEN]);
  26.739 -		if (msg->u.watch.handle != NULL) {
  26.740 -			spin_lock(&watch_events_lock);
  26.741 -			list_add_tail(&msg->list, &watch_events);
  26.742 -			wake_up(&watch_events_waitq);
  26.743 -			spin_unlock(&watch_events_lock);
  26.744 -		} else {
  26.745 -			free(msg->u.watch.vec);
  26.746 -			free(msg);
  26.747 -		}
  26.748 -		spin_unlock(&watches_lock);
  26.749 -	} else {
  26.750 -		msg->u.reply.body = body;
  26.751 -		spin_lock(&xs_state.reply_lock);
  26.752 -		list_add_tail(&msg->list, &xs_state.reply_list);
  26.753 -		spin_unlock(&xs_state.reply_lock);
  26.754 -		wake_up(&xs_state.reply_waitq);
  26.755 -	}
  26.756 -
  26.757 -	return 0;
  26.758 -}
  26.759 -
  26.760 -static void xenbus_thread(void *unused)
  26.761 -{
  26.762 -	int err;
  26.763 -
  26.764 -	for (;;) {
  26.765 -		err = process_msg();
  26.766 -		if (err)
  26.767 -			printk("XENBUS error %d while reading "
  26.768 -			       "message\n", err);
  26.769 -	}
  26.770 -}
  26.771 -
  26.772 -int xs_init(void)
  26.773 -{
  26.774 -	int err;
  26.775 -	struct thread *kxwatcher_thread;
  26.776 -	struct thread *kxenbus_thread;
  26.777 -
  26.778 -	INIT_LIST_HEAD(&xs_state.reply_list);
  26.779 -	spin_lock_init(&xs_state.reply_lock);
  26.780 -	init_waitqueue_head(&xs_state.reply_waitq);
  26.781 -
  26.782 -	init_MUTEX(&xs_state.request_mutex);
  26.783 -	init_rwsem(&xs_state.suspend_mutex);
  26.784 -
  26.785 -	/* Initialize the shared memory rings to talk to xenstored */
  26.786 -	err = xb_init_comms();
  26.787 -	if (err)
  26.788 -		return err;
  26.789 -
  26.790 -	kxwatcher_thread = create_thread("kxwatch", xenwatch_thread, NULL);
  26.791 -	if (IS_ERR(kxwatcher_thread))
  26.792 -		return PTR_ERR(kxwatcher_thread);
  26.793 -
  26.794 -	kxenbus_thread = create_thread("kxenbus", xenbus_thread, NULL);
  26.795 -	if (IS_ERR(kxenbus_thread))
  26.796 -		return PTR_ERR(kxenbus_thread);
  26.797 -
  26.798 -	return 0;
  26.799 -}
    27.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/cpu/common-xen.c	Mon Mar 27 15:36:47 2006 -0700
    27.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/cpu/common-xen.c	Tue Mar 28 08:54:58 2006 -0700
    27.3 @@ -34,8 +34,6 @@ static int disable_x86_serial_nr __devin
    27.4  
    27.5  struct cpu_dev * cpu_devs[X86_VENDOR_NUM] = {};
    27.6  
    27.7 -extern void machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c);
    27.8 -
    27.9  extern int disable_pse;
   27.10  
   27.11  static void default_init(struct cpuinfo_x86 * c)
   27.12 @@ -425,8 +423,6 @@ void __devinit identify_cpu(struct cpuin
   27.13  				c->x86_vendor, c->x86_model);
   27.14  	}
   27.15  
   27.16 -	machine_specific_modify_cpu_capabilities(c);
   27.17 -
   27.18  	/* Now the feature flags better reflect actual CPU features! */
   27.19  
   27.20  	printk(KERN_DEBUG "CPU: After all inits, caps:");
    28.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/entry-xen.S	Mon Mar 27 15:36:47 2006 -0700
    28.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/entry-xen.S	Tue Mar 28 08:54:58 2006 -0700
    28.3 @@ -462,7 +462,7 @@ vector=0
    28.4  ENTRY(irq_entries_start)
    28.5  .rept NR_IRQS
    28.6  	ALIGN
    28.7 -1:	pushl $vector-256
    28.8 +1:	pushl 0x80000000+$vector
    28.9  	jmp common_interrupt
   28.10  .data
   28.11  	.long 1b
   28.12 @@ -479,7 +479,7 @@ common_interrupt:
   28.13  
   28.14  #define BUILD_INTERRUPT(name, nr)	\
   28.15  ENTRY(name)				\
   28.16 -	pushl $nr-256;			\
   28.17 +	pushl 0x80000000+$nr;		\
   28.18  	SAVE_ALL			\
   28.19  	movl %esp,%eax;			\
   28.20  	call smp_/**/name;		\
    29.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/head-xen.S	Mon Mar 27 15:36:47 2006 -0700
    29.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/head-xen.S	Tue Mar 28 08:54:58 2006 -0700
    29.3 @@ -32,14 +32,14 @@ ENTRY(startup_32)
    29.4  
    29.5  	/* get vendor info */
    29.6  	xorl %eax,%eax			# call CPUID with 0 -> return vendor ID
    29.7 -	cpuid
    29.8 +	XEN_CPUID
    29.9  	movl %eax,X86_CPUID		# save CPUID level
   29.10  	movl %ebx,X86_VENDOR_ID		# lo 4 chars
   29.11  	movl %edx,X86_VENDOR_ID+4	# next 4 chars
   29.12  	movl %ecx,X86_VENDOR_ID+8	# last 4 chars
   29.13  
   29.14  	movl $1,%eax		# Use the CPUID instruction to get CPU type
   29.15 -	cpuid
   29.16 +	XEN_CPUID
   29.17  	movb %al,%cl		# save reg for future use
   29.18  	andb $0x0f,%ah		# mask processor family
   29.19  	movb %ah,X86
    30.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/irq-xen.c	Mon Mar 27 15:36:47 2006 -0700
    30.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/irq-xen.c	Tue Mar 28 08:54:58 2006 -0700
    30.3 @@ -53,8 +53,8 @@ static union irq_ctx *softirq_ctx[NR_CPU
    30.4   */
    30.5  fastcall unsigned int do_IRQ(struct pt_regs *regs)
    30.6  {	
    30.7 -	/* high bits used in ret_from_ code */
    30.8 -	int irq = regs->orig_eax & __IRQ_MASK(HARDIRQ_BITS);
    30.9 +	/* high bit used in ret_from_ code */
   30.10 +	int irq = regs->orig_eax & __IRQ_MASK(BITS_PER_LONG - 1);
   30.11  #ifdef CONFIG_4KSTACKS
   30.12  	union irq_ctx *curctx, *irqctx;
   30.13  	u32 *isp;
    31.1 --- a/linux-2.6-xen-sparse/arch/i386/mm/ioremap-xen.c	Mon Mar 27 15:36:47 2006 -0700
    31.2 +++ b/linux-2.6-xen-sparse/arch/i386/mm/ioremap-xen.c	Tue Mar 28 08:54:58 2006 -0700
    31.3 @@ -32,13 +32,13 @@
    31.4  #endif
    31.5  
    31.6  static int direct_remap_area_pte_fn(pte_t *pte, 
    31.7 -				    struct page *pte_page,
    31.8 +				    struct page *pmd_page,
    31.9  				    unsigned long address, 
   31.10  				    void *data)
   31.11  {
   31.12  	mmu_update_t **v = (mmu_update_t **)data;
   31.13  
   31.14 -	(*v)->ptr = ((u64)pfn_to_mfn(page_to_pfn(pte_page)) <<
   31.15 +	(*v)->ptr = ((u64)pfn_to_mfn(page_to_pfn(pmd_page)) <<
   31.16  		     PAGE_SHIFT) | ((unsigned long)pte & ~PAGE_MASK);
   31.17  	(*v)++;
   31.18  
   31.19 @@ -67,9 +67,9 @@ static int __direct_remap_pfn_range(stru
   31.20  	for (i = 0; i < size; i += PAGE_SIZE) {
   31.21  		if ((v - u) == (PAGE_SIZE / sizeof(mmu_update_t))) {
   31.22  			/* Fill in the PTE pointers. */
   31.23 -			rc = generic_page_range(mm, start_address, 
   31.24 -						address - start_address,
   31.25 -						direct_remap_area_pte_fn, &w);
   31.26 +			rc = apply_to_page_range(mm, start_address, 
   31.27 +						 address - start_address,
   31.28 +						 direct_remap_area_pte_fn, &w);
   31.29  			if (rc)
   31.30  				goto out;
   31.31  			w = u;
   31.32 @@ -93,8 +93,9 @@ static int __direct_remap_pfn_range(stru
   31.33  
   31.34  	if (v != u) {
   31.35  		/* get the ptep's filled in */
   31.36 -		rc = generic_page_range(mm, start_address, address - start_address,
   31.37 -				   direct_remap_area_pte_fn, &w);
   31.38 +		rc = apply_to_page_range(mm, start_address,
   31.39 +					 address - start_address,
   31.40 +					 direct_remap_area_pte_fn, &w);
   31.41  		if (rc)
   31.42  			goto out;
   31.43  		rc = -EFAULT;
   31.44 @@ -142,11 +143,11 @@ int direct_kernel_remap_pfn_range(unsign
   31.45  EXPORT_SYMBOL(direct_kernel_remap_pfn_range);
   31.46  
   31.47  static int lookup_pte_fn(
   31.48 -	pte_t *pte, struct page *pte_page, unsigned long addr, void *data)
   31.49 +	pte_t *pte, struct page *pmd_page, unsigned long addr, void *data)
   31.50  {
   31.51  	uint64_t *ptep = (uint64_t *)data;
   31.52  	if (ptep)
   31.53 -		*ptep = ((uint64_t)pfn_to_mfn(page_to_pfn(pte_page)) <<
   31.54 +		*ptep = ((uint64_t)pfn_to_mfn(page_to_pfn(pmd_page)) <<
   31.55  			 PAGE_SHIFT) | ((unsigned long)pte & ~PAGE_MASK);
   31.56  	return 0;
   31.57  }
   31.58 @@ -155,13 +156,14 @@ int create_lookup_pte_addr(struct mm_str
   31.59  			   unsigned long address,
   31.60  			   uint64_t *ptep)
   31.61  {
   31.62 -	return generic_page_range(mm, address, PAGE_SIZE, lookup_pte_fn, ptep);
   31.63 +	return apply_to_page_range(mm, address, PAGE_SIZE,
   31.64 +				   lookup_pte_fn, ptep);
   31.65  }
   31.66  
   31.67  EXPORT_SYMBOL(create_lookup_pte_addr);
   31.68  
   31.69  static int noop_fn(
   31.70 -	pte_t *pte, struct page *pte_page, unsigned long addr, void *data)
   31.71 +	pte_t *pte, struct page *pmd_page, unsigned long addr, void *data)
   31.72  {
   31.73  	return 0;
   31.74  }
   31.75 @@ -170,7 +172,7 @@ int touch_pte_range(struct mm_struct *mm
   31.76  		    unsigned long address,
   31.77  		    unsigned long size)
   31.78  {
   31.79 -	return generic_page_range(mm, address, size, noop_fn, NULL);
   31.80 +	return apply_to_page_range(mm, address, size, noop_fn, NULL);
   31.81  } 
   31.82  
   31.83  EXPORT_SYMBOL(touch_pte_range);
    32.1 --- a/linux-2.6-xen-sparse/arch/ia64/Kconfig	Mon Mar 27 15:36:47 2006 -0700
    32.2 +++ b/linux-2.6-xen-sparse/arch/ia64/Kconfig	Tue Mar 28 08:54:58 2006 -0700
    32.3 @@ -84,19 +84,6 @@ config XEN_BLKDEV_BACKEND
    32.4  	bool
    32.5  	default y
    32.6  
    32.7 -config XEN_VT
    32.8 -	bool "Override for turning on CONFIG_VT for domU"
    32.9 -	default y
   32.10 -	help
   32.11 -	  Hack to turn off CONFIG_VT for domU
   32.12 -
   32.13 -config VT
   32.14 -	bool
   32.15 -	default y if XEN && XEN_VT
   32.16 -	default n if XEN && !XEN_VT
   32.17 -	help
   32.18 -	  Hack to turn off CONFIG_VT for domU
   32.19 -
   32.20  config XEN_SYSFS
   32.21  	bool "Export Xen attributes in sysfs"
   32.22  	depends on XEN && SYSFS
    33.1 --- a/linux-2.6-xen-sparse/arch/ia64/kernel/setup.c	Mon Mar 27 15:36:47 2006 -0700
    33.2 +++ b/linux-2.6-xen-sparse/arch/ia64/kernel/setup.c	Tue Mar 28 08:54:58 2006 -0700
    33.3 @@ -506,6 +506,22 @@ setup_arch (char **cmdline_p)
    33.4  			conswitchp = &vga_con;
    33.5  # endif
    33.6  	}
    33.7 +#ifdef CONFIG_XEN
    33.8 +	if (running_on_xen) {
    33.9 +		extern shared_info_t *HYPERVISOR_shared_info;
   33.10 +
   33.11 +		/* xen_start_info isn't setup yet, get the flags manually */
   33.12 +		if (HYPERVISOR_shared_info->arch.flags & SIF_INITDOMAIN) {
   33.13 +			if (!(HYPERVISOR_shared_info->arch.flags & SIF_PRIVILEGED))
   33.14 +				panic("Xen granted us console access "
   33.15 +				      "but not privileged status");
   33.16 +		} else {
   33.17 +			extern int console_use_vt;
   33.18 +			conswitchp = NULL;
   33.19 +			console_use_vt = 0;
   33.20 +		}
   33.21 +	}
   33.22 +#endif
   33.23  #endif
   33.24  
   33.25  	/* enable IA-64 Machine Check Abort Handling unless disabled */
    34.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/apic-xen.c	Mon Mar 27 15:36:47 2006 -0700
    34.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/apic-xen.c	Tue Mar 28 08:54:58 2006 -0700
    34.3 @@ -114,8 +114,6 @@ void smp_apic_timer_interrupt(struct pt_
    34.4  	irq_exit();
    34.5  }
    34.6  
    34.7 -int __initdata unsync_tsc_on_multicluster;
    34.8 -
    34.9  /*
   34.10   * This interrupt should _never_ happen with our APIC/SMP architecture
   34.11   */
    35.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/entry-xen.S	Mon Mar 27 15:36:47 2006 -0700
    35.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/entry-xen.S	Tue Mar 28 08:54:58 2006 -0700
    35.3 @@ -584,7 +584,7 @@ retint_kernel:
    35.4   */		
    35.5  	.macro apicinterrupt num,func
    35.6  	INTR_FRAME
    35.7 -	pushq $\num-256
    35.8 +	pushq 0x8000000000000000+$\num
    35.9  	CFI_ADJUST_CFA_OFFSET 8
   35.10  	interrupt \func
   35.11  	jmp error_entry
   35.12 @@ -855,32 +855,12 @@ ecrit:  /**** END OF CRITICAL REGION ***
   35.13  # i.e. it just resumes from the next instruction interrupted with the same context. 
   35.14  	
   35.15  # Hypervisor uses this for application faults while it executes.
   35.16 +# Unlike i386 there is no need to reload the saved segment selectors:
   35.17 +# Xen already reloaded all valid ones and zeroed the others.
   35.18  ENTRY(failsafe_callback)
   35.19 -	addq $0x10,%rsp /* skip rcx and r11 */	
   35.20 -1:	mov  (%rsp),%ds
   35.21 -2:	mov  8(%rsp),%es
   35.22 -3:	mov  16(%rsp),%fs
   35.23 -4:	mov  24(%rsp),%gs
   35.24 -	addq $0x20,%rsp /* skip the above selectors */		
   35.25 +	addq $0x30,%rsp /* skip %rcx,%r11,%ds,%es,%fs,%gs */
   35.26  	SAVE_ALL
   35.27  	jmp  error_exit
   35.28 -.section .fixup,"ax";	\
   35.29 -6:	movq $0,(%rsp);	\
   35.30 -	jmp 1b;		\
   35.31 -7:	movq $0,8(%rsp);	\
   35.32 -	jmp 2b;		\
   35.33 -8:	movq $0,16(%rsp);	\
   35.34 -	jmp 3b;		\
   35.35 -9:	movq $0,24(%rsp);	\
   35.36 -	jmp 4b;		\
   35.37 -.previous;		\
   35.38 -.section __ex_table,"a";\
   35.39 -	.align 16;	\
   35.40 -	.quad 1b,6b;	\
   35.41 -	.quad 2b,7b;	\
   35.42 -	.quad 3b,8b;	\
   35.43 -	.quad 4b,9b;	\
   35.44 -.previous
   35.45   
   35.46  #if 0	      
   35.47          .section __ex_table,"a"
    36.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/irq-xen.c	Mon Mar 27 15:36:47 2006 -0700
    36.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/irq-xen.c	Tue Mar 28 08:54:58 2006 -0700
    36.3 @@ -96,8 +96,8 @@ skip:
    36.4   */
    36.5  asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
    36.6  {	
    36.7 -	/* high bits used in ret_from_ code  */
    36.8 -        int irq = regs->orig_rax & __IRQ_MASK(HARDIRQ_BITS);
    36.9 +	/* high bit used in ret_from_ code  */
   36.10 +        int irq = regs->orig_rax & __IRQ_MASK(BITS_PER_LONG - 1);
   36.11  
   36.12  	exit_idle();
   36.13  	irq_enter();
    37.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/setup-xen.c	Mon Mar 27 15:36:47 2006 -0700
    37.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/setup-xen.c	Tue Mar 28 08:54:58 2006 -0700
    37.3 @@ -82,8 +82,6 @@
    37.4  extern unsigned long start_pfn;
    37.5  extern struct edid_info edid_info;
    37.6  
    37.7 -extern void machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c);
    37.8 -
    37.9  shared_info_t *HYPERVISOR_shared_info = (shared_info_t *)empty_zero_page;
   37.10  EXPORT_SYMBOL(HYPERVISOR_shared_info);
   37.11  
   37.12 @@ -1433,8 +1431,6 @@ void __cpuinit identify_cpu(struct cpuin
   37.13  	select_idle_routine(c);
   37.14  	detect_ht(c); 
   37.15  
   37.16 -	machine_specific_modify_cpu_capabilities(c);
   37.17 -
   37.18  	/*
   37.19  	 * On SMP, boot_cpu_data holds the common feature set between
   37.20  	 * all CPUs; so make sure that we indicate which features are
    38.1 --- a/linux-2.6-xen-sparse/drivers/xen/balloon/balloon.c	Mon Mar 27 15:36:47 2006 -0700
    38.2 +++ b/linux-2.6-xen-sparse/drivers/xen/balloon/balloon.c	Tue Mar 28 08:54:58 2006 -0700
    38.3 @@ -517,7 +517,7 @@ void balloon_update_driver_allowance(lon
    38.4  }
    38.5  
    38.6  static int dealloc_pte_fn(
    38.7 -	pte_t *pte, struct page *pte_page, unsigned long addr, void *data)
    38.8 +	pte_t *pte, struct page *pmd_page, unsigned long addr, void *data)
    38.9  {
   38.10  	unsigned long mfn = pte_mfn(*pte);
   38.11  	int ret;
   38.12 @@ -547,8 +547,8 @@ struct page *balloon_alloc_empty_page_ra
   38.13  	scrub_pages(vstart, 1 << order);
   38.14  
   38.15  	balloon_lock(flags);
   38.16 -	ret = generic_page_range(
   38.17 -		&init_mm, vstart, PAGE_SIZE << order, dealloc_pte_fn, NULL);
   38.18 +	ret = apply_to_page_range(&init_mm, vstart,
   38.19 +				  PAGE_SIZE << order, dealloc_pte_fn, NULL);
   38.20  	BUG_ON(ret);
   38.21  	current_pages -= 1UL << order;
   38.22  	totalram_pages = current_pages;
    39.1 --- a/linux-2.6-xen-sparse/drivers/xen/core/evtchn.c	Mon Mar 27 15:36:47 2006 -0700
    39.2 +++ b/linux-2.6-xen-sparse/drivers/xen/core/evtchn.c	Tue Mar 28 08:54:58 2006 -0700
    39.3 @@ -58,17 +58,37 @@ static int evtchn_to_irq[NR_EVENT_CHANNE
    39.4  
    39.5  /* Packed IRQ information: binding type, sub-type index, and event channel. */
    39.6  static u32 irq_info[NR_IRQS];
    39.7 +
    39.8  /* Binding types. */
    39.9  enum { IRQT_UNBOUND, IRQT_PIRQ, IRQT_VIRQ, IRQT_IPI, IRQT_EVTCHN };
   39.10 +
   39.11  /* Constructor for packed IRQ information. */
   39.12 -#define mk_irq_info(type, index, evtchn)				\
   39.13 -	(((u32)(type) << 24) | ((u32)(index) << 16) | (u32)(evtchn))
   39.14 +static inline u32 mk_irq_info(u32 type, u32 index, u32 evtchn)
   39.15 +{
   39.16 +	return ((type << 24) | (index << 16) | evtchn);
   39.17 +}
   39.18 +
   39.19  /* Convenient shorthand for packed representation of an unbound IRQ. */
   39.20  #define IRQ_UNBOUND	mk_irq_info(IRQT_UNBOUND, 0, 0)
   39.21 -/* Accessor macros for packed IRQ information. */
   39.22 -#define evtchn_from_irq(irq) ((u16)(irq_info[irq]))
   39.23 -#define index_from_irq(irq)  ((u8)(irq_info[irq] >> 16))
   39.24 -#define type_from_irq(irq)   ((u8)(irq_info[irq] >> 24))
   39.25 +
   39.26 +/*
   39.27 + * Accessors for packed IRQ information.
   39.28 + */
   39.29 +
   39.30 +static inline unsigned int evtchn_from_irq(int irq)
   39.31 +{
   39.32 +	return (u16)(irq_info[irq]);
   39.33 +}
   39.34 +
   39.35 +static inline unsigned int index_from_irq(int irq)
   39.36 +{
   39.37 +	return (u8)(irq_info[irq] >> 16);
   39.38 +}
   39.39 +
   39.40 +static inline unsigned int type_from_irq(int irq)
   39.41 +{
   39.42 +	return (u8)(irq_info[irq] >> 24);
   39.43 +}
   39.44  
   39.45  /* IRQ <-> VIRQ mapping. */
   39.46  DEFINE_PER_CPU(int, virq_to_irq[NR_VIRQS]);
   39.47 @@ -90,10 +110,13 @@ static unsigned long pirq_needs_unmask_n
   39.48  static u8 cpu_evtchn[NR_EVENT_CHANNELS];
   39.49  static unsigned long cpu_evtchn_mask[NR_CPUS][NR_EVENT_CHANNELS/BITS_PER_LONG];
   39.50  
   39.51 -#define active_evtchns(cpu,sh,idx)		\
   39.52 -	((sh)->evtchn_pending[idx] &		\
   39.53 -	 cpu_evtchn_mask[cpu][idx] &		\
   39.54 -	 ~(sh)->evtchn_mask[idx])
   39.55 +static inline unsigned long active_evtchns(unsigned int cpu, shared_info_t *sh,
   39.56 +					   unsigned int idx)
   39.57 +{
   39.58 +	return (sh->evtchn_pending[idx] &
   39.59 +		cpu_evtchn_mask[cpu][idx] &
   39.60 +		~sh->evtchn_mask[idx]);
   39.61 +}
   39.62  
   39.63  static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
   39.64  {
   39.65 @@ -109,16 +132,31 @@ static void init_evtchn_cpu_bindings(voi
   39.66  	memset(cpu_evtchn_mask[0], ~0, sizeof(cpu_evtchn_mask[0]));
   39.67  }
   39.68  
   39.69 -#define cpu_from_evtchn(evtchn)		(cpu_evtchn[evtchn])
   39.70 +static inline unsigned int cpu_from_evtchn(unsigned int evtchn)
   39.71 +{
   39.72 +	return cpu_evtchn[evtchn];
   39.73 +}
   39.74  
   39.75  #else
   39.76  
   39.77 -#define active_evtchns(cpu,sh,idx)		\
   39.78 -	((sh)->evtchn_pending[idx] &		\
   39.79 -	 ~(sh)->evtchn_mask[idx])
   39.80 -#define bind_evtchn_to_cpu(chn,cpu)	((void)0)
   39.81 -#define init_evtchn_cpu_bindings()	((void)0)
   39.82 -#define cpu_from_evtchn(evtchn)		(0)
   39.83 +static inline unsigned long active_evtchns(unsigned int cpu, shared_info_t *sh,
   39.84 +					   unsigned int idx)
   39.85 +{
   39.86 +	return (sh->evtchn_pending[idx] & ~sh->evtchn_mask[idx]);
   39.87 +}
   39.88 +
   39.89 +static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
   39.90 +{
   39.91 +}
   39.92 +
   39.93 +static void init_evtchn_cpu_bindings(void)
   39.94 +{
   39.95 +}
   39.96 +
   39.97 +static inline unsigned int cpu_from_evtchn(unsigned int evtchn)
   39.98 +{
   39.99 +	return 0;
  39.100 +}
  39.101  
  39.102  #endif
  39.103  
  39.104 @@ -132,9 +170,9 @@ static inline void exit_idle(void) {}
  39.105  #include <asm/idle.h>
  39.106  #define IRQ_REG orig_rax
  39.107  #endif
  39.108 -#define do_IRQ(irq, regs) do {			\
  39.109 -	(regs)->IRQ_REG = (irq);		\
  39.110 -	do_IRQ((regs));				\
  39.111 +#define do_IRQ(irq, regs) do {					\
  39.112 +	(regs)->IRQ_REG = (irq) | (1UL << (BITS_PER_LONG - 1));	\
  39.113 +	do_IRQ((regs));						\
  39.114  } while (0)
  39.115  #endif
  39.116  
    40.1 --- a/linux-2.6-xen-sparse/drivers/xen/core/gnttab.c	Mon Mar 27 15:36:47 2006 -0700
    40.2 +++ b/linux-2.6-xen-sparse/drivers/xen/core/gnttab.c	Tue Mar 28 08:54:58 2006 -0700
    40.3 @@ -360,7 +360,7 @@ gnttab_request_free_callback(struct gntt
    40.4  }
    40.5  
    40.6  #ifndef __ia64__
    40.7 -static int map_pte_fn(pte_t *pte, struct page *pte_page,
    40.8 +static int map_pte_fn(pte_t *pte, struct page *pmd_page,
    40.9  		      unsigned long addr, void *data)
   40.10  {
   40.11  	unsigned long **frames = (unsigned long **)data;
   40.12 @@ -370,7 +370,7 @@ static int map_pte_fn(pte_t *pte, struct
   40.13  	return 0;
   40.14  }
   40.15  
   40.16 -static int unmap_pte_fn(pte_t *pte, struct page *pte_page,
   40.17 +static int unmap_pte_fn(pte_t *pte, struct page *pmd_page,
   40.18  		      unsigned long addr, void *data)
   40.19  {
   40.20  
   40.21 @@ -384,6 +384,7 @@ gnttab_resume(void)
   40.22  {
   40.23  	gnttab_setup_table_t setup;
   40.24  	unsigned long frames[NR_GRANT_FRAMES];
   40.25 +	int rc;
   40.26  #ifndef __ia64__
   40.27  	void *pframes = frames;
   40.28  	struct vm_struct *area;
   40.29 @@ -393,8 +394,8 @@ gnttab_resume(void)
   40.30  	setup.nr_frames  = NR_GRANT_FRAMES;
   40.31  	setup.frame_list = frames;
   40.32  
   40.33 -	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1));
   40.34 -	BUG_ON(setup.status != 0);
   40.35 +	rc = HYPERVISOR_grant_table_op(GNTTABOP_setup_table, &setup, 1);
   40.36 +	BUG_ON(rc || setup.status);
   40.37  
   40.38  #ifndef __ia64__
   40.39  	if (shared == NULL) {
   40.40 @@ -402,9 +403,10 @@ gnttab_resume(void)
   40.41  		BUG_ON(area == NULL);
   40.42  		shared = area->addr;
   40.43  	}
   40.44 -	BUG_ON(generic_page_range(&init_mm, (unsigned long)shared,
   40.45 -				  PAGE_SIZE * NR_GRANT_FRAMES,
   40.46 -				  map_pte_fn, &pframes));
   40.47 +	rc = apply_to_page_range(&init_mm, (unsigned long)shared,
   40.48 +				 PAGE_SIZE * NR_GRANT_FRAMES,
   40.49 +				 map_pte_fn, &pframes);
   40.50 +	BUG_ON(rc);
   40.51  #else
   40.52  	shared = __va(frames[0] << PAGE_SHIFT);
   40.53  	printk("grant table at %p\n", shared);
   40.54 @@ -418,9 +420,9 @@ gnttab_suspend(void)
   40.55  {
   40.56  
   40.57  #ifndef __ia64__
   40.58 -	generic_page_range(&init_mm, (unsigned long)shared,
   40.59 -			   PAGE_SIZE * NR_GRANT_FRAMES,
   40.60 -			   unmap_pte_fn, NULL);
   40.61 +	apply_to_page_range(&init_mm, (unsigned long)shared,
   40.62 +			    PAGE_SIZE * NR_GRANT_FRAMES,
   40.63 +			    unmap_pte_fn, NULL);
   40.64  #endif
   40.65  
   40.66  	return 0;
    41.1 --- a/linux-2.6-xen-sparse/drivers/xen/core/reboot.c	Mon Mar 27 15:36:47 2006 -0700
    41.2 +++ b/linux-2.6-xen-sparse/drivers/xen/core/reboot.c	Tue Mar 28 08:54:58 2006 -0700
    41.3 @@ -25,9 +25,10 @@ void (*pm_power_off)(void);
    41.4  EXPORT_SYMBOL(pm_power_off);
    41.5  #endif
    41.6  
    41.7 +extern void ctrl_alt_del(void);
    41.8 +
    41.9  #define SHUTDOWN_INVALID  -1
   41.10  #define SHUTDOWN_POWEROFF  0
   41.11 -#define SHUTDOWN_REBOOT    1
   41.12  #define SHUTDOWN_SUSPEND   2
   41.13  /* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
   41.14   * report a crash, not be instructed to crash!
   41.15 @@ -234,33 +235,19 @@ static int shutdown_process(void *__unus
   41.16  {
   41.17  	static char *envp[] = { "HOME=/", "TERM=linux",
   41.18  				"PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
   41.19 -	static char *restart_argv[]  = { "/sbin/reboot", NULL };
   41.20  	static char *poweroff_argv[] = { "/sbin/poweroff", NULL };
   41.21  
   41.22  	extern asmlinkage long sys_reboot(int magic1, int magic2,
   41.23  					  unsigned int cmd, void *arg);
   41.24  
   41.25 -	daemonize("shutdown");
   41.26 -
   41.27 -	switch (shutting_down) {
   41.28 -	case SHUTDOWN_POWEROFF:
   41.29 -	case SHUTDOWN_HALT:
   41.30 +	if ((shutting_down == SHUTDOWN_POWEROFF) ||
   41.31 +	    (shutting_down == SHUTDOWN_HALT)) {
   41.32  		if (execve("/sbin/poweroff", poweroff_argv, envp) < 0) {
   41.33  			sys_reboot(LINUX_REBOOT_MAGIC1,
   41.34  				   LINUX_REBOOT_MAGIC2,
   41.35  				   LINUX_REBOOT_CMD_POWER_OFF,
   41.36  				   NULL);
   41.37  		}
   41.38 -		break;
   41.39 -
   41.40 -	case SHUTDOWN_REBOOT:
   41.41 -		if (execve("/sbin/reboot", restart_argv, envp) < 0) {
   41.42 -			sys_reboot(LINUX_REBOOT_MAGIC1,
   41.43 -				   LINUX_REBOOT_MAGIC2,
   41.44 -				   LINUX_REBOOT_CMD_RESTART,
   41.45 -				   NULL);
   41.46 -		}
   41.47 -		break;
   41.48  	}
   41.49  
   41.50  	shutting_down = SHUTDOWN_INVALID; /* could try again */
   41.51 @@ -331,7 +318,7 @@ static void shutdown_handler(struct xenb
   41.52  	if (strcmp(str, "poweroff") == 0)
   41.53  		shutting_down = SHUTDOWN_POWEROFF;
   41.54  	else if (strcmp(str, "reboot") == 0)
   41.55 -		shutting_down = SHUTDOWN_REBOOT;
   41.56 +		ctrl_alt_del();
   41.57  	else if (strcmp(str, "suspend") == 0)
   41.58  		shutting_down = SHUTDOWN_SUSPEND;
   41.59  	else if (strcmp(str, "halt") == 0)
   41.60 @@ -391,8 +378,6 @@ static struct xenbus_watch sysrq_watch =
   41.61  };
   41.62  #endif
   41.63  
   41.64 -static struct notifier_block xenstore_notifier;
   41.65 -
   41.66  static int setup_shutdown_watcher(struct notifier_block *notifier,
   41.67                                    unsigned long event,
   41.68                                    void *data)
   41.69 @@ -420,11 +405,10 @@ static int setup_shutdown_watcher(struct
   41.70  
   41.71  static int __init setup_shutdown_event(void)
   41.72  {
   41.73 -
   41.74 -	xenstore_notifier.notifier_call = setup_shutdown_watcher;
   41.75 -
   41.76 +	static struct notifier_block xenstore_notifier = {
   41.77 +		.notifier_call = setup_shutdown_watcher
   41.78 +	};
   41.79  	register_xenstore_notifier(&xenstore_notifier);
   41.80 -
   41.81  	return 0;
   41.82  }
   41.83  
    42.1 --- a/linux-2.6-xen-sparse/drivers/xen/netback/netback.c	Mon Mar 27 15:36:47 2006 -0700
    42.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netback/netback.c	Tue Mar 28 08:54:58 2006 -0700
    42.3 @@ -331,7 +331,7 @@ static void net_rx_action(unsigned long 
    42.4  		if (make_rx_response(netif, id, status,
    42.5  				     (unsigned long)skb->data & ~PAGE_MASK,
    42.6  				     size, skb->proto_csum_valid ?
    42.7 -				     NETRXF_csum_valid : 0) &&
    42.8 +				     NETRXF_data_validated : 0) &&
    42.9  		    (rx_notify[irq] == 0)) {
   42.10  			rx_notify[irq] = 1;
   42.11  			notify_list[notify_nr++] = irq;
    43.1 --- a/linux-2.6-xen-sparse/drivers/xen/netfront/netfront.c	Mon Mar 27 15:36:47 2006 -0700
    43.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netfront/netfront.c	Tue Mar 28 08:54:58 2006 -0700
    43.3 @@ -68,18 +68,12 @@
    43.4  #define NET_TX_RING_SIZE __RING_SIZE((netif_tx_sring_t *)0, PAGE_SIZE)
    43.5  #define NET_RX_RING_SIZE __RING_SIZE((netif_rx_sring_t *)0, PAGE_SIZE)
    43.6  
    43.7 -#define alloc_xen_skb(_l) __dev_alloc_skb((_l), GFP_ATOMIC|__GFP_NOWARN)
    43.8 -
    43.9 -#define init_skb_shinfo(_skb)                         \
   43.10 -    do {                                              \
   43.11 -        atomic_set(&(skb_shinfo(_skb)->dataref), 1);  \
   43.12 -        skb_shinfo(_skb)->nr_frags = 0;               \
   43.13 -        skb_shinfo(_skb)->frag_list = NULL;           \
   43.14 -    } while (0)
   43.15 -
   43.16 -static unsigned long rx_pfn_array[NET_RX_RING_SIZE];
   43.17 -static multicall_entry_t rx_mcl[NET_RX_RING_SIZE+1];
   43.18 -static mmu_update_t rx_mmu[NET_RX_RING_SIZE];
   43.19 +static inline void init_skb_shinfo(struct sk_buff *skb)
   43.20 +{
   43.21 +	atomic_set(&(skb_shinfo(skb)->dataref), 1);
   43.22 +	skb_shinfo(skb)->nr_frags = 0;
   43.23 +	skb_shinfo(skb)->frag_list = NULL;
   43.24 +}
   43.25  
   43.26  struct netfront_info
   43.27  {
   43.28 @@ -134,16 +128,28 @@ struct netfront_info
   43.29  	int tx_ring_ref;
   43.30  	int rx_ring_ref;
   43.31  	u8 mac[ETH_ALEN];
   43.32 +
   43.33 +	unsigned long rx_pfn_array[NET_RX_RING_SIZE];
   43.34 +	multicall_entry_t rx_mcl[NET_RX_RING_SIZE+1];
   43.35 +	mmu_update_t rx_mmu[NET_RX_RING_SIZE];
   43.36  };
   43.37  
   43.38 -/* Access macros for acquiring freeing slots in {tx,rx}_skbs[]. */
   43.39 -#define ADD_ID_TO_FREELIST(_list, _id)			\
   43.40 -	(_list)[(_id)] = (_list)[0];			\
   43.41 -	(_list)[0]     = (void *)(unsigned long)(_id);
   43.42 -#define GET_ID_FROM_FREELIST(_list)				\
   43.43 -	({ unsigned long _id = (unsigned long)(_list)[0];	\
   43.44 -	   (_list)[0]  = (_list)[_id];				\
   43.45 -	   (unsigned short)_id; })
   43.46 +/*
   43.47 + * Access macros for acquiring freeing slots in {tx,rx}_skbs[].
   43.48 + */
   43.49 +
   43.50 +static inline void add_id_to_freelist(struct sk_buff **list, unsigned short id)
   43.51 +{
   43.52 +	list[id] = list[0];
   43.53 +	list[0]  = (void *)(unsigned long)id;
   43.54 +}
   43.55 +
   43.56 +static inline unsigned short get_id_from_freelist(struct sk_buff **list)
   43.57 +{
   43.58 +	unsigned int id = (unsigned int)(unsigned long)list[0];
   43.59 +	list[0] = list[id];
   43.60 +	return id;
   43.61 +}
   43.62  
   43.63  #ifdef DEBUG
   43.64  static char *be_state_name[] = {
   43.65 @@ -484,7 +490,7 @@ static void network_tx_buf_gc(struct net
   43.66  			gnttab_release_grant_reference(
   43.67  				&np->gref_tx_head, np->grant_tx_ref[id]);
   43.68  			np->grant_tx_ref[id] = GRANT_INVALID_REF;
   43.69 -			ADD_ID_TO_FREELIST(np->tx_skbs, id);
   43.70 +			add_id_to_freelist(np->tx_skbs, id);
   43.71  			dev_kfree_skb_irq(skb);
   43.72  		}
   43.73  
   43.74 @@ -545,9 +551,10 @@ static void network_alloc_rx_buffers(str
   43.75  		 * Subtract dev_alloc_skb headroom (16 bytes) and shared info
   43.76  		 * tailroom then round down to SKB_DATA_ALIGN boundary.
   43.77  		 */
   43.78 -		skb = alloc_xen_skb(
   43.79 +		skb = __dev_alloc_skb(
   43.80  			((PAGE_SIZE - sizeof(struct skb_shared_info)) &
   43.81 -			 (-SKB_DATA_ALIGN(1))) - 16);
   43.82 +			 (-SKB_DATA_ALIGN(1))) - 16,
   43.83 +			GFP_ATOMIC|__GFP_NOWARN);
   43.84  		if (skb == NULL) {
   43.85  			/* Any skbuffs queued for refill? Force them out. */
   43.86  			if (i != 0)
   43.87 @@ -576,7 +583,7 @@ static void network_alloc_rx_buffers(str
   43.88  
   43.89  		skb->dev = dev;
   43.90  
   43.91 -		id = GET_ID_FROM_FREELIST(np->rx_skbs);
   43.92 +		id = get_id_from_freelist(np->rx_skbs);
   43.93  
   43.94  		np->rx_skbs[id] = skb;
   43.95  
   43.96 @@ -588,13 +595,13 @@ static void network_alloc_rx_buffers(str
   43.97  						  np->xbdev->otherend_id,
   43.98  						  __pa(skb->head) >> PAGE_SHIFT);
   43.99  		RING_GET_REQUEST(&np->rx, req_prod + i)->gref = ref;
  43.100 -		rx_pfn_array[i] = virt_to_mfn(skb->head);
  43.101 +		np->rx_pfn_array[i] = virt_to_mfn(skb->head);
  43.102  
  43.103  		if (!xen_feature(XENFEAT_auto_translated_physmap)) {
  43.104  			/* Remove this page before passing back to Xen. */
  43.105  			set_phys_to_machine(__pa(skb->head) >> PAGE_SHIFT,
  43.106  					    INVALID_P2M_ENTRY);
  43.107 -			MULTI_update_va_mapping(rx_mcl+i,
  43.108 +			MULTI_update_va_mapping(np->rx_mcl+i,
  43.109  						(unsigned long)skb->head,
  43.110  						__pte(0), 0);
  43.111  		}
  43.112 @@ -603,7 +610,7 @@ static void network_alloc_rx_buffers(str
  43.113  	/* Tell the ballon driver what is going on. */
  43.114  	balloon_update_driver_allowance(i);
  43.115  
  43.116 -	reservation.extent_start = rx_pfn_array;
  43.117 +	reservation.extent_start = np->rx_pfn_array;
  43.118  	reservation.nr_extents   = i;
  43.119  	reservation.extent_order = 0;
  43.120  	reservation.address_bits = 0;
  43.121 @@ -611,19 +618,19 @@ static void network_alloc_rx_buffers(str
  43.122  
  43.123  	if (!xen_feature(XENFEAT_auto_translated_physmap)) {
  43.124  		/* After all PTEs have been zapped, flush the TLB. */
  43.125 -		rx_mcl[i-1].args[MULTI_UVMFLAGS_INDEX] =
  43.126 +		np->rx_mcl[i-1].args[MULTI_UVMFLAGS_INDEX] =
  43.127  			UVMF_TLB_FLUSH|UVMF_ALL;
  43.128  
  43.129  		/* Give away a batch of pages. */
  43.130 -		rx_mcl[i].op = __HYPERVISOR_memory_op;
  43.131 -		rx_mcl[i].args[0] = XENMEM_decrease_reservation;
  43.132 -		rx_mcl[i].args[1] = (unsigned long)&reservation;
  43.133 +		np->rx_mcl[i].op = __HYPERVISOR_memory_op;
  43.134 +		np->rx_mcl[i].args[0] = XENMEM_decrease_reservation;
  43.135 +		np->rx_mcl[i].args[1] = (unsigned long)&reservation;
  43.136  
  43.137  		/* Zap PTEs and give away pages in one big multicall. */
  43.138 -		(void)HYPERVISOR_multicall(rx_mcl, i+1);
  43.139 +		(void)HYPERVISOR_multicall(np->rx_mcl, i+1);
  43.140  
  43.141  		/* Check return status of HYPERVISOR_memory_op(). */
  43.142 -		if (unlikely(rx_mcl[i].result != i))
  43.143 +		if (unlikely(np->rx_mcl[i].result != i))
  43.144  			panic("Unable to reduce memory reservation\n");
  43.145  	} else
  43.146  		if (HYPERVISOR_memory_op(XENMEM_decrease_reservation,
  43.147 @@ -656,7 +663,8 @@ static int network_start_xmit(struct sk_
  43.148  	if (unlikely((((unsigned long)skb->data & ~PAGE_MASK) + skb->len) >=
  43.149  		     PAGE_SIZE)) {
  43.150  		struct sk_buff *nskb;
  43.151 -		if (unlikely((nskb = alloc_xen_skb(skb->len)) == NULL))
  43.152 +		nskb = __dev_alloc_skb(skb->len, GFP_ATOMIC|__GFP_NOWARN);
  43.153 +		if (unlikely(nskb == NULL))
  43.154  			goto drop;
  43.155  		skb_put(nskb, skb->len);
  43.156  		memcpy(nskb->data, skb->data, skb->len);
  43.157 @@ -674,7 +682,7 @@ static int network_start_xmit(struct sk_
  43.158  
  43.159  	i = np->tx.req_prod_pvt;
  43.160  
  43.161 -	id = GET_ID_FROM_FREELIST(np->tx_skbs);
  43.162 +	id = get_id_from_freelist(np->tx_skbs);
  43.163  	np->tx_skbs[id] = skb;
  43.164  
  43.165  	tx = RING_GET_REQUEST(&np->tx, i);
  43.166 @@ -739,8 +747,8 @@ static int netif_poll(struct net_device 
  43.167  	struct sk_buff *skb, *nskb;
  43.168  	netif_rx_response_t *rx;
  43.169  	RING_IDX i, rp;
  43.170 -	mmu_update_t *mmu = rx_mmu;
  43.171 -	multicall_entry_t *mcl = rx_mcl;
  43.172 +	mmu_update_t *mmu = np->rx_mmu;
  43.173 +	multicall_entry_t *mcl = np->rx_mcl;
  43.174  	int work_done, budget, more_to_do = 1;
  43.175  	struct sk_buff_head rxq;
  43.176  	unsigned long flags;
  43.177 @@ -796,14 +804,14 @@ static int netif_poll(struct net_device 
  43.178  		np->grant_rx_ref[rx->id] = GRANT_INVALID_REF;
  43.179  
  43.180  		skb = np->rx_skbs[rx->id];
  43.181 -		ADD_ID_TO_FREELIST(np->rx_skbs, rx->id);
  43.182 +		add_id_to_freelist(np->rx_skbs, rx->id);
  43.183  
  43.184  		/* NB. We handle skb overflow later. */
  43.185  		skb->data = skb->head + rx->offset;
  43.186  		skb->len  = rx->status;
  43.187  		skb->tail = skb->data + skb->len;
  43.188  
  43.189 -		if (rx->flags & NETRXF_csum_valid)
  43.190 +		if (rx->flags & NETRXF_data_validated)
  43.191  			skb->ip_summed = CHECKSUM_UNNECESSARY;
  43.192  
  43.193  		np->stats.rx_packets++;
  43.194 @@ -831,14 +839,14 @@ static int netif_poll(struct net_device 
  43.195  	balloon_update_driver_allowance(-work_done);
  43.196  
  43.197  	/* Do all the remapping work, and M2P updates, in one big hypercall. */
  43.198 -	if (likely((mcl - rx_mcl) != 0)) {
  43.199 +	if (likely((mcl - np->rx_mcl) != 0)) {
  43.200  		mcl->op = __HYPERVISOR_mmu_update;
  43.201 -		mcl->args[0] = (unsigned long)rx_mmu;
  43.202 -		mcl->args[1] = mmu - rx_mmu;
  43.203 +		mcl->args[0] = (unsigned long)np->rx_mmu;
  43.204 +		mcl->args[1] = mmu - np->rx_mmu;
  43.205  		mcl->args[2] = 0;
  43.206  		mcl->args[3] = DOMID_SELF;
  43.207  		mcl++;
  43.208 -		(void)HYPERVISOR_multicall(rx_mcl, mcl - rx_mcl);
  43.209 +		(void)HYPERVISOR_multicall(np->rx_mcl, mcl - np->rx_mcl);
  43.210  	}
  43.211  
  43.212  	while ((skb = __skb_dequeue(&rxq)) != NULL) {
  43.213 @@ -871,7 +879,8 @@ static int netif_poll(struct net_device 
  43.214  					       16 - (skb->data - skb->head));
  43.215  			}
  43.216  
  43.217 -			nskb = alloc_xen_skb(skb->len + 2);
  43.218 +			nskb = __dev_alloc_skb(skb->len + 2,
  43.219 +					       GFP_ATOMIC|__GFP_NOWARN);
  43.220  			if (nskb != NULL) {
  43.221  				skb_reserve(nskb, 2);
  43.222  				skb_put(nskb, skb->len);
    44.1 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/passthrough.c	Mon Mar 27 15:36:47 2006 -0700
    44.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/passthrough.c	Tue Mar 28 08:54:58 2006 -0700
    44.3 @@ -7,10 +7,13 @@
    44.4  
    44.5  #include <linux/list.h>
    44.6  #include <linux/pci.h>
    44.7 +#include <linux/spinlock.h>
    44.8  #include "pciback.h"
    44.9  
   44.10  struct passthrough_dev_data {
   44.11 +	/* Access to dev_list must be protected by lock */
   44.12  	struct list_head dev_list;
   44.13 +	spinlock_t lock;
   44.14  };
   44.15  
   44.16  struct pci_dev *pciback_get_pci_dev(struct pciback_device *pdev,
   44.17 @@ -19,33 +22,66 @@ struct pci_dev *pciback_get_pci_dev(stru
   44.18  {
   44.19  	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
   44.20  	struct pci_dev_entry *dev_entry;
   44.21 +	struct pci_dev *dev = NULL;
   44.22 +	unsigned long flags;
   44.23 +
   44.24 +	spin_lock_irqsave(&dev_data->lock, flags);
   44.25  
   44.26  	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
   44.27  		if (domain == (unsigned int)pci_domain_nr(dev_entry->dev->bus)
   44.28  		    && bus == (unsigned int)dev_entry->dev->bus->number
   44.29 -		    && devfn == dev_entry->dev->devfn)
   44.30 -			return dev_entry->dev;
   44.31 +		    && devfn == dev_entry->dev->devfn) {
   44.32 +			dev = dev_entry->dev;
   44.33 +			break;
   44.34 +		}
   44.35  	}
   44.36  
   44.37 -	return NULL;
   44.38 +	spin_unlock_irqrestore(&dev_data->lock, flags);
   44.39 +
   44.40 +	return dev;
   44.41  }
   44.42  
   44.43 -/* Must hold pciback_device->dev_lock when calling this */
   44.44  int pciback_add_pci_dev(struct pciback_device *pdev, struct pci_dev *dev)
   44.45  {
   44.46  	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
   44.47  	struct pci_dev_entry *dev_entry;
   44.48 +	unsigned long flags;
   44.49  
   44.50  	dev_entry = kmalloc(sizeof(*dev_entry), GFP_KERNEL);
   44.51  	if (!dev_entry)
   44.52  		return -ENOMEM;
   44.53  	dev_entry->dev = dev;
   44.54  
   44.55 +	spin_lock_irqsave(&dev_data->lock, flags);
   44.56  	list_add_tail(&dev_entry->list, &dev_data->dev_list);
   44.57 +	spin_unlock_irqrestore(&dev_data->lock, flags);
   44.58  
   44.59  	return 0;
   44.60  }
   44.61  
   44.62 +void pciback_release_pci_dev(struct pciback_device *pdev, struct pci_dev *dev)
   44.63 +{
   44.64 +	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
   44.65 +	struct pci_dev_entry *dev_entry, *t;
   44.66 +	struct pci_dev *found_dev = NULL;
   44.67 +	unsigned long flags;
   44.68 +
   44.69 +	spin_lock_irqsave(&dev_data->lock, flags);
   44.70 +
   44.71 +	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
   44.72 +		if (dev_entry->dev == dev) {
   44.73 +			list_del(&dev_entry->list);
   44.74 +			found_dev = dev_entry->dev;
   44.75 +			kfree(dev_entry);
   44.76 +		}
   44.77 +	}
   44.78 +
   44.79 +	spin_unlock_irqrestore(&dev_data->lock, flags);
   44.80 +
   44.81 +	if (found_dev)
   44.82 +		pcistub_put_pci_dev(found_dev);
   44.83 +}
   44.84 +
   44.85  int pciback_init_devices(struct pciback_device *pdev)
   44.86  {
   44.87  	struct passthrough_dev_data *dev_data;
   44.88 @@ -54,6 +90,8 @@ int pciback_init_devices(struct pciback_
   44.89  	if (!dev_data)
   44.90  		return -ENOMEM;
   44.91  
   44.92 +	spin_lock_init(&dev_data->lock);
   44.93 +
   44.94  	INIT_LIST_HEAD(&dev_data->dev_list);
   44.95  
   44.96  	pdev->pci_dev_data = dev_data;
   44.97 @@ -71,6 +109,8 @@ int pciback_publish_pci_roots(struct pci
   44.98  	int found;
   44.99  	unsigned int domain, bus;
  44.100  
  44.101 +	spin_lock(&dev_data->lock);
  44.102 +
  44.103  	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
  44.104  		/* Only publish this device as a root if none of its
  44.105  		 * parent bridges are exported
  44.106 @@ -96,10 +136,11 @@ int pciback_publish_pci_roots(struct pci
  44.107  		}
  44.108  	}
  44.109  
  44.110 +	spin_unlock(&dev_data->lock);
  44.111 +
  44.112  	return err;
  44.113  }
  44.114  
  44.115 -/* Must hold pciback_device->dev_lock when calling this */
  44.116  void pciback_release_devices(struct pciback_device *pdev)
  44.117  {
  44.118  	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
    45.1 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/pci_stub.c	Mon Mar 27 15:36:47 2006 -0700
    45.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/pci_stub.c	Tue Mar 28 08:54:58 2006 -0700
    45.3 @@ -7,110 +7,190 @@
    45.4  #include <linux/init.h>
    45.5  #include <linux/list.h>
    45.6  #include <linux/spinlock.h>
    45.7 +#include <linux/kref.h>
    45.8  #include <asm/atomic.h>
    45.9  #include "pciback.h"
   45.10  
   45.11  static char *pci_devs_to_hide = NULL;
   45.12  module_param_named(hide, pci_devs_to_hide, charp, 0444);
   45.13  
   45.14 -struct pci_stub_device_id {
   45.15 +struct pcistub_device_id {
   45.16  	struct list_head slot_list;
   45.17  	int domain;
   45.18  	unsigned char bus;
   45.19  	unsigned int devfn;
   45.20  };
   45.21 -LIST_HEAD(pci_stub_device_ids);
   45.22 +static LIST_HEAD(pcistub_device_ids);
   45.23 +static DEFINE_SPINLOCK(device_ids_lock);
   45.24  
   45.25 -struct pci_stub_device {
   45.26 +struct pcistub_device {
   45.27 +	struct kref kref;
   45.28  	struct list_head dev_list;
   45.29 +	spinlock_t lock;
   45.30 +
   45.31  	struct pci_dev *dev;
   45.32 -	atomic_t in_use;
   45.33 +	struct pciback_device *pdev;	/* non-NULL if struct pci_dev is in use */
   45.34  };
   45.35 -/* Access to pci_stub_devices & seized_devices lists and the initialize_devices
   45.36 - * flag must be locked with pci_stub_devices_lock
   45.37 +/* Access to pcistub_devices & seized_devices lists and the initialize_devices
   45.38 + * flag must be locked with pcistub_devices_lock
   45.39   */
   45.40 -DEFINE_SPINLOCK(pci_stub_devices_lock);
   45.41 -LIST_HEAD(pci_stub_devices);
   45.42 +static DEFINE_SPINLOCK(pcistub_devices_lock);
   45.43 +static LIST_HEAD(pcistub_devices);
   45.44  
   45.45  /* wait for device_initcall before initializing our devices
   45.46   * (see pcistub_init_devices_late)
   45.47   */
   45.48  static int initialize_devices = 0;
   45.49 -LIST_HEAD(seized_devices);
   45.50 +static LIST_HEAD(seized_devices);
   45.51  
   45.52 -static inline struct pci_dev *get_pci_dev(struct pci_stub_device *psdev)
   45.53 +static struct pcistub_device *pcistub_device_alloc(struct pci_dev *dev)
   45.54  {
   45.55 -	if (atomic_dec_and_test(&psdev->in_use))
   45.56 -		return psdev->dev;
   45.57 -	else {
   45.58 -		atomic_inc(&psdev->in_use);
   45.59 +	struct pcistub_device *psdev;
   45.60 +
   45.61 +	dev_dbg(&dev->dev, "pcistub_device_alloc\n");
   45.62 +
   45.63 +	psdev = kzalloc(sizeof(*psdev), GFP_ATOMIC);
   45.64 +	if (!psdev)
   45.65 +		return NULL;
   45.66 +
   45.67 +	psdev->dev = pci_dev_get(dev);
   45.68 +	if (!psdev->dev) {
   45.69 +		kfree(psdev);
   45.70  		return NULL;
   45.71  	}
   45.72 +
   45.73 +	kref_init(&psdev->kref);
   45.74 +	spin_lock_init(&psdev->lock);
   45.75 +
   45.76 +	return psdev;
   45.77  }
   45.78  
   45.79 -struct pci_dev *pcistub_get_pci_dev_by_slot(int domain, int bus,
   45.80 +/* Don't call this directly as it's called by pcistub_device_put */
   45.81 +static void pcistub_device_release(struct kref *kref)
   45.82 +{
   45.83 +	struct pcistub_device *psdev;
   45.84 +
   45.85 +	psdev = container_of(kref, struct pcistub_device, kref);
   45.86 +
   45.87 +	dev_dbg(&psdev->dev->dev, "pcistub_device_release\n");
   45.88 +
   45.89 +	/* Clean-up the device */
   45.90 +	pciback_reset_device(psdev->dev);
   45.91 +	pciback_config_free(psdev->dev);
   45.92 +	kfree(pci_get_drvdata(psdev->dev));
   45.93 +	pci_set_drvdata(psdev->dev, NULL);
   45.94 +
   45.95 +	pci_dev_put(psdev->dev);
   45.96 +
   45.97 +	kfree(psdev);
   45.98 +}
   45.99 +
  45.100 +static inline void pcistub_device_get(struct pcistub_device *psdev)
  45.101 +{
  45.102 +	kref_get(&psdev->kref);
  45.103 +}
  45.104 +
  45.105 +static inline void pcistub_device_put(struct pcistub_device *psdev)
  45.106 +{
  45.107 +	kref_put(&psdev->kref, pcistub_device_release);
  45.108 +}
  45.109 +
  45.110 +static struct pci_dev *pcistub_device_get_pci_dev(struct pciback_device *pdev,
  45.111 +						  struct pcistub_device *psdev)
  45.112 +{
  45.113 +	struct pci_dev *pci_dev = NULL;
  45.114 +	unsigned long flags;
  45.115 +
  45.116 +	pcistub_device_get(psdev);
  45.117 +
  45.118 +	spin_lock_irqsave(&psdev->lock, flags);
  45.119 +	if (!psdev->pdev) {
  45.120 +		psdev->pdev = pdev;
  45.121 +		pci_dev = psdev->dev;
  45.122 +	}
  45.123 +	spin_unlock_irqrestore(&psdev->lock, flags);
  45.124 +
  45.125 +	if (!pci_dev)
  45.126 +		pcistub_device_put(psdev);
  45.127 +
  45.128 +	return pci_dev;
  45.129 +}
  45.130 +
  45.131 +struct pci_dev *pcistub_get_pci_dev_by_slot(struct pciback_device *pdev,
  45.132 +					    int domain, int bus,
  45.133  					    int slot, int func)
  45.134  {
  45.135 -	struct pci_stub_device *psdev;
  45.136 +	struct pcistub_device *psdev;
  45.137  	struct pci_dev *found_dev = NULL;
  45.138 +	unsigned long flags;
  45.139  
  45.140 -	spin_lock(&pci_stub_devices_lock);
  45.141 +	spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.142  
  45.143 -	list_for_each_entry(psdev, &pci_stub_devices, dev_list) {
  45.144 +	list_for_each_entry(psdev, &pcistub_devices, dev_list) {
  45.145  		if (psdev->dev != NULL
  45.146  		    && domain == pci_domain_nr(psdev->dev->bus)
  45.147  		    && bus == psdev->dev->bus->number
  45.148  		    && PCI_DEVFN(slot, func) == psdev->dev->devfn) {
  45.149 -			found_dev = get_pci_dev(psdev);
  45.150 +			found_dev = pcistub_device_get_pci_dev(pdev, psdev);
  45.151  			break;
  45.152  		}
  45.153  	}
  45.154  
  45.155 -	spin_unlock(&pci_stub_devices_lock);
  45.156 +	spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.157  	return found_dev;
  45.158  }
  45.159  
  45.160 -struct pci_dev *pcistub_get_pci_dev(struct pci_dev *dev)
  45.161 +struct pci_dev *pcistub_get_pci_dev(struct pciback_device *pdev,
  45.162 +				    struct pci_dev *dev)
  45.163  {
  45.164 -	struct pci_stub_device *psdev;
  45.165 +	struct pcistub_device *psdev;
  45.166  	struct pci_dev *found_dev = NULL;
  45.167 +	unsigned long flags;
  45.168  
  45.169 -	spin_lock(&pci_stub_devices_lock);
  45.170 +	spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.171  
  45.172 -	list_for_each_entry(psdev, &pci_stub_devices, dev_list) {
  45.173 +	list_for_each_entry(psdev, &pcistub_devices, dev_list) {
  45.174  		if (psdev->dev == dev) {
  45.175 -			found_dev = get_pci_dev(psdev);
  45.176 +			found_dev = pcistub_device_get_pci_dev(pdev, psdev);
  45.177  			break;
  45.178  		}
  45.179  	}
  45.180  
  45.181 -	spin_unlock(&pci_stub_devices_lock);
  45.182 +	spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.183  	return found_dev;
  45.184  }
  45.185  
  45.186  void pcistub_put_pci_dev(struct pci_dev *dev)
  45.187  {
  45.188 -	struct pci_stub_device *psdev;
  45.189 +	struct pcistub_device *psdev, *found_psdev = NULL;
  45.190 +	unsigned long flags;
  45.191  
  45.192 -	spin_lock(&pci_stub_devices_lock);
  45.193 +	spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.194  
  45.195 -	list_for_each_entry(psdev, &pci_stub_devices, dev_list) {
  45.196 +	list_for_each_entry(psdev, &pcistub_devices, dev_list) {
  45.197  		if (psdev->dev == dev) {
  45.198 -			/* Cleanup our device
  45.199 -			 * (so it's ready for the next domain)
  45.200 -			 */
  45.201 -			pciback_reset_device(psdev->dev);
  45.202 -
  45.203 -			atomic_inc(&psdev->in_use);
  45.204 +			found_psdev = psdev;
  45.205  			break;
  45.206  		}
  45.207  	}
  45.208  
  45.209 -	spin_unlock(&pci_stub_devices_lock);
  45.210 +	spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.211 +
  45.212 +	/* Cleanup our device
  45.213 +	 * (so it's ready for the next domain)
  45.214 +	 */
  45.215 +	pciback_reset_device(found_psdev->dev);
  45.216 +	pciback_config_reset(found_psdev->dev);
  45.217 +
  45.218 +	spin_lock_irqsave(&found_psdev->lock, flags);
  45.219 +	found_psdev->pdev = NULL;
  45.220 +	spin_unlock_irqrestore(&found_psdev->lock, flags);
  45.221 +
  45.222 +	pcistub_device_put(found_psdev);
  45.223  }
  45.224  
  45.225 -static int __devinit pcistub_match(struct pci_dev *dev,
  45.226 -				   struct pci_stub_device_id *pdev_id)
  45.227 +static int __devinit pcistub_match_one(struct pci_dev *dev,
  45.228 +				       struct pcistub_device_id *pdev_id)
  45.229  {
  45.230  	/* Match the specified device by domain, bus, slot, func and also if
  45.231  	 * any of the device's parent bridges match.
  45.232 @@ -125,23 +205,44 @@ static int __devinit pcistub_match(struc
  45.233  	return 0;
  45.234  }
  45.235  
  45.236 +static int __devinit pcistub_match(struct pci_dev *dev)
  45.237 +{
  45.238 +	struct pcistub_device_id *pdev_id;
  45.239 +	unsigned long flags;
  45.240 +	int found = 0;
  45.241 +
  45.242 +	spin_lock_irqsave(&device_ids_lock, flags);
  45.243 +	list_for_each_entry(pdev_id, &pcistub_device_ids, slot_list) {
  45.244 +		if (pcistub_match_one(dev, pdev_id)) {
  45.245 +			found = 1;
  45.246 +			break;
  45.247 +		}
  45.248 +	}
  45.249 +	spin_unlock_irqrestore(&device_ids_lock, flags);
  45.250 +
  45.251 +	return found;
  45.252 +}
  45.253 +
  45.254  static int __devinit pcistub_init_device(struct pci_dev *dev)
  45.255  {
  45.256  	struct pciback_dev_data *dev_data;
  45.257  	int err = 0;
  45.258  
  45.259 +	dev_dbg(&dev->dev, "initializing...\n");
  45.260 +
  45.261  	/* The PCI backend is not intended to be a module (or to work with
  45.262  	 * removable PCI devices (yet). If it were, pciback_config_free()
  45.263  	 * would need to be called somewhere to free the memory allocated
  45.264  	 * here and then to call kfree(pci_get_drvdata(psdev->dev)).
  45.265  	 */
  45.266 -	dev_data = kmalloc(sizeof(*dev_data), GFP_KERNEL);
  45.267 +	dev_data = kmalloc(sizeof(*dev_data), GFP_ATOMIC);
  45.268  	if (!dev_data) {
  45.269  		err = -ENOMEM;
  45.270  		goto out;
  45.271  	}
  45.272  	pci_set_drvdata(dev, dev_data);
  45.273  
  45.274 +	dev_dbg(&dev->dev, "initializing config\n");
  45.275  	err = pciback_config_init(dev);
  45.276  	if (err)
  45.277  		goto out;
  45.278 @@ -153,14 +254,15 @@ static int __devinit pcistub_init_device
  45.279  	 * This makes the assumption that the device's resources won't
  45.280  	 * change after this point (otherwise this code may break!)
  45.281  	 */
  45.282 +	dev_dbg(&dev->dev, "enabling device\n");
  45.283  	err = pci_enable_device(dev);
  45.284  	if (err)
  45.285  		goto config_release;
  45.286  
  45.287  	/* Now disable the device (this also ensures some private device
  45.288  	 * data is setup before we export)
  45.289 -	 * This calls pciback_config_reset(dev)
  45.290  	 */
  45.291 +	dev_dbg(&dev->dev, "reset device\n");
  45.292  	pciback_reset_device(dev);
  45.293  
  45.294  	return 0;
  45.295 @@ -182,60 +284,82 @@ static int __devinit pcistub_init_device
  45.296   */
  45.297  static int __init pcistub_init_devices_late(void)
  45.298  {
  45.299 -	struct pci_stub_device *psdev, *t;
  45.300 +	struct pcistub_device *psdev;
  45.301 +	unsigned long flags;
  45.302  	int err = 0;
  45.303  
  45.304 -	spin_lock(&pci_stub_devices_lock);
  45.305 +	pr_debug("pciback: pcistub_init_devices_late\n");
  45.306  
  45.307 -	list_for_each_entry_safe(psdev, t, &seized_devices, dev_list) {
  45.308 +	spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.309 +
  45.310 +	while (!list_empty(&seized_devices)) {
  45.311 +		psdev = container_of(seized_devices.next,
  45.312 +				     struct pcistub_device, dev_list);
  45.313  		list_del(&psdev->dev_list);
  45.314 +
  45.315 +		spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.316 +
  45.317  		err = pcistub_init_device(psdev->dev);
  45.318  		if (err) {
  45.319 -			printk(KERN_ERR
  45.320 -			       "pciback: %s error %d initializing device\n",
  45.321 -			       pci_name(psdev->dev), err);
  45.322 +			dev_err(&psdev->dev->dev,
  45.323 +				"error %d initializing device\n", err);
  45.324  			kfree(psdev);
  45.325 -			continue;
  45.326 +			psdev = NULL;
  45.327  		}
  45.328  
  45.329 -		list_add_tail(&psdev->dev_list, &pci_stub_devices);
  45.330 +		spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.331 +
  45.332 +		if (psdev)
  45.333 +			list_add_tail(&psdev->dev_list, &pcistub_devices);
  45.334  	}
  45.335  
  45.336  	initialize_devices = 1;
  45.337  
  45.338 -	spin_unlock(&pci_stub_devices_lock);
  45.339 +	spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.340  
  45.341  	return 0;
  45.342  }
  45.343  
  45.344  static int __devinit pcistub_seize(struct pci_dev *dev)
  45.345  {
  45.346 -	struct pci_stub_device *psdev;
  45.347 +	struct pcistub_device *psdev;
  45.348 +	unsigned long flags;
  45.349 +	int initialize_devices_copy;
  45.350  	int err = 0;
  45.351  
  45.352 -	psdev = kmalloc(sizeof(*psdev), GFP_KERNEL);
  45.353 +	psdev = pcistub_device_alloc(dev);
  45.354  	if (!psdev)
  45.355  		return -ENOMEM;
  45.356  
  45.357 -	psdev->dev = dev;
  45.358 -	atomic_set(&psdev->in_use, 1);
  45.359 +	/* initialize_devices has to be accessed under a spin lock. But since
  45.360 +	 * it can only change from 0 -> 1, if it's already 1, we don't have to
  45.361 +	 * worry about it changing. That's why we can take a *copy* of
  45.362 +	 * initialize_devices and wait till we're outside of the lock to
  45.363 +	 * check if it's 1 (don't ever check if it's 0 outside of the lock)
  45.364 +	 */
  45.365 +	spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.366  
  45.367 -	spin_lock(&pci_stub_devices_lock);
  45.368 +	initialize_devices_copy = initialize_devices;
  45.369  
  45.370 -	if (initialize_devices) {
  45.371 +	if (!initialize_devices_copy) {
  45.372 +		dev_dbg(&dev->dev, "deferring initialization\n");
  45.373 +		list_add(&psdev->dev_list, &seized_devices);
  45.374 +	}
  45.375 +
  45.376 +	spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.377 +
  45.378 +	if (initialize_devices_copy) {
  45.379 +		/* don't want irqs disabled when calling pcistub_init_device */
  45.380  		err = pcistub_init_device(psdev->dev);
  45.381  		if (err)
  45.382  			goto out;
  45.383  
  45.384 -		list_add(&psdev->dev_list, &pci_stub_devices);
  45.385 -	} else
  45.386 -		list_add(&psdev->dev_list, &seized_devices);
  45.387 +		list_add(&psdev->dev_list, &pcistub_devices);
  45.388 +	}
  45.389  
  45.390        out:
  45.391 -	spin_unlock(&pci_stub_devices_lock);
  45.392 -
  45.393  	if (err)
  45.394 -		kfree(psdev);
  45.395 +		pcistub_device_put(psdev);
  45.396  
  45.397  	return err;
  45.398  }
  45.399 @@ -243,47 +367,78 @@ static int __devinit pcistub_seize(struc
  45.400  static int __devinit pcistub_probe(struct pci_dev *dev,
  45.401  				   const struct pci_device_id *id)
  45.402  {
  45.403 -	struct pci_stub_device_id *pdev_id;
  45.404 -	struct pci_dev *seized_dev;
  45.405  	int err = 0;
  45.406  
  45.407 -	list_for_each_entry(pdev_id, &pci_stub_device_ids, slot_list) {
  45.408 +	dev_dbg(&dev->dev, "probing...\n");
  45.409  
  45.410 -		if (!pcistub_match(dev, pdev_id))
  45.411 -			continue;
  45.412 +	if (pcistub_match(dev)) {
  45.413  
  45.414  		if (dev->hdr_type != PCI_HEADER_TYPE_NORMAL
  45.415  		    && dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
  45.416 -			printk(KERN_ERR
  45.417 -			       "pciback: %s: can't export pci devices that "
  45.418 -			       "don't have a normal (0) or bridge (1) "
  45.419 -			       "header type!\n", pci_name(dev));
  45.420 -			break;
  45.421 +			dev_err(&dev->dev, "can't export pci devices that "
  45.422 +				"don't have a normal (0) or bridge (1) "
  45.423 +				"header type!\n");
  45.424 +			err = -ENODEV;
  45.425 +			goto out;
  45.426  		}
  45.427  
  45.428 -		pr_info("pciback: seizing PCI device %s\n", pci_name(dev));
  45.429 -		seized_dev = pci_dev_get(dev);
  45.430 -
  45.431 -		if (seized_dev) {
  45.432 -			err = pcistub_seize(seized_dev);
  45.433 -			if (err) {
  45.434 -				pci_dev_put(dev);
  45.435 -				goto out;
  45.436 -			}
  45.437 -
  45.438 -			/* Success! */
  45.439 -			goto out;
  45.440 -		}
  45.441 -	}
  45.442 -
  45.443 -	/* Didn't find the device */
  45.444 -	err = -ENODEV;
  45.445 +		dev_info(&dev->dev, "seizing device\n");
  45.446 +		err = pcistub_seize(dev);
  45.447 +	} else
  45.448 +		/* Didn't find the device */
  45.449 +		err = -ENODEV;
  45.450  
  45.451        out:
  45.452  	return err;
  45.453  }
  45.454  
  45.455 -struct pci_device_id pcistub_ids[] = {
  45.456 +static void pcistub_remove(struct pci_dev *dev)
  45.457 +{
  45.458 +	struct pcistub_device *psdev, *found_psdev = NULL;
  45.459 +	unsigned long flags;
  45.460 +
  45.461 +	dev_dbg(&dev->dev, "removing\n");
  45.462 +
  45.463 +	spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.464 +
  45.465 +	list_for_each_entry(psdev, &pcistub_devices, dev_list) {
  45.466 +		if (psdev->dev == dev) {
  45.467 +			found_psdev = psdev;
  45.468 +			break;
  45.469 +		}
  45.470 +	}
  45.471 +
  45.472 +	spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.473 +
  45.474 +	if (found_psdev) {
  45.475 +		dev_dbg(&dev->dev, "found device to remove - in use? %p\n",
  45.476 +			found_psdev->pdev);
  45.477 +
  45.478 +		if (found_psdev->pdev) {
  45.479 +			printk(KERN_WARNING "pciback: ****** removing device "
  45.480 +			       "%s while still in-use! ******\n",
  45.481 +			       pci_name(found_psdev->dev));
  45.482 +			printk(KERN_WARNING "pciback: ****** driver domain may "
  45.483 +			       "still access this device's i/o resources!\n");
  45.484 +			printk(KERN_WARNING "pciback: ****** shutdown driver "
  45.485 +			       "domain before binding device\n");
  45.486 +			printk(KERN_WARNING "pciback: ****** to other drivers "
  45.487 +			       "or domains\n");
  45.488 +
  45.489 +			pciback_release_pci_dev(found_psdev->pdev,
  45.490 +						found_psdev->dev);
  45.491 +		}
  45.492 +
  45.493 +		spin_lock_irqsave(&pcistub_devices_lock, flags);
  45.494 +		list_del(&found_psdev->dev_list);
  45.495 +		spin_unlock_irqrestore(&pcistub_devices_lock, flags);
  45.496 +
  45.497 +		/* the final put for releasing from the list */
  45.498 +		pcistub_device_put(found_psdev);
  45.499 +	}
  45.500 +}
  45.501 +
  45.502 +static struct pci_device_id pcistub_ids[] = {
  45.503  	{
  45.504  	 .vendor = PCI_ANY_ID,
  45.505  	 .device = PCI_ANY_ID,
  45.506 @@ -298,16 +453,152 @@ struct pci_device_id pcistub_ids[] = {
  45.507   * for a normal device. I don't want it to be loaded automatically.
  45.508   */
  45.509  
  45.510 -struct pci_driver pciback_pci_driver = {
  45.511 +static struct pci_driver pciback_pci_driver = {
  45.512  	.name = "pciback",
  45.513  	.id_table = pcistub_ids,
  45.514  	.probe = pcistub_probe,
  45.515 +	.remove = pcistub_remove,
  45.516  };
  45.517  
  45.518 +static inline int str_to_slot(const char *buf, int *domain, int *bus,
  45.519 +			      int *slot, int *func)
  45.520 +{
  45.521 +	int err;
  45.522 +
  45.523 +	err = sscanf(buf, " %x:%x:%x.%x", domain, bus, slot, func);
  45.524 +	if (err == 4)
  45.525 +		return 0;
  45.526 +	else if (err < 0)
  45.527 +		return -EINVAL;
  45.528 +
  45.529 +	/* try again without domain */
  45.530 +	*domain = 0;
  45.531 +	err = sscanf(buf, " %x:%x.%x", bus, slot, func);
  45.532 +	if (err == 3)
  45.533 +		return 0;
  45.534 +
  45.535 +	return -EINVAL;
  45.536 +}
  45.537 +
  45.538 +static int pcistub_device_id_add(int domain, int bus, int slot, int func)
  45.539 +{
  45.540 +	struct pcistub_device_id *pci_dev_id;
  45.541 +	unsigned long flags;
  45.542 +
  45.543 +	pci_dev_id = kmalloc(sizeof(*pci_dev_id), GFP_KERNEL);
  45.544 +	if (!pci_dev_id)
  45.545 +		return -ENOMEM;
  45.546 +
  45.547 +	pci_dev_id->domain = domain;
  45.548 +	pci_dev_id->bus = bus;
  45.549 +	pci_dev_id->devfn = PCI_DEVFN(slot, func);
  45.550 +
  45.551 +	pr_debug("pciback: wants to seize %04x:%02x:%02x.%01x\n",
  45.552 +		 domain, bus, slot, func);
  45.553 +
  45.554 +	spin_lock_irqsave(&device_ids_lock, flags);
  45.555 +	list_add_tail(&pci_dev_id->slot_list, &pcistub_device_ids);
  45.556 +	spin_unlock_irqrestore(&device_ids_lock, flags);
  45.557 +
  45.558 +	return 0;
  45.559 +}
  45.560 +
  45.561 +static int pcistub_device_id_remove(int domain, int bus, int slot, int func)
  45.562 +{
  45.563 +	struct pcistub_device_id *pci_dev_id, *t;
  45.564 +	int devfn = PCI_DEVFN(slot, func);
  45.565 +	int err = -ENOENT;
  45.566 +	unsigned long flags;
  45.567 +
  45.568 +	spin_lock_irqsave(&device_ids_lock, flags);
  45.569 +	list_for_each_entry_safe(pci_dev_id, t, &pcistub_device_ids, slot_list) {
  45.570 +
  45.571 +		if (pci_dev_id->domain == domain
  45.572 +		    && pci_dev_id->bus == bus && pci_dev_id->devfn == devfn) {
  45.573 +			/* Don't break; here because it's possible the same
  45.574 +			 * slot could be in the list more than once
  45.575 +			 */
  45.576 +			list_del(&pci_dev_id->slot_list);
  45.577 +			kfree(pci_dev_id);
  45.578 +
  45.579 +			err = 0;
  45.580 +
  45.581 +			pr_debug("pciback: removed %04x:%02x:%02x.%01x from "
  45.582 +				 "seize list\n", domain, bus, slot, func);
  45.583 +		}
  45.584 +	}
  45.585 +	spin_unlock_irqrestore(&device_ids_lock, flags);
  45.586 +
  45.587 +	return err;
  45.588 +}
  45.589 +
  45.590 +static ssize_t pcistub_slot_add(struct device_driver *drv, const char *buf,
  45.591 +				size_t count)
  45.592 +{
  45.593 +	int domain, bus, slot, func;
  45.594 +	int err;
  45.595 +
  45.596 +	err = str_to_slot(buf, &domain, &bus, &slot, &func);
  45.597 +	if (err)
  45.598 +		goto out;
  45.599 +
  45.600 +	err = pcistub_device_id_add(domain, bus, slot, func);
  45.601 +
  45.602 +      out:
  45.603 +	if (!err)
  45.604 +		err = count;
  45.605 +	return err;
  45.606 +}
  45.607 +
  45.608 +DRIVER_ATTR(new_slot, S_IWUSR, NULL, pcistub_slot_add);
  45.609 +
  45.610 +static ssize_t pcistub_slot_remove(struct device_driver *drv, const char *buf,
  45.611 +				   size_t count)
  45.612 +{
  45.613 +	int domain, bus, slot, func;
  45.614 +	int err;
  45.615 +
  45.616 +	err = str_to_slot(buf, &domain, &bus, &slot, &func);
  45.617 +	if (err)
  45.618 +		goto out;
  45.619 +
  45.620 +	err = pcistub_device_id_remove(domain, bus, slot, func);
  45.621 +
  45.622 +      out:
  45.623 +	if (!err)
  45.624 +		err = count;
  45.625 +	return err;
  45.626 +}
  45.627 +
  45.628 +DRIVER_ATTR(remove_slot, S_IWUSR, NULL, pcistub_slot_remove);
  45.629 +
  45.630 +static ssize_t pcistub_slot_show(struct device_driver *drv, char *buf)
  45.631 +{
  45.632 +	struct pcistub_device_id *pci_dev_id;
  45.633 +	size_t count = 0;
  45.634 +	unsigned long flags;
  45.635 +
  45.636 +	spin_lock_irqsave(&device_ids_lock, flags);
  45.637 +	list_for_each_entry(pci_dev_id, &pcistub_device_ids, slot_list) {
  45.638 +		if (count >= PAGE_SIZE)
  45.639 +			break;
  45.640 +
  45.641 +		count += scnprintf(buf + count, PAGE_SIZE - count,
  45.642 +				   "%04x:%02x:%02x.%01x\n",
  45.643 +				   pci_dev_id->domain, pci_dev_id->bus,
  45.644 +				   PCI_SLOT(pci_dev_id->devfn),
  45.645 +				   PCI_FUNC(pci_dev_id->devfn));
  45.646 +	}
  45.647 +	spin_unlock_irqrestore(&device_ids_lock, flags);
  45.648 +
  45.649 +	return count;
  45.650 +}
  45.651 +
  45.652 +DRIVER_ATTR(slots, S_IRUSR, pcistub_slot_show, NULL);
  45.653 +
  45.654  static int __init pcistub_init(void)
  45.655  {
  45.656  	int pos = 0;
  45.657 -	struct pci_stub_device_id *pci_dev_id;
  45.658  	int err = 0;
  45.659  	int domain, bus, slot, func;
  45.660  	int parsed;
  45.661 @@ -328,33 +619,27 @@ static int __init pcistub_init(void)
  45.662  					goto parse_error;
  45.663  			}
  45.664  
  45.665 -			pci_dev_id = kmalloc(sizeof(*pci_dev_id), GFP_KERNEL);
  45.666 -			if (!pci_dev_id) {
  45.667 -				err = -ENOMEM;
  45.668 +			err = pcistub_device_id_add(domain, bus, slot, func);
  45.669 +			if (err)
  45.670  				goto out;
  45.671 -			}
  45.672 -
  45.673 -			pci_dev_id->domain = domain;
  45.674 -			pci_dev_id->bus = bus;
  45.675 -			pci_dev_id->devfn = PCI_DEVFN(slot, func);
  45.676 -
  45.677 -			pr_debug
  45.678 -			    ("pciback: wants to seize %04x:%02x:%02x.%01x\n",
  45.679 -			     domain, bus, slot, func);
  45.680 -
  45.681 -			list_add_tail(&pci_dev_id->slot_list,
  45.682 -				      &pci_stub_device_ids);
  45.683  
  45.684  			/* if parsed<=0, we've reached the end of the string */
  45.685  			pos += parsed;
  45.686  		} while (parsed > 0 && pci_devs_to_hide[pos]);
  45.687 +	}
  45.688  
  45.689 -		/* If we're the first PCI Device Driver to register, we're the
  45.690 -		 * first one to get offered PCI devices as they become
  45.691 -		 * available (and thus we can be the first to grab them)
  45.692 -		 */
  45.693 -		pci_register_driver(&pciback_pci_driver);
  45.694 -	}
  45.695 +	/* If we're the first PCI Device Driver to register, we're the
  45.696 +	 * first one to get offered PCI devices as they become
  45.697 +	 * available (and thus we can be the first to grab them)
  45.698 +	 */
  45.699 +	err = pci_register_driver(&pciback_pci_driver);
  45.700 +	if (err < 0)
  45.701 +		goto out;
  45.702 +
  45.703 +	driver_create_file(&pciback_pci_driver.driver, &driver_attr_new_slot);
  45.704 +	driver_create_file(&pciback_pci_driver.driver,
  45.705 +			   &driver_attr_remove_slot);
  45.706 +	driver_create_file(&pciback_pci_driver.driver, &driver_attr_slots);
  45.707  
  45.708        out:
  45.709  	return err;
  45.710 @@ -386,19 +671,22 @@ static int __init pciback_init(void)
  45.711  		return err;
  45.712  #endif
  45.713  
  45.714 -	if (list_empty(&pci_stub_device_ids))
  45.715 -		return -ENODEV;
  45.716  	pcistub_init_devices_late();
  45.717  	pciback_xenbus_register();
  45.718  
  45.719 -	__unsafe(THIS_MODULE);
  45.720 -
  45.721  	return 0;
  45.722  }
  45.723  
  45.724 -static void pciback_cleanup(void)
  45.725 +static void __exit pciback_cleanup(void)
  45.726  {
  45.727 -	BUG();
  45.728 +	pciback_xenbus_unregister();
  45.729 +
  45.730 +	driver_remove_file(&pciback_pci_driver.driver, &driver_attr_new_slot);
  45.731 +	driver_remove_file(&pciback_pci_driver.driver,
  45.732 +			   &driver_attr_remove_slot);
  45.733 +	driver_remove_file(&pciback_pci_driver.driver, &driver_attr_slots);
  45.734 +
  45.735 +	pci_unregister_driver(&pciback_pci_driver);
  45.736  }
  45.737  
  45.738  module_init(pciback_init);
    46.1 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/pciback.h	Mon Mar 27 15:36:47 2006 -0700
    46.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/pciback.h	Tue Mar 28 08:54:58 2006 -0700
    46.3 @@ -37,9 +37,11 @@ struct pciback_dev_data {
    46.4  };
    46.5  
    46.6  /* Get/Put PCI Devices that are hidden from the PCI Backend Domain */
    46.7 -struct pci_dev *pcistub_get_pci_dev_by_slot(int domain, int bus,
    46.8 +struct pci_dev *pcistub_get_pci_dev_by_slot(struct pciback_device *pdev,
    46.9 +					    int domain, int bus,
   46.10  					    int slot, int func);
   46.11 -struct pci_dev *pcistub_get_pci_dev(struct pci_dev *dev);
   46.12 +struct pci_dev *pcistub_get_pci_dev(struct pciback_device *pdev,
   46.13 +				    struct pci_dev *dev);
   46.14  void pcistub_put_pci_dev(struct pci_dev *dev);
   46.15  
   46.16  /* Ensure a device is turned off or reset */
   46.17 @@ -57,6 +59,7 @@ int pciback_config_write(struct pci_dev 
   46.18  typedef int (*publish_pci_root_cb) (struct pciback_device * pdev,
   46.19  				    unsigned int domain, unsigned int bus);
   46.20  int pciback_add_pci_dev(struct pciback_device *pdev, struct pci_dev *dev);
   46.21 +void pciback_release_pci_dev(struct pciback_device *pdev, struct pci_dev *dev);
   46.22  struct pci_dev *pciback_get_pci_dev(struct pciback_device *pdev,
   46.23  				    unsigned int domain, unsigned int bus,
   46.24  				    unsigned int devfn);
   46.25 @@ -69,6 +72,7 @@ void pciback_release_devices(struct pcib
   46.26  irqreturn_t pciback_handle_event(int irq, void *dev_id, struct pt_regs *regs);
   46.27  
   46.28  int pciback_xenbus_register(void);
   46.29 +void pciback_xenbus_unregister(void);
   46.30  
   46.31  extern int verbose_request;
   46.32  #endif
    47.1 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/pciback_ops.c	Mon Mar 27 15:36:47 2006 -0700
    47.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/pciback_ops.c	Tue Mar 28 08:54:58 2006 -0700
    47.3 @@ -12,9 +12,8 @@ int verbose_request = 0;
    47.4  module_param(verbose_request, int, 0644);
    47.5  
    47.6  /* Ensure a device is "turned off" and ready to be exported.
    47.7 - * This also sets up the device's private data to keep track of what should
    47.8 - * be in the base address registers (BARs) so that we can keep the
    47.9 - * client from manipulating them directly.
   47.10 + * (Also see pciback_config_reset to ensure virtual configuration space is
   47.11 + * ready to be re-exported)
   47.12   */
   47.13  void pciback_reset_device(struct pci_dev *dev)
   47.14  {
    48.1 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/vpci.c	Mon Mar 27 15:36:47 2006 -0700
    48.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/vpci.c	Tue Mar 28 08:54:58 2006 -0700
    48.3 @@ -8,12 +8,15 @@
    48.4  #include <linux/list.h>
    48.5  #include <linux/slab.h>
    48.6  #include <linux/pci.h>
    48.7 +#include <linux/spinlock.h>
    48.8  #include "pciback.h"
    48.9  
   48.10  #define PCI_SLOT_MAX 32
   48.11  
   48.12  struct vpci_dev_data {
   48.13 +	/* Access to dev_list must be protected by lock */
   48.14  	struct list_head dev_list[PCI_SLOT_MAX];
   48.15 +	spinlock_t lock;
   48.16  };
   48.17  
   48.18  static inline struct list_head *list_first(struct list_head *head)
   48.19 @@ -25,25 +28,29 @@ struct pci_dev *pciback_get_pci_dev(stru
   48.20  				    unsigned int domain, unsigned int bus,
   48.21  				    unsigned int devfn)
   48.22  {
   48.23 -	struct pci_dev_entry *dev_entry;
   48.24 +	struct pci_dev_entry *entry;
   48.25 +	struct pci_dev *dev = NULL;
   48.26  	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
   48.27 +	unsigned long flags;
   48.28  
   48.29  	if (domain != 0 || bus != 0)
   48.30  		return NULL;
   48.31  
   48.32  	if (PCI_SLOT(devfn) < PCI_SLOT_MAX) {
   48.33 -		/* we don't need to lock the list here because once the backend
   48.34 -		 * is in operation, it won't have any more devices addeded
   48.35 -		 * (or removed).
   48.36 -		 */
   48.37 -		list_for_each_entry(dev_entry,
   48.38 +		spin_lock_irqsave(&vpci_dev->lock, flags);
   48.39 +
   48.40 +		list_for_each_entry(entry,
   48.41  				    &vpci_dev->dev_list[PCI_SLOT(devfn)],
   48.42  				    list) {
   48.43 -			if (PCI_FUNC(dev_entry->dev->devfn) == PCI_FUNC(devfn))
   48.44 -				return dev_entry->dev;
   48.45 +			if (PCI_FUNC(entry->dev->devfn) == PCI_FUNC(devfn)) {
   48.46 +				dev = entry->dev;
   48.47 +				break;
   48.48 +			}
   48.49  		}
   48.50 +
   48.51 +		spin_unlock_irqrestore(&vpci_dev->lock, flags);
   48.52  	}
   48.53 -	return NULL;
   48.54 +	return dev;
   48.55  }
   48.56  
   48.57  static inline int match_slot(struct pci_dev *l, struct pci_dev *r)
   48.58 @@ -55,12 +62,12 @@ static inline int match_slot(struct pci_
   48.59  	return 0;
   48.60  }
   48.61  
   48.62 -/* Must hold pciback_device->dev_lock when calling this */
   48.63  int pciback_add_pci_dev(struct pciback_device *pdev, struct pci_dev *dev)
   48.64  {
   48.65  	int err = 0, slot;
   48.66  	struct pci_dev_entry *t, *dev_entry;
   48.67  	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
   48.68 +	unsigned long flags;
   48.69  
   48.70  	if ((dev->class >> 24) == PCI_BASE_CLASS_BRIDGE) {
   48.71  		err = -EFAULT;
   48.72 @@ -79,6 +86,8 @@ int pciback_add_pci_dev(struct pciback_d
   48.73  
   48.74  	dev_entry->dev = dev;
   48.75  
   48.76 +	spin_lock_irqsave(&vpci_dev->lock, flags);
   48.77 +
   48.78  	/* Keep multi-function devices together on the virtual PCI bus */
   48.79  	for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
   48.80  		if (!list_empty(&vpci_dev->dev_list[slot])) {
   48.81 @@ -92,7 +101,7 @@ int pciback_add_pci_dev(struct pciback_d
   48.82  					PCI_FUNC(dev->devfn));
   48.83  				list_add_tail(&dev_entry->list,
   48.84  					      &vpci_dev->dev_list[slot]);
   48.85 -				goto out;
   48.86 +				goto unlock;
   48.87  			}
   48.88  		}
   48.89  	}
   48.90 @@ -105,7 +114,7 @@ int pciback_add_pci_dev(struct pciback_d
   48.91  			       pci_name(dev), slot);
   48.92  			list_add_tail(&dev_entry->list,
   48.93  				      &vpci_dev->dev_list[slot]);
   48.94 -			goto out;
   48.95 +			goto unlock;
   48.96  		}
   48.97  	}
   48.98  
   48.99 @@ -113,10 +122,41 @@ int pciback_add_pci_dev(struct pciback_d
  48.100  	xenbus_dev_fatal(pdev->xdev, err,
  48.101  			 "No more space on root virtual PCI bus");
  48.102  
  48.103 +      unlock:
  48.104 +	spin_unlock_irqrestore(&vpci_dev->lock, flags);
  48.105        out:
  48.106  	return err;
  48.107  }
  48.108  
  48.109 +void pciback_release_pci_dev(struct pciback_device *pdev, struct pci_dev *dev)
  48.110 +{
  48.111 +	int slot;
  48.112 +	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
  48.113 +	struct pci_dev *found_dev = NULL;
  48.114 +	unsigned long flags;
  48.115 +
  48.116 +	spin_lock_irqsave(&vpci_dev->lock, flags);
  48.117 +
  48.118 +	for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
  48.119 +		struct pci_dev_entry *e, *tmp;
  48.120 +		list_for_each_entry_safe(e, tmp, &vpci_dev->dev_list[slot],
  48.121 +					 list) {
  48.122 +			if (e->dev == dev) {
  48.123 +				list_del(&e->list);
  48.124 +				found_dev = e->dev;
  48.125 +				kfree(e);
  48.126 +				goto out;
  48.127 +			}
  48.128 +		}
  48.129 +	}
  48.130 +
  48.131 +      out:
  48.132 +	spin_unlock_irqrestore(&vpci_dev->lock, flags);
  48.133 +
  48.134 +	if (found_dev)
  48.135 +		pcistub_put_pci_dev(found_dev);
  48.136 +}
  48.137 +
  48.138  int pciback_init_devices(struct pciback_device *pdev)
  48.139  {
  48.140  	int slot;
  48.141 @@ -126,6 +166,8 @@ int pciback_init_devices(struct pciback_
  48.142  	if (!vpci_dev)
  48.143  		return -ENOMEM;
  48.144  
  48.145 +	spin_lock_init(&vpci_dev->lock);
  48.146 +
  48.147  	for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
  48.148  		INIT_LIST_HEAD(&vpci_dev->dev_list[slot]);
  48.149  	}
  48.150 @@ -142,7 +184,6 @@ int pciback_publish_pci_roots(struct pci
  48.151  	return publish_cb(pdev, 0, 0);
  48.152  }
  48.153  
  48.154 -/* Must hold pciback_device->dev_lock when calling this */
  48.155  void pciback_release_devices(struct pciback_device *pdev)
  48.156  {
  48.157  	int slot;
    49.1 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/xenbus.c	Mon Mar 27 15:36:47 2006 -0700
    49.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/xenbus.c	Tue Mar 28 08:54:58 2006 -0700
    49.3 @@ -12,7 +12,7 @@
    49.4  
    49.5  #define INVALID_EVTCHN_IRQ  (-1)
    49.6  
    49.7 -struct pciback_device *alloc_pdev(struct xenbus_device *xdev)
    49.8 +static struct pciback_device *alloc_pdev(struct xenbus_device *xdev)
    49.9  {
   49.10  	struct pciback_device *pdev;
   49.11  
   49.12 @@ -38,7 +38,7 @@ struct pciback_device *alloc_pdev(struct
   49.13  	return pdev;
   49.14  }
   49.15  
   49.16 -void free_pdev(struct pciback_device *pdev)
   49.17 +static void free_pdev(struct pciback_device *pdev)
   49.18  {
   49.19  	if (pdev->be_watching)
   49.20  		unregister_xenbus_watch(&pdev->be_watch);
   49.21 @@ -247,7 +247,7 @@ static int pciback_export_device(struct 
   49.22  	dev_dbg(&pdev->xdev->dev, "exporting dom %x bus %x slot %x func %x\n",
   49.23  		domain, bus, slot, func);
   49.24  
   49.25 -	dev = pcistub_get_pci_dev_by_slot(domain, bus, slot, func);
   49.26 +	dev = pcistub_get_pci_dev_by_slot(pdev, domain, bus, slot, func);
   49.27  	if (!dev) {
   49.28  		err = -EINVAL;
   49.29  		xenbus_dev_fatal(pdev->xdev, err,
   49.30 @@ -434,3 +434,8 @@ int __init pciback_xenbus_register(void)
   49.31  {
   49.32  	return xenbus_register_backend(&xenbus_pciback_driver);
   49.33  }
   49.34 +
   49.35 +void __exit pciback_xenbus_unregister(void)
   49.36 +{
   49.37 +	xenbus_unregister_driver(&xenbus_pciback_driver);
   49.38 +}
    50.1 --- a/linux-2.6-xen-sparse/drivers/xen/pcifront/pci_op.c	Mon Mar 27 15:36:47 2006 -0700
    50.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pcifront/pci_op.c	Tue Mar 28 08:54:58 2006 -0700
    50.3 @@ -56,19 +56,19 @@ static int do_pci_op(struct pcifront_dev
    50.4  	notify_remote_via_evtchn(port);
    50.5  
    50.6  	/*
    50.7 -	 * We set a poll timeout of 5 seconds but give up on return after
    50.8 -	 * 4 seconds. It is better to time out too late rather than too early
    50.9 +	 * We set a poll timeout of 3 seconds but give up on return after
   50.10 +	 * 2 seconds. It is better to time out too late rather than too early
   50.11  	 * (in the latter case we end up continually re-executing poll() with a
   50.12  	 * timeout in the past). 1s difference gives plenty of slack for error.
   50.13  	 */
   50.14  	do_gettimeofday(&tv);
   50.15 -	ns_timeout = timeval_to_ns(&tv) + 4 * (nsec_t)NSEC_PER_SEC;
   50.16 +	ns_timeout = timeval_to_ns(&tv) + 2 * (nsec_t)NSEC_PER_SEC;
   50.17  
   50.18  	clear_evtchn(port);
   50.19  
   50.20  	while (test_bit(_XEN_PCIF_active,
   50.21  			(unsigned long *)&pdev->sh_info->flags)) {
   50.22 -		if (HYPERVISOR_poll(&port, 1, jiffies + 5*HZ))
   50.23 +		if (HYPERVISOR_poll(&port, 1, jiffies + 3*HZ))
   50.24  			BUG();
   50.25  		clear_evtchn(port);
   50.26  		do_gettimeofday(&tv);
   50.27 @@ -173,7 +173,7 @@ static void pcifront_claim_resource(stru
   50.28  
   50.29  		if (!r->parent && r->start && r->flags) {
   50.30  			dev_dbg(&pdev->xdev->dev, "claiming resource %s/%d\n",
   50.31 -					pci_name(dev), i);
   50.32 +				pci_name(dev), i);
   50.33  			pci_claim_resource(dev, i);
   50.34  		}
   50.35  	}
   50.36 @@ -234,25 +234,38 @@ int pcifront_scan_root(struct pcifront_d
   50.37  	return err;
   50.38  }
   50.39  
   50.40 +static void free_root_bus_devs(struct pci_bus *bus)
   50.41 +{
   50.42 +	struct pci_dev *dev;
   50.43 +
   50.44 +	spin_lock(&pci_bus_lock);
   50.45 +	while (!list_empty(&bus->devices)) {
   50.46 +		dev = container_of(bus->devices.next, struct pci_dev, bus_list);
   50.47 +		spin_unlock(&pci_bus_lock);
   50.48 +
   50.49 +		dev_dbg(&dev->dev, "removing device\n");
   50.50 +		pci_remove_bus_device(dev);
   50.51 +
   50.52 +		spin_lock(&pci_bus_lock);
   50.53 +	}
   50.54 +	spin_unlock(&pci_bus_lock);
   50.55 +}
   50.56 +
   50.57  void pcifront_free_roots(struct pcifront_device *pdev)
   50.58  {
   50.59  	struct pci_bus_entry *bus_entry, *t;
   50.60  
   50.61 +	dev_dbg(&pdev->xdev->dev, "cleaning up root buses\n");
   50.62 +
   50.63  	list_for_each_entry_safe(bus_entry, t, &pdev->root_buses, list) {
   50.64 -		/* TODO: Removing a PCI Bus is untested (as it normally
   50.65 -		 * just goes away on domain shutdown)
   50.66 -		 */
   50.67  		list_del(&bus_entry->list);
   50.68  
   50.69 -		spin_lock(&pci_bus_lock);
   50.70 -		list_del(&bus_entry->bus->node);
   50.71 -		spin_unlock(&pci_bus_lock);
   50.72 +		free_root_bus_devs(bus_entry->bus);
   50.73  
   50.74  		kfree(bus_entry->bus->sysdata);
   50.75  
   50.76  		device_unregister(bus_entry->bus->bridge);
   50.77 -
   50.78 -		/* Do we need to free() the bus itself? */
   50.79 +		pci_remove_bus(bus_entry->bus);
   50.80  
   50.81  		kfree(bus_entry);
   50.82  	}
    51.1 --- a/linux-2.6-xen-sparse/drivers/xen/pcifront/xenbus.c	Mon Mar 27 15:36:47 2006 -0700
    51.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pcifront/xenbus.c	Tue Mar 28 08:54:58 2006 -0700
    51.3 @@ -50,6 +50,8 @@ static void free_pdev(struct pcifront_de
    51.4  {
    51.5  	dev_dbg(&pdev->xdev->dev, "freeing pdev @ 0x%p\n", pdev);
    51.6  
    51.7 +	pcifront_free_roots(pdev);
    51.8 +
    51.9  	if (pdev->evtchn != INVALID_EVTCHN)
   51.10  		xenbus_free_evtchn(pdev->xdev, pdev->evtchn);
   51.11  
    52.1 --- a/linux-2.6-xen-sparse/drivers/xen/util.c	Mon Mar 27 15:36:47 2006 -0700
    52.2 +++ b/linux-2.6-xen-sparse/drivers/xen/util.c	Tue Mar 28 08:54:58 2006 -0700
    52.3 @@ -6,9 +6,9 @@
    52.4  #include <asm/uaccess.h>
    52.5  #include <xen/driver_util.h>
    52.6  
    52.7 -static int f(pte_t *pte, struct page *pte_page, unsigned long addr, void *data)
    52.8 +static int f(pte_t *pte, struct page *pmd_page, unsigned long addr, void *data)
    52.9  {
   52.10 -	/* generic_page_range() does all the hard work. */
   52.11 +	/* apply_to_page_range() does all the hard work. */
   52.12  	return 0;
   52.13  }
   52.14  
   52.15 @@ -24,8 +24,8 @@ struct vm_struct *alloc_vm_area(unsigned
   52.16  	 * This ensures that page tables are constructed for this region
   52.17  	 * of kernel virtual address space and mapped into init_mm.
   52.18  	 */
   52.19 -	if (generic_page_range(&init_mm, (unsigned long)area->addr,
   52.20 -			       area->size, f, NULL)) {
   52.21 +	if (apply_to_page_range(&init_mm, (unsigned long)area->addr,
   52.22 +				area->size, f, NULL)) {
   52.23  		free_vm_area(area);
   52.24  		return NULL;
   52.25  	}
    53.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c	Mon Mar 27 15:36:47 2006 -0700
    53.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c	Tue Mar 28 08:54:58 2006 -0700
    53.3 @@ -1039,8 +1039,7 @@ static int __init xenbus_probe_init(void
    53.4  		xsd_port_intf = create_xen_proc_entry("xsd_port", 0400);
    53.5  		if (xsd_port_intf)
    53.6  			xsd_port_intf->read_proc = xsd_port_read;
    53.7 -	}
    53.8 -	else
    53.9 +	} else
   53.10  		xenstored_ready = 1;
   53.11  
   53.12  	/* Initialize the interface to xenstore. */
    54.1 --- a/linux-2.6-xen-sparse/include/asm-i386/mach-xen/asm/processor.h	Mon Mar 27 15:36:47 2006 -0700
    54.2 +++ b/linux-2.6-xen-sparse/include/asm-i386/mach-xen/asm/processor.h	Tue Mar 28 08:54:58 2006 -0700
    54.3 @@ -146,7 +146,7 @@ static inline void detect_ht(struct cpui
    54.4   */
    54.5  static inline void cpuid(unsigned int op, unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx)
    54.6  {
    54.7 -	__asm__("cpuid"
    54.8 +	__asm__(XEN_CPUID
    54.9  		: "=a" (*eax),
   54.10  		  "=b" (*ebx),
   54.11  		  "=c" (*ecx),
   54.12 @@ -158,7 +158,7 @@ static inline void cpuid(unsigned int op
   54.13  static inline void cpuid_count(int op, int count, int *eax, int *ebx, int *ecx,
   54.14  	       	int *edx)
   54.15  {
   54.16 -	__asm__("cpuid"
   54.17 +	__asm__(XEN_CPUID
   54.18  		: "=a" (*eax),
   54.19  		  "=b" (*ebx),
   54.20  		  "=c" (*ecx),
   54.21 @@ -173,7 +173,7 @@ static inline unsigned int cpuid_eax(uns
   54.22  {
   54.23  	unsigned int eax;
   54.24  
   54.25 -	__asm__("cpuid"
   54.26 +	__asm__(XEN_CPUID
   54.27  		: "=a" (eax)
   54.28  		: "0" (op)
   54.29  		: "bx", "cx", "dx");
   54.30 @@ -183,7 +183,7 @@ static inline unsigned int cpuid_ebx(uns
   54.31  {
   54.32  	unsigned int eax, ebx;
   54.33  
   54.34 -	__asm__("cpuid"
   54.35 +	__asm__(XEN_CPUID
   54.36  		: "=a" (eax), "=b" (ebx)
   54.37  		: "0" (op)
   54.38  		: "cx", "dx" );
   54.39 @@ -193,7 +193,7 @@ static inline unsigned int cpuid_ecx(uns
   54.40  {
   54.41  	unsigned int eax, ecx;
   54.42  
   54.43 -	__asm__("cpuid"
   54.44 +	__asm__(XEN_CPUID
   54.45  		: "=a" (eax), "=c" (ecx)
   54.46  		: "0" (op)
   54.47  		: "bx", "dx" );
   54.48 @@ -203,7 +203,7 @@ static inline unsigned int cpuid_edx(uns
   54.49  {
   54.50  	unsigned int eax, edx;
   54.51  
   54.52 -	__asm__("cpuid"
   54.53 +	__asm__(XEN_CPUID
   54.54  		: "=a" (eax), "=d" (edx)
   54.55  		: "0" (op)
   54.56  		: "bx", "cx");
   54.57 @@ -237,20 +237,11 @@ extern unsigned long mmu_cr4_features;
   54.58  
   54.59  static inline void set_in_cr4 (unsigned long mask)
   54.60  {
   54.61 +	unsigned cr4;
   54.62  	mmu_cr4_features |= mask;
   54.63 -	switch (mask) {
   54.64 -	case X86_CR4_OSFXSR:
   54.65 -	case X86_CR4_OSXMMEXCPT:
   54.66 -		break;
   54.67 -	default:
   54.68 -		do {
   54.69 -			const char *msg = "Xen unsupported cr4 update\n";
   54.70 -			(void)HYPERVISOR_console_io(
   54.71 -				CONSOLEIO_write, __builtin_strlen(msg),
   54.72 -				(char *)msg);
   54.73 -			BUG();
   54.74 -		} while (0);
   54.75 -	}
   54.76 +	cr4 = read_cr4();
   54.77 +	cr4 |= mask;
   54.78 +	write_cr4(cr4);
   54.79  }
   54.80  
   54.81  static inline void clear_in_cr4 (unsigned long mask)
    55.1 --- a/linux-2.6-xen-sparse/include/asm-i386/mach-xen/setup_arch_post.h	Mon Mar 27 15:36:47 2006 -0700
    55.2 +++ b/linux-2.6-xen-sparse/include/asm-i386/mach-xen/setup_arch_post.h	Tue Mar 28 08:54:58 2006 -0700
    55.3 @@ -16,18 +16,6 @@ static char * __init machine_specific_me
    55.4  	return "Xen";
    55.5  }
    55.6  
    55.7 -void __devinit machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c)
    55.8 -{
    55.9 -	clear_bit(X86_FEATURE_VME, c->x86_capability);
   55.10 -	clear_bit(X86_FEATURE_DE, c->x86_capability);
   55.11 -	clear_bit(X86_FEATURE_PSE, c->x86_capability);
   55.12 -	clear_bit(X86_FEATURE_PGE, c->x86_capability);
   55.13 -	clear_bit(X86_FEATURE_SEP, c->x86_capability);
   55.14 -	if (!(xen_start_info->flags & SIF_PRIVILEGED))
   55.15 -		clear_bit(X86_FEATURE_MTRR, c->x86_capability);
   55.16 -	c->hlt_works_ok = 0;
   55.17 -}
   55.18 -
   55.19  extern void hypervisor_callback(void);
   55.20  extern void failsafe_callback(void);
   55.21  extern void nmi(void);
   55.22 @@ -51,8 +39,6 @@ static void __init machine_specific_arch
   55.23  	cb.handler_address = (unsigned long)&nmi;
   55.24  	HYPERVISOR_nmi_op(XENNMI_register_callback, &cb);
   55.25  
   55.26 -	machine_specific_modify_cpu_capabilities(&boot_cpu_data);
   55.27 -
   55.28  	if (HYPERVISOR_xen_version(XENVER_platform_parameters,
   55.29  				   &pp) == 0)
   55.30  		set_fixaddr_top(pp.virt_start - PAGE_SIZE);
    56.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    56.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/msr.h	Tue Mar 28 08:54:58 2006 -0700
    56.3 @@ -0,0 +1,399 @@
    56.4 +#ifndef X86_64_MSR_H
    56.5 +#define X86_64_MSR_H 1
    56.6 +
    56.7 +#ifndef __ASSEMBLY__
    56.8 +/*
    56.9 + * Access to machine-specific registers (available on 586 and better only)
   56.10 + * Note: the rd* operations modify the parameters directly (without using
   56.11 + * pointer indirection), this allows gcc to optimize better
   56.12 + */
   56.13 +
   56.14 +#define rdmsr(msr,val1,val2) \
   56.15 +       __asm__ __volatile__("rdmsr" \
   56.16 +			    : "=a" (val1), "=d" (val2) \
   56.17 +			    : "c" (msr))
   56.18 +
   56.19 +
   56.20 +#define rdmsrl(msr,val) do { unsigned long a__,b__; \
   56.21 +       __asm__ __volatile__("rdmsr" \
   56.22 +			    : "=a" (a__), "=d" (b__) \
   56.23 +			    : "c" (msr)); \
   56.24 +       val = a__ | (b__<<32); \
   56.25 +} while(0)
   56.26 +
   56.27 +#define wrmsr(msr,val1,val2) \
   56.28 +     __asm__ __volatile__("wrmsr" \
   56.29 +			  : /* no outputs */ \
   56.30 +			  : "c" (msr), "a" (val1), "d" (val2))
   56.31 +
   56.32 +#define wrmsrl(msr,val) wrmsr(msr,(__u32)((__u64)(val)),((__u64)(val))>>32) 
   56.33 +
   56.34 +/* wrmsr with exception handling */
   56.35 +#define wrmsr_safe(msr,a,b) ({ int ret__;			\
   56.36 +	asm volatile("2: wrmsr ; xorl %0,%0\n"			\
   56.37 +		     "1:\n\t"					\
   56.38 +		     ".section .fixup,\"ax\"\n\t"		\
   56.39 +		     "3:  movl %4,%0 ; jmp 1b\n\t"		\
   56.40 +		     ".previous\n\t"				\
   56.41 + 		     ".section __ex_table,\"a\"\n"		\
   56.42 +		     "   .align 8\n\t"				\
   56.43 +		     "   .quad 	2b,3b\n\t"			\
   56.44 +		     ".previous"				\
   56.45 +		     : "=a" (ret__)				\
   56.46 +		     : "c" (msr), "0" (a), "d" (b), "i" (-EFAULT)); \
   56.47 +	ret__; })
   56.48 +
   56.49 +#define checking_wrmsrl(msr,val) wrmsr_safe(msr,(u32)(val),(u32)((val)>>32))
   56.50 +
   56.51 +#define rdmsr_safe(msr,a,b) \
   56.52 +	({ int ret__;						\
   56.53 +	  asm volatile ("1:       rdmsr\n"			\
   56.54 +                      "2:\n"					\
   56.55 +                      ".section .fixup,\"ax\"\n"		\
   56.56 +                      "3:       movl %4,%0\n"			\
   56.57 +                      " jmp 2b\n"				\
   56.58 +                      ".previous\n"				\
   56.59 +                      ".section __ex_table,\"a\"\n"		\
   56.60 +                      " .align 8\n"				\
   56.61 +                      " .quad 1b,3b\n"				\
   56.62 +                      ".previous":"=&bDS" (ret__), "=a"(*(a)), "=d"(*(b))\
   56.63 +                      :"c"(msr), "i"(-EIO), "0"(0));		\
   56.64 +	  ret__; })		
   56.65 +
   56.66 +#define rdtsc(low,high) \
   56.67 +     __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
   56.68 +
   56.69 +#define rdtscl(low) \
   56.70 +     __asm__ __volatile__ ("rdtsc" : "=a" (low) : : "edx")
   56.71 +
   56.72 +#define rdtscll(val) do { \
   56.73 +     unsigned int __a,__d; \
   56.74 +     asm volatile("rdtsc" : "=a" (__a), "=d" (__d)); \
   56.75 +     (val) = ((unsigned long)__a) | (((unsigned long)__d)<<32); \
   56.76 +} while(0)
   56.77 +
   56.78 +#define write_tsc(val1,val2) wrmsr(0x10, val1, val2)
   56.79 +
   56.80 +#define rdpmc(counter,low,high) \
   56.81 +     __asm__ __volatile__("rdpmc" \
   56.82 +			  : "=a" (low), "=d" (high) \
   56.83 +			  : "c" (counter))
   56.84 +
   56.85 +static inline void cpuid(int op, unsigned int *eax, unsigned int *ebx,
   56.86 +			 unsigned int *ecx, unsigned int *edx)
   56.87 +{
   56.88 +	__asm__(XEN_CPUID
   56.89 +		: "=a" (*eax),
   56.90 +		  "=b" (*ebx),
   56.91 +		  "=c" (*ecx),
   56.92 +		  "=d" (*edx)
   56.93 +		: "0" (op));
   56.94 +}
   56.95 +
   56.96 +/* Some CPUID calls want 'count' to be placed in ecx */
   56.97 +static inline void cpuid_count(int op, int count, int *eax, int *ebx, int *ecx,
   56.98 +	       	int *edx)
   56.99 +{
  56.100 +	__asm__(XEN_CPUID
  56.101 +		: "=a" (*eax),
  56.102 +		  "=b" (*ebx),
  56.103 +		  "=c" (*ecx),
  56.104 +		  "=d" (*edx)
  56.105 +		: "0" (op), "c" (count));
  56.106 +}
  56.107 +
  56.108 +/*
  56.109 + * CPUID functions returning a single datum
  56.110 + */
  56.111 +static inline unsigned int cpuid_eax(unsigned int op)
  56.112 +{
  56.113 +	unsigned int eax;
  56.114 +
  56.115 +	__asm__(XEN_CPUID
  56.116 +		: "=a" (eax)
  56.117 +		: "0" (op)
  56.118 +		: "bx", "cx", "dx");
  56.119 +	return eax;
  56.120 +}
  56.121 +static inline unsigned int cpuid_ebx(unsigned int op)
  56.122 +{
  56.123 +	unsigned int eax, ebx;
  56.124 +
  56.125 +	__asm__(XEN_CPUID
  56.126 +		: "=a" (eax), "=b" (ebx)
  56.127 +		: "0" (op)
  56.128 +		: "cx", "dx" );
  56.129 +	return ebx;
  56.130 +}
  56.131 +static inline unsigned int cpuid_ecx(unsigned int op)
  56.132 +{
  56.133 +	unsigned int eax, ecx;
  56.134 +
  56.135 +	__asm__(XEN_CPUID
  56.136 +		: "=a" (eax), "=c" (ecx)
  56.137 +		: "0" (op)
  56.138 +		: "bx", "dx" );
  56.139 +	return ecx;
  56.140 +}
  56.141 +static inline unsigned int cpuid_edx(unsigned int op)
  56.142 +{
  56.143 +	unsigned int eax, edx;
  56.144 +
  56.145 +	__asm__(XEN_CPUID
  56.146 +		: "=a" (eax), "=d" (edx)
  56.147 +		: "0" (op)
  56.148 +		: "bx", "cx");
  56.149 +	return edx;
  56.150 +}
  56.151 +
  56.152 +#define MSR_IA32_UCODE_WRITE		0x79
  56.153 +#define MSR_IA32_UCODE_REV		0x8b
  56.154 +
  56.155 +
  56.156 +#endif
  56.157 +
  56.158 +/* AMD/K8 specific MSRs */ 
  56.159 +#define MSR_EFER 0xc0000080		/* extended feature register */
  56.160 +#define MSR_STAR 0xc0000081		/* legacy mode SYSCALL target */
  56.161 +#define MSR_LSTAR 0xc0000082 		/* long mode SYSCALL target */
  56.162 +#define MSR_CSTAR 0xc0000083		/* compatibility mode SYSCALL target */
  56.163 +#define MSR_SYSCALL_MASK 0xc0000084	/* EFLAGS mask for syscall */
  56.164 +#define MSR_FS_BASE 0xc0000100		/* 64bit GS base */
  56.165 +#define MSR_GS_BASE 0xc0000101		/* 64bit FS base */
  56.166 +#define MSR_KERNEL_GS_BASE  0xc0000102	/* SwapGS GS shadow (or USER_GS from kernel) */ 
  56.167 +/* EFER bits: */ 
  56.168 +#define _EFER_SCE 0  /* SYSCALL/SYSRET */
  56.169 +#define _EFER_LME 8  /* Long mode enable */
  56.170 +#define _EFER_LMA 10 /* Long mode active (read-only) */
  56.171 +#define _EFER_NX 11  /* No execute enable */
  56.172 +
  56.173 +#define EFER_SCE (1<<_EFER_SCE)
  56.174 +#define EFER_LME (1<<_EFER_LME)
  56.175 +#define EFER_LMA (1<<_EFER_LMA)
  56.176 +#define EFER_NX (1<<_EFER_NX)
  56.177 +
  56.178 +/* Intel MSRs. Some also available on other CPUs */
  56.179 +#define MSR_IA32_TSC		0x10
  56.180 +#define MSR_IA32_PLATFORM_ID	0x17
  56.181 +
  56.182 +#define MSR_IA32_PERFCTR0      0xc1
  56.183 +#define MSR_IA32_PERFCTR1      0xc2
  56.184 +
  56.185 +#define MSR_MTRRcap		0x0fe
  56.186 +#define MSR_IA32_BBL_CR_CTL        0x119
  56.187 +
  56.188 +#define MSR_IA32_SYSENTER_CS	0x174
  56.189 +#define MSR_IA32_SYSENTER_ESP	0x175
  56.190 +#define MSR_IA32_SYSENTER_EIP	0x176
  56.191 +
  56.192 +#define MSR_IA32_MCG_CAP       0x179
  56.193 +#define MSR_IA32_MCG_STATUS        0x17a
  56.194 +#define MSR_IA32_MCG_CTL       0x17b
  56.195 +
  56.196 +#define MSR_IA32_EVNTSEL0      0x186
  56.197 +#define MSR_IA32_EVNTSEL1      0x187
  56.198 +
  56.199 +#define MSR_IA32_DEBUGCTLMSR       0x1d9
  56.200 +#define MSR_IA32_LASTBRANCHFROMIP  0x1db
  56.201 +#define MSR_IA32_LASTBRANCHTOIP        0x1dc
  56.202 +#define MSR_IA32_LASTINTFROMIP     0x1dd
  56.203 +#define MSR_IA32_LASTINTTOIP       0x1de
  56.204 +
  56.205 +#define MSR_MTRRfix64K_00000	0x250
  56.206 +#define MSR_MTRRfix16K_80000	0x258
  56.207 +#define MSR_MTRRfix16K_A0000	0x259
  56.208 +#define MSR_MTRRfix4K_C0000	0x268
  56.209 +#define MSR_MTRRfix4K_C8000	0x269
  56.210 +#define MSR_MTRRfix4K_D0000	0x26a
  56.211 +#define MSR_MTRRfix4K_D8000	0x26b
  56.212 +#define MSR_MTRRfix4K_E0000	0x26c
  56.213 +#define MSR_MTRRfix4K_E8000	0x26d
  56.214 +#define MSR_MTRRfix4K_F0000	0x26e
  56.215 +#define MSR_MTRRfix4K_F8000	0x26f
  56.216 +#define MSR_MTRRdefType		0x2ff
  56.217 +
  56.218 +#define MSR_IA32_MC0_CTL       0x400
  56.219 +#define MSR_IA32_MC0_STATUS        0x401
  56.220 +#define MSR_IA32_MC0_ADDR      0x402
  56.221 +#define MSR_IA32_MC0_MISC      0x403
  56.222 +
  56.223 +#define MSR_P6_PERFCTR0			0xc1
  56.224 +#define MSR_P6_PERFCTR1			0xc2
  56.225 +#define MSR_P6_EVNTSEL0			0x186
  56.226 +#define MSR_P6_EVNTSEL1			0x187
  56.227 +
  56.228 +/* K7/K8 MSRs. Not complete. See the architecture manual for a more complete list. */
  56.229 +#define MSR_K7_EVNTSEL0            0xC0010000
  56.230 +#define MSR_K7_PERFCTR0            0xC0010004
  56.231 +#define MSR_K7_EVNTSEL1            0xC0010001
  56.232 +#define MSR_K7_PERFCTR1            0xC0010005
  56.233 +#define MSR_K7_EVNTSEL2            0xC0010002
  56.234 +#define MSR_K7_PERFCTR2            0xC0010006
  56.235 +#define MSR_K7_EVNTSEL3            0xC0010003
  56.236 +#define MSR_K7_PERFCTR3            0xC0010007
  56.237 +#define MSR_K8_TOP_MEM1		   0xC001001A
  56.238 +#define MSR_K8_TOP_MEM2		   0xC001001D
  56.239 +#define MSR_K8_SYSCFG		   0xC0010010
  56.240 +#define MSR_K8_HWCR		   0xC0010015
  56.241 +
  56.242 +/* K6 MSRs */
  56.243 +#define MSR_K6_EFER			0xC0000080
  56.244 +#define MSR_K6_STAR			0xC0000081
  56.245 +#define MSR_K6_WHCR			0xC0000082
  56.246 +#define MSR_K6_UWCCR			0xC0000085
  56.247 +#define MSR_K6_PSOR			0xC0000087
  56.248 +#define MSR_K6_PFIR			0xC0000088
  56.249 +
  56.250 +/* Centaur-Hauls/IDT defined MSRs. */
  56.251 +#define MSR_IDT_FCR1			0x107
  56.252 +#define MSR_IDT_FCR2			0x108
  56.253 +#define MSR_IDT_FCR3			0x109
  56.254 +#define MSR_IDT_FCR4			0x10a
  56.255 +
  56.256 +#define MSR_IDT_MCR0			0x110
  56.257 +#define MSR_IDT_MCR1			0x111
  56.258 +#define MSR_IDT_MCR2			0x112
  56.259 +#define MSR_IDT_MCR3			0x113
  56.260 +#define MSR_IDT_MCR4			0x114
  56.261 +#define MSR_IDT_MCR5			0x115
  56.262 +#define MSR_IDT_MCR6			0x116
  56.263 +#define MSR_IDT_MCR7			0x117
  56.264 +#define MSR_IDT_MCR_CTRL		0x120
  56.265 +
  56.266 +/* VIA Cyrix defined MSRs*/
  56.267 +#define MSR_VIA_FCR			0x1107
  56.268 +#define MSR_VIA_LONGHAUL		0x110a
  56.269 +#define MSR_VIA_RNG			0x110b
  56.270 +#define MSR_VIA_BCR2			0x1147
  56.271 +
  56.272 +/* Intel defined MSRs. */
  56.273 +#define MSR_IA32_P5_MC_ADDR		0
  56.274 +#define MSR_IA32_P5_MC_TYPE		1
  56.275 +#define MSR_IA32_PLATFORM_ID		0x17
  56.276 +#define MSR_IA32_EBL_CR_POWERON		0x2a
  56.277 +
  56.278 +#define MSR_IA32_APICBASE               0x1b
  56.279 +#define MSR_IA32_APICBASE_BSP           (1<<8)
  56.280 +#define MSR_IA32_APICBASE_ENABLE        (1<<11)
  56.281 +#define MSR_IA32_APICBASE_BASE          (0xfffff<<12)
  56.282 +
  56.283 +/* P4/Xeon+ specific */
  56.284 +#define MSR_IA32_MCG_EAX		0x180
  56.285 +#define MSR_IA32_MCG_EBX		0x181
  56.286 +#define MSR_IA32_MCG_ECX		0x182
  56.287 +#define MSR_IA32_MCG_EDX		0x183
  56.288 +#define MSR_IA32_MCG_ESI		0x184
  56.289 +#define MSR_IA32_MCG_EDI		0x185
  56.290 +#define MSR_IA32_MCG_EBP		0x186
  56.291 +#define MSR_IA32_MCG_ESP		0x187
  56.292 +#define MSR_IA32_MCG_EFLAGS		0x188
  56.293 +#define MSR_IA32_MCG_EIP		0x189
  56.294 +#define MSR_IA32_MCG_RESERVED		0x18A
  56.295 +
  56.296 +#define MSR_P6_EVNTSEL0			0x186
  56.297 +#define MSR_P6_EVNTSEL1			0x187
  56.298 +
  56.299 +#define MSR_IA32_PERF_STATUS		0x198
  56.300 +#define MSR_IA32_PERF_CTL		0x199
  56.301 +
  56.302 +#define MSR_IA32_THERM_CONTROL		0x19a
  56.303 +#define MSR_IA32_THERM_INTERRUPT	0x19b
  56.304 +#define MSR_IA32_THERM_STATUS		0x19c
  56.305 +#define MSR_IA32_MISC_ENABLE		0x1a0
  56.306 +
  56.307 +#define MSR_IA32_DEBUGCTLMSR		0x1d9
  56.308 +#define MSR_IA32_LASTBRANCHFROMIP	0x1db
  56.309 +#define MSR_IA32_LASTBRANCHTOIP		0x1dc
  56.310 +#define MSR_IA32_LASTINTFROMIP		0x1dd
  56.311 +#define MSR_IA32_LASTINTTOIP		0x1de
  56.312 +
  56.313 +#define MSR_IA32_MC0_CTL		0x400
  56.314 +#define MSR_IA32_MC0_STATUS		0x401
  56.315 +#define MSR_IA32_MC0_ADDR		0x402
  56.316 +#define MSR_IA32_MC0_MISC		0x403
  56.317 +
  56.318 +/* Pentium IV performance counter MSRs */
  56.319 +#define MSR_P4_BPU_PERFCTR0 		0x300
  56.320 +#define MSR_P4_BPU_PERFCTR1 		0x301
  56.321 +#define MSR_P4_BPU_PERFCTR2 		0x302
  56.322 +#define MSR_P4_BPU_PERFCTR3 		0x303
  56.323 +#define MSR_P4_MS_PERFCTR0 		0x304
  56.324 +#define MSR_P4_MS_PERFCTR1 		0x305
  56.325 +#define MSR_P4_MS_PERFCTR2 		0x306
  56.326 +#define MSR_P4_MS_PERFCTR3 		0x307
  56.327 +#define MSR_P4_FLAME_PERFCTR0 		0x308
  56.328 +#define MSR_P4_FLAME_PERFCTR1 		0x309
  56.329 +#define MSR_P4_FLAME_PERFCTR2 		0x30a
  56.330 +#define MSR_P4_FLAME_PERFCTR3 		0x30b
  56.331 +#define MSR_P4_IQ_PERFCTR0 		0x30c
  56.332 +#define MSR_P4_IQ_PERFCTR1 		0x30d
  56.333 +#define MSR_P4_IQ_PERFCTR2 		0x30e
  56.334 +#define MSR_P4_IQ_PERFCTR3 		0x30f
  56.335 +#define MSR_P4_IQ_PERFCTR4 		0x310
  56.336 +#define MSR_P4_IQ_PERFCTR5 		0x311
  56.337 +#define MSR_P4_BPU_CCCR0 		0x360
  56.338 +#define MSR_P4_BPU_CCCR1 		0x361
  56.339 +#define MSR_P4_BPU_CCCR2 		0x362
  56.340 +#define MSR_P4_BPU_CCCR3 		0x363
  56.341 +#define MSR_P4_MS_CCCR0 		0x364
  56.342 +#define MSR_P4_MS_CCCR1 		0x365
  56.343 +#define MSR_P4_MS_CCCR2 		0x366
  56.344 +#define MSR_P4_MS_CCCR3 		0x367
  56.345 +#define MSR_P4_FLAME_CCCR0 		0x368
  56.346 +#define MSR_P4_FLAME_CCCR1 		0x369
  56.347 +#define MSR_P4_FLAME_CCCR2 		0x36a
  56.348 +#define MSR_P4_FLAME_CCCR3 		0x36b
  56.349 +#define MSR_P4_IQ_CCCR0 		0x36c
  56.350 +#define MSR_P4_IQ_CCCR1 		0x36d
  56.351 +#define MSR_P4_IQ_CCCR2 		0x36e
  56.352 +#define MSR_P4_IQ_CCCR3 		0x36f
  56.353 +#define MSR_P4_IQ_CCCR4 		0x370
  56.354 +#define MSR_P4_IQ_CCCR5 		0x371
  56.355 +#define MSR_P4_ALF_ESCR0 		0x3ca
  56.356 +#define MSR_P4_ALF_ESCR1 		0x3cb
  56.357 +#define MSR_P4_BPU_ESCR0 		0x3b2
  56.358 +#define MSR_P4_BPU_ESCR1 		0x3b3
  56.359 +#define MSR_P4_BSU_ESCR0 		0x3a0
  56.360 +#define MSR_P4_BSU_ESCR1 		0x3a1
  56.361 +#define MSR_P4_CRU_ESCR0 		0x3b8
  56.362 +#define MSR_P4_CRU_ESCR1 		0x3b9
  56.363 +#define MSR_P4_CRU_ESCR2 		0x3cc
  56.364 +#define MSR_P4_CRU_ESCR3 		0x3cd
  56.365 +#define MSR_P4_CRU_ESCR4 		0x3e0
  56.366 +#define MSR_P4_CRU_ESCR5 		0x3e1
  56.367 +#define MSR_P4_DAC_ESCR0 		0x3a8
  56.368 +#define MSR_P4_DAC_ESCR1 		0x3a9
  56.369 +#define MSR_P4_FIRM_ESCR0 		0x3a4
  56.370 +#define MSR_P4_FIRM_ESCR1 		0x3a5
  56.371 +#define MSR_P4_FLAME_ESCR0 		0x3a6
  56.372 +#define MSR_P4_FLAME_ESCR1 		0x3a7
  56.373 +#define MSR_P4_FSB_ESCR0 		0x3a2
  56.374 +#define MSR_P4_FSB_ESCR1 		0x3a3
  56.375 +#define MSR_P4_IQ_ESCR0 		0x3ba
  56.376 +#define MSR_P4_IQ_ESCR1 		0x3bb
  56.377 +#define MSR_P4_IS_ESCR0 		0x3b4
  56.378 +#define MSR_P4_IS_ESCR1 		0x3b5
  56.379 +#define MSR_P4_ITLB_ESCR0 		0x3b6
  56.380 +#define MSR_P4_ITLB_ESCR1 		0x3b7
  56.381 +#define MSR_P4_IX_ESCR0 		0x3c8
  56.382 +#define MSR_P4_IX_ESCR1 		0x3c9
  56.383 +#define MSR_P4_MOB_ESCR0 		0x3aa
  56.384 +#define MSR_P4_MOB_ESCR1 		0x3ab
  56.385 +#define MSR_P4_MS_ESCR0 		0x3c0
  56.386 +#define MSR_P4_MS_ESCR1 		0x3c1
  56.387 +#define MSR_P4_PMH_ESCR0 		0x3ac
  56.388 +#define MSR_P4_PMH_ESCR1 		0x3ad
  56.389 +#define MSR_P4_RAT_ESCR0 		0x3bc
  56.390 +#define MSR_P4_RAT_ESCR1 		0x3bd
  56.391 +#define MSR_P4_SAAT_ESCR0 		0x3ae
  56.392 +#define MSR_P4_SAAT_ESCR1 		0x3af
  56.393 +#define MSR_P4_SSU_ESCR0 		0x3be
  56.394 +#define MSR_P4_SSU_ESCR1 		0x3bf    /* guess: not defined in manual */
  56.395 +#define MSR_P4_TBPU_ESCR0 		0x3c2
  56.396 +#define MSR_P4_TBPU_ESCR1 		0x3c3
  56.397 +#define MSR_P4_TC_ESCR0 		0x3c4
  56.398 +#define MSR_P4_TC_ESCR1 		0x3c5
  56.399 +#define MSR_P4_U2L_ESCR0 		0x3b0
  56.400 +#define MSR_P4_U2L_ESCR1 		0x3b1
  56.401 +
  56.402 +#endif
    57.1 --- a/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/processor.h	Mon Mar 27 15:36:47 2006 -0700
    57.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/processor.h	Tue Mar 28 08:54:58 2006 -0700
    57.3 @@ -141,31 +141,21 @@ extern unsigned long mmu_cr4_features;
    57.4  static inline void set_in_cr4 (unsigned long mask)
    57.5  {
    57.6  	mmu_cr4_features |= mask;
    57.7 -	switch (mask) {
    57.8 -	case X86_CR4_OSFXSR:
    57.9 -	case X86_CR4_OSXMMEXCPT:
   57.10 -		break;
   57.11 -	default:
   57.12 -		do {
   57.13 -			const char *msg = "Xen unsupported cr4 update\n";
   57.14 -			(void)HYPERVISOR_console_io(
   57.15 -				CONSOLEIO_write, __builtin_strlen(msg),
   57.16 -				(char *)msg);
   57.17 -			BUG();
   57.18 -		} while (0);
   57.19 -	}
   57.20 +	__asm__("movq %%cr4,%%rax\n\t"
   57.21 +		"orq %0,%%rax\n\t"
   57.22 +		"movq %%rax,%%cr4\n"
   57.23 +		: : "irg" (mask)
   57.24 +		:"ax");
   57.25  }
   57.26  
   57.27  static inline void clear_in_cr4 (unsigned long mask)
   57.28  {
   57.29 -#ifndef CONFIG_XEN
   57.30  	mmu_cr4_features &= ~mask;
   57.31  	__asm__("movq %%cr4,%%rax\n\t"
   57.32  		"andq %0,%%rax\n\t"
   57.33  		"movq %%rax,%%cr4\n"
   57.34  		: : "irg" (~mask)
   57.35  		:"ax");
   57.36 -#endif
   57.37  }
   57.38  
   57.39  
    58.1 --- a/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/setup_arch_post.h	Mon Mar 27 15:36:47 2006 -0700
    58.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/setup_arch_post.h	Tue Mar 28 08:54:58 2006 -0700
    58.3 @@ -6,17 +6,6 @@
    58.4   *	use of all of the static functions.
    58.5   **/
    58.6  
    58.7 -void __cpuinit machine_specific_modify_cpu_capabilities(struct cpuinfo_x86 *c)
    58.8 -{
    58.9 -	clear_bit(X86_FEATURE_VME, c->x86_capability);
   58.10 -	clear_bit(X86_FEATURE_DE, c->x86_capability);
   58.11 -	clear_bit(X86_FEATURE_PSE, c->x86_capability);
   58.12 -	clear_bit(X86_FEATURE_PGE, c->x86_capability);
   58.13 -	clear_bit(X86_FEATURE_SEP, c->x86_capability);
   58.14 -	if (!(xen_start_info->flags & SIF_PRIVILEGED))
   58.15 -		clear_bit(X86_FEATURE_MTRR, c->x86_capability);
   58.16 -}
   58.17 -
   58.18  extern void hypervisor_callback(void);
   58.19  extern void failsafe_callback(void);
   58.20  extern void nmi(void);
   58.21 @@ -36,6 +25,4 @@ static void __init machine_specific_arch
   58.22  	cb.handler_address = (unsigned long)&nmi;
   58.23  	HYPERVISOR_nmi_op(XENNMI_register_callback, &cb);
   58.24  #endif
   58.25 -
   58.26 -	machine_specific_modify_cpu_capabilities(&boot_cpu_data);
   58.27  }
    59.1 --- a/linux-2.6-xen-sparse/include/linux/mm.h	Mon Mar 27 15:36:47 2006 -0700
    59.2 +++ b/linux-2.6-xen-sparse/include/linux/mm.h	Tue Mar 28 08:54:58 2006 -0700
    59.3 @@ -1020,10 +1020,10 @@ struct page *follow_page(struct vm_area_
    59.4  #define FOLL_ANON	0x08	/* give ZERO_PAGE if no pgtable */
    59.5  
    59.6  #ifdef CONFIG_XEN
    59.7 -typedef int (*pte_fn_t)(pte_t *pte, struct page *pte_page, unsigned long addr,
    59.8 -                        void *data);
    59.9 -extern int generic_page_range(struct mm_struct *mm, unsigned long address,
   59.10 -                              unsigned long size, pte_fn_t fn, void *data);
   59.11 +typedef int (*pte_fn_t)(pte_t *pte, struct page *pmd_page, unsigned long addr,
   59.12 +			void *data);
   59.13 +extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,
   59.14 +			       unsigned long size, pte_fn_t fn, void *data);
   59.15  #endif
   59.16  
   59.17  #ifdef CONFIG_PROC_FS
    60.1 --- a/linux-2.6-xen-sparse/mm/memory.c	Mon Mar 27 15:36:47 2006 -0700
    60.2 +++ b/linux-2.6-xen-sparse/mm/memory.c	Tue Mar 28 08:54:58 2006 -0700
    60.3 @@ -1378,36 +1378,39 @@ int remap_pfn_range(struct vm_area_struc
    60.4  EXPORT_SYMBOL(remap_pfn_range);
    60.5  
    60.6  #ifdef CONFIG_XEN
    60.7 -static inline int generic_pte_range(struct mm_struct *mm, pmd_t *pmd,
    60.8 -				    unsigned long addr, unsigned long end,
    60.9 -				    pte_fn_t fn, void *data)
   60.10 +static inline int apply_to_pte_range(struct mm_struct *mm, pmd_t *pmd,
   60.11 +				     unsigned long addr, unsigned long end,
   60.12 +				     pte_fn_t fn, void *data)
   60.13  {
   60.14  	pte_t *pte;
   60.15  	int err;
   60.16 -	struct page *pte_page;
   60.17 +	struct page *pmd_page;
   60.18 +	spinlock_t *ptl;
   60.19  
   60.20  	pte = (mm == &init_mm) ?
   60.21  		pte_alloc_kernel(pmd, addr) :
   60.22 -		pte_alloc_map(mm, pmd, addr);
   60.23 +		pte_alloc_map_lock(mm, pmd, addr, &ptl);
   60.24  	if (!pte)
   60.25  		return -ENOMEM;
   60.26  
   60.27 -	pte_page = pmd_page(*pmd);
   60.28 +	BUG_ON(pmd_huge(*pmd));
   60.29 +
   60.30 +	pmd_page = pmd_page(*pmd);
   60.31  
   60.32  	do {
   60.33 -		err = fn(pte, pte_page, addr, data);
   60.34 +		err = fn(pte, pmd_page, addr, data);
   60.35  		if (err)
   60.36  			break;
   60.37  	} while (pte++, addr += PAGE_SIZE, addr != end);
   60.38  
   60.39  	if (mm != &init_mm)
   60.40 -		pte_unmap(pte-1);
   60.41 +		pte_unmap_unlock(pte-1, ptl);
   60.42  	return err;
   60.43  }
   60.44  
   60.45 -static inline int generic_pmd_range(struct mm_struct *mm, pud_t *pud,
   60.46 -				    unsigned long addr, unsigned long end,
   60.47 -				    pte_fn_t fn, void *data)
   60.48 +static inline int apply_to_pmd_range(struct mm_struct *mm, pud_t *pud,
   60.49 +				     unsigned long addr, unsigned long end,
   60.50 +				     pte_fn_t fn, void *data)
   60.51  {
   60.52  	pmd_t *pmd;
   60.53  	unsigned long next;
   60.54 @@ -1418,16 +1421,16 @@ static inline int generic_pmd_range(stru
   60.55  		return -ENOMEM;
   60.56  	do {
   60.57  		next = pmd_addr_end(addr, end);
   60.58 -		err = generic_pte_range(mm, pmd, addr, next, fn, data);
   60.59 +		err = apply_to_pte_range(mm, pmd, addr, next, fn, data);
   60.60  		if (err)
   60.61  			break;
   60.62  	} while (pmd++, addr = next, addr != end);
   60.63  	return err;
   60.64  }
   60.65  
   60.66 -static inline int generic_pud_range(struct mm_struct *mm, pgd_t *pgd,
   60.67 -				    unsigned long addr, unsigned long end,
   60.68 -				    pte_fn_t fn, void *data)
   60.69 +static inline int apply_to_pud_range(struct mm_struct *mm, pgd_t *pgd,
   60.70 +				     unsigned long addr, unsigned long end,
   60.71 +				     pte_fn_t fn, void *data)
   60.72  {
   60.73  	pud_t *pud;
   60.74  	unsigned long next;
   60.75 @@ -1438,7 +1441,7 @@ static inline int generic_pud_range(stru
   60.76  		return -ENOMEM;
   60.77  	do {
   60.78  		next = pud_addr_end(addr, end);
   60.79 -		err = generic_pmd_range(mm, pud, addr, next, fn, data);
   60.80 +		err = apply_to_pmd_range(mm, pud, addr, next, fn, data);
   60.81  		if (err)
   60.82  			break;
   60.83  	} while (pud++, addr = next, addr != end);
   60.84 @@ -1449,8 +1452,8 @@ static inline int generic_pud_range(stru
   60.85   * Scan a region of virtual memory, filling in page tables as necessary
   60.86   * and calling a provided function on each leaf page table.
   60.87   */
   60.88 -int generic_page_range(struct mm_struct *mm, unsigned long addr,
   60.89 -		       unsigned long size, pte_fn_t fn, void *data)
   60.90 +int apply_to_page_range(struct mm_struct *mm, unsigned long addr,
   60.91 +			unsigned long size, pte_fn_t fn, void *data)
   60.92  {
   60.93  	pgd_t *pgd;
   60.94  	unsigned long next;
   60.95 @@ -1461,12 +1464,13 @@ int generic_page_range(struct mm_struct 
   60.96  	pgd = pgd_offset(mm, addr);
   60.97  	do {
   60.98  		next = pgd_addr_end(addr, end);
   60.99 -		err = generic_pud_range(mm, pgd, addr, next, fn, data);
  60.100 +		err = apply_to_pud_range(mm, pgd, addr, next, fn, data);
  60.101  		if (err)
  60.102  			break;
  60.103  	} while (pgd++, addr = next, addr != end);
  60.104  	return err;
  60.105  }
  60.106 +EXPORT_SYMBOL_GPL(apply_to_page_range);
  60.107  #endif
  60.108  
  60.109  /*
    61.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    61.2 +++ b/patches/linux-2.6.16/device_bind.patch	Tue Mar 28 08:54:58 2006 -0700
    61.3 @@ -0,0 +1,14 @@
    61.4 +--- linux-2.6.16/drivers/base/bus.c	2006-03-16 10:50:20.000000000 -0500
    61.5 ++++ linux-2.6.16/drivers/base/bus.c	2006-03-16 11:02:08.000000000 -0500
    61.6 +@@ -188,6 +188,11 @@ static ssize_t driver_bind(struct device
    61.7 + 		up(&dev->sem);
    61.8 + 		if (dev->parent)
    61.9 + 			up(&dev->parent->sem);
   61.10 ++
   61.11 ++		if (err > 0) 		/* success */
   61.12 ++			err = count;
   61.13 ++		else if (err == 0)	/* driver didn't accept device */
   61.14 ++			err = -ENODEV;
   61.15 + 	}
   61.16 + 	put_device(dev);
   61.17 + 	put_bus(bus);
    62.1 --- a/tools/Makefile	Mon Mar 27 15:36:47 2006 -0700
    62.2 +++ b/tools/Makefile	Tue Mar 28 08:54:58 2006 -0700
    62.3 @@ -37,6 +37,7 @@ install: check
    62.4  		$(MAKE) -C $$subdir $@; \
    62.5  	done
    62.6  	$(MAKE) ioemuinstall
    62.7 +	$(INSTALL_DIR) -p $(DESTDIR)/var/xen/dump
    62.8  
    62.9  clean: check_clean
   62.10  	@set -e; for subdir in $(SUBDIRS); do \
    63.1 --- a/tools/debugger/gdb/README	Mon Mar 27 15:36:47 2006 -0700
    63.2 +++ b/tools/debugger/gdb/README	Tue Mar 28 08:54:58 2006 -0700
    63.3 @@ -11,8 +11,8 @@ To build the GDB server:
    63.4      to your test machine.
    63.5  
    63.6  To build a debuggable guest kernel image:
    63.7 - 1. cd linux-2.6.12-xenU
    63.8 - 2. ARCH=xen make menuconfig
    63.9 + 1. cd linux-2.6.xx-xenU
   63.10 + 2. make menuconfig
   63.11   3. From within the configurator, enable the following options:
   63.12      # Kernel hacking -> Compile the kernel with debug info [*]
   63.13                       -> Compile the kernel with frame pointers
    64.1 --- a/tools/debugger/gdb/gdb-6.2.1-xen-sparse/gdb/gdbserver/configure.srv	Mon Mar 27 15:36:47 2006 -0700
    64.2 +++ b/tools/debugger/gdb/gdb-6.2.1-xen-sparse/gdb/gdbserver/configure.srv	Tue Mar 28 08:54:58 2006 -0700
    64.3 @@ -61,7 +61,7 @@ case "${target}" in
    64.4  			srv_linux_thread_db=yes
    64.5  			;;
    64.6    x86_64-*-linux*)	srv_regobj=reg-x86-64.o
    64.7 -			srv_tgtobj="linux-low.o linux-x86-64-low.o i387-fp.o"
    64.8 +			srv_tgtobj="linux-xen-low.o linux-x86-64-low.o i387-fp.o"
    64.9  			srv_linux_regsets=yes
   64.10  			;;
   64.11    xscale*-*-linux*)	srv_regobj=reg-arm.o
    65.1 --- a/tools/examples/xen-backend.agent	Mon Mar 27 15:36:47 2006 -0700
    65.2 +++ b/tools/examples/xen-backend.agent	Tue Mar 28 08:54:58 2006 -0700
    65.3 @@ -2,6 +2,10 @@
    65.4  
    65.5  PATH=/etc/xen/scripts:$PATH
    65.6  
    65.7 +. /etc/xen/scripts/locking.sh
    65.8 +
    65.9 +claim_lock xenbus_hotplug_global
   65.10 +
   65.11  case "$XENBUS_TYPE" in
   65.12    vbd)
   65.13      /etc/xen/scripts/block "$ACTION"
   65.14 @@ -25,3 +29,5 @@ case "$ACTION" in
   65.15    offline)
   65.16      ;;
   65.17  esac
   65.18 +
   65.19 +release_lock xenbus_hotplug_global
    66.1 --- a/tools/examples/xend-config.sxp	Mon Mar 27 15:36:47 2006 -0700
    66.2 +++ b/tools/examples/xend-config.sxp	Tue Mar 28 08:54:58 2006 -0700
    66.3 @@ -15,7 +15,9 @@
    66.4  #(loglevel DEBUG)
    66.5  
    66.6  #(xend-http-server no)
    66.7 -#(xend-unix-server yes)
    66.8 +#(xend-unix-server no)
    66.9 +#(xend-tcp-xmlrpc-server no)
   66.10 +#(xend-unix-xmlrpc-server yes)
   66.11  #(xend-relocation-server no)
   66.12  (xend-relocation-server yes)
   66.13  
    67.1 --- a/tools/ioemu/hw/pcnet.c	Mon Mar 27 15:36:47 2006 -0700
    67.2 +++ b/tools/ioemu/hw/pcnet.c	Tue Mar 28 08:54:58 2006 -0700
    67.3 @@ -45,21 +45,6 @@
    67.4  #define PCNET_PNPMMIO_SIZE      0x20
    67.5  
    67.6  
    67.7 -typedef struct PCNetState_st PCNetState;
    67.8 -
    67.9 -struct PCNetState_st {
   67.10 -    PCIDevice dev;
   67.11 -    NetDriverState *nd;
   67.12 -    int mmio_io_addr, rap, isr, lnkst;
   67.13 -    target_phys_addr_t rdra, tdra;
   67.14 -    uint8_t prom[16];
   67.15 -    uint16_t csr[128];
   67.16 -    uint16_t bcr[32];
   67.17 -    uint64_t timer;
   67.18 -    int xmit_pos, recv_pos;
   67.19 -    uint8_t buffer[4096];
   67.20 -};
   67.21 -
   67.22  #include "pcnet.h"
   67.23  
   67.24  static void pcnet_poll(PCNetState *s);
   67.25 @@ -217,6 +202,11 @@ static void pcnet_init(PCNetState *s)
   67.26      CSR_RCVRC(s) = CSR_RCVRL(s);
   67.27      CSR_XMTRC(s) = CSR_XMTRL(s);
   67.28  
   67.29 +    /* flush any cached receive descriptors */
   67.30 +    s->crmd.rmd1.own = 0;
   67.31 +    s->nrmd.rmd1.own = 0;
   67.32 +    s->nnrmd.rmd1.own = 0;
   67.33 +
   67.34  #ifdef PCNET_DEBUG
   67.35      printf("pcnet ss32=%d rdra=0x%08x[%d] tdra=0x%08x[%d]\n", 
   67.36          BCR_SSIZE32(s),
   67.37 @@ -239,6 +229,11 @@ static void pcnet_start(PCNetState *s)
   67.38      if (!CSR_DRX(s))
   67.39          s->csr[0] |= 0x0020;    /* set RXON */
   67.40  
   67.41 +    /* flush any cached receive descriptors */
   67.42 +    s->crmd.rmd1.own = 0;
   67.43 +    s->nrmd.rmd1.own = 0;
   67.44 +    s->nnrmd.rmd1.own = 0;
   67.45 +
   67.46      s->csr[0] &= ~0x0004;       /* clear STOP bit */
   67.47      s->csr[0] |= 0x0002;
   67.48  }
   67.49 @@ -260,29 +255,21 @@ static void pcnet_rdte_poll(PCNetState *
   67.50      s->csr[28] = s->csr[29] = 0;
   67.51      if (s->rdra) {
   67.52          int bad = 0;
   67.53 -#if 1
   67.54          target_phys_addr_t crda = pcnet_rdra_addr(s, CSR_RCVRC(s));
   67.55          target_phys_addr_t nrda = pcnet_rdra_addr(s, -1 + CSR_RCVRC(s));
   67.56          target_phys_addr_t nnrd = pcnet_rdra_addr(s, -2 + CSR_RCVRC(s));
   67.57 -#else
   67.58 -        target_phys_addr_t crda = s->rdra + 
   67.59 -            (CSR_RCVRL(s) - CSR_RCVRC(s)) *
   67.60 -            (BCR_SWSTYLE(s) ? 16 : 8 );
   67.61 -        int nrdc = CSR_RCVRC(s)<=1 ? CSR_RCVRL(s) : CSR_RCVRC(s)-1;
   67.62 -        target_phys_addr_t nrda = s->rdra + 
   67.63 -            (CSR_RCVRL(s) - nrdc) *
   67.64 -            (BCR_SWSTYLE(s) ? 16 : 8 );
   67.65 -        int nnrc = nrdc<=1 ? CSR_RCVRL(s) : nrdc-1;
   67.66 -        target_phys_addr_t nnrd = s->rdra + 
   67.67 -            (CSR_RCVRL(s) - nnrc) *
   67.68 -            (BCR_SWSTYLE(s) ? 16 : 8 );
   67.69 -#endif
   67.70  
   67.71 -        CHECK_RMD(PHYSADDR(s,crda), bad);
   67.72 +	if (!s->crmd.rmd1.own) {
   67.73 +	    CHECK_RMD(&(s->crmd),PHYSADDR(s,crda), bad);
   67.74 +	}
   67.75          if (!bad) {
   67.76 -            CHECK_RMD(PHYSADDR(s,nrda), bad);
   67.77 +	    if (s->crmd.rmd1.own && !s->nrmd.rmd1.own) {
   67.78 +		CHECK_RMD(&(s->nrmd),PHYSADDR(s,nrda), bad);
   67.79 +	    }
   67.80              if (bad || (nrda == crda)) nrda = 0;
   67.81 -            CHECK_RMD(PHYSADDR(s,nnrd), bad);
   67.82 +	    if (s->crmd.rmd1.own && s->nrmd.rmd1.own && !s->nnrmd.rmd1.own) {
   67.83 +		CHECK_RMD(&(s->nnrmd),PHYSADDR(s,nnrd), bad);
   67.84 +	    }
   67.85              if (bad || (nnrd == crda)) nnrd = 0;
   67.86  
   67.87              s->csr[28] = crda & 0xffff;
   67.88 @@ -303,14 +290,12 @@ static void pcnet_rdte_poll(PCNetState *
   67.89      }
   67.90      
   67.91      if (CSR_CRDA(s)) {
   67.92 -        struct pcnet_RMD rmd;
   67.93 -        RMDLOAD(&rmd, PHYSADDR(s,CSR_CRDA(s)));
   67.94 -        CSR_CRBC(s) = rmd.rmd1.bcnt;
   67.95 -        CSR_CRST(s) = ((uint32_t *)&rmd)[1] >> 16;
   67.96 +        CSR_CRBC(s) = s->crmd.rmd1.bcnt;
   67.97 +        CSR_CRST(s) = ((uint32_t *)&(s->crmd))[1] >> 16;
   67.98  #ifdef PCNET_DEBUG_RMD_X
   67.99          printf("CRDA=0x%08x CRST=0x%04x RCVRC=%d RMD1=0x%08x RMD2=0x%08x\n",
  67.100                  PHYSADDR(s,CSR_CRDA(s)), CSR_CRST(s), CSR_RCVRC(s),
  67.101 -                ((uint32_t *)&rmd)[1], ((uint32_t *)&rmd)[2]);
  67.102 +                ((uint32_t *)&(s->crmd))[1], ((uint32_t *)&(s->crmd))[2]);
  67.103          PRINT_RMD(&rmd);
  67.104  #endif
  67.105      } else {
  67.106 @@ -318,10 +303,8 @@ static void pcnet_rdte_poll(PCNetState *
  67.107      }
  67.108      
  67.109      if (CSR_NRDA(s)) {
  67.110 -        struct pcnet_RMD rmd;
  67.111 -        RMDLOAD(&rmd, PHYSADDR(s,CSR_NRDA(s)));
  67.112 -        CSR_NRBC(s) = rmd.rmd1.bcnt;
  67.113 -        CSR_NRST(s) = ((uint32_t *)&rmd)[1] >> 16;
  67.114 +        CSR_NRBC(s) = s->nrmd.rmd1.bcnt;
  67.115 +        CSR_NRST(s) = ((uint32_t *)&(s->nrmd))[1] >> 16;
  67.116      } else {
  67.117          CSR_NRBC(s) = CSR_NRST(s) = 0;
  67.118      }
  67.119 @@ -336,6 +319,7 @@ static int pcnet_tdte_poll(PCNetState *s
  67.120              (CSR_XMTRL(s) - CSR_XMTRC(s)) *
  67.121              (BCR_SWSTYLE(s) ? 16 : 8 );
  67.122          int bad = 0;
  67.123 +	s->csr[0] &= ~0x0008;   /* clear TDMD */
  67.124          CHECK_TMD(PHYSADDR(s, cxda),bad);
  67.125          if (!bad) {
  67.126              if (CSR_CXDA(s) != cxda) {
  67.127 @@ -354,12 +338,8 @@ static int pcnet_tdte_poll(PCNetState *s
  67.128      }
  67.129  
  67.130      if (CSR_CXDA(s)) {
  67.131 -        struct pcnet_TMD tmd;
  67.132 -
  67.133 -        TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));                
  67.134 -
  67.135 -        CSR_CXBC(s) = tmd.tmd1.bcnt;
  67.136 -        CSR_CXST(s) = ((uint32_t *)&tmd)[1] >> 16;
  67.137 +        CSR_CXBC(s) = s->tmd.tmd1.bcnt;
  67.138 +        CSR_CXST(s) = ((uint32_t *)&(s->tmd))[1] >> 16;
  67.139      } else {
  67.140          CSR_CXBC(s) = CSR_CXST(s) = 0;
  67.141      }
  67.142 @@ -373,14 +353,11 @@ static int pcnet_can_receive(void *opaqu
  67.143      if (CSR_STOP(s) || CSR_SPND(s))
  67.144          return 0;
  67.145          
  67.146 -    if (s->recv_pos > 0)
  67.147 -        return 0;
  67.148 -
  67.149      pcnet_rdte_poll(s);
  67.150      if (!(CSR_CRST(s) & 0x8000)) {
  67.151          return 0;
  67.152      }
  67.153 -    return sizeof(s->buffer)-16;
  67.154 +    return sizeof(s->rx_buffer)-16;
  67.155  }
  67.156  
  67.157  #define MIN_BUF_SIZE 60
  67.158 @@ -389,7 +366,7 @@ static void pcnet_receive(void *opaque, 
  67.159  {
  67.160      PCNetState *s = opaque;
  67.161      int is_padr = 0, is_bcast = 0, is_ladr = 0;
  67.162 -    uint8_t buf1[60];
  67.163 +    int pad;
  67.164  
  67.165      if (CSR_DRX(s) || CSR_STOP(s) || CSR_SPND(s) || !size)
  67.166          return;
  67.167 @@ -399,12 +376,10 @@ static void pcnet_receive(void *opaque, 
  67.168  #endif
  67.169  
  67.170      /* if too small buffer, then expand it */
  67.171 -    if (size < MIN_BUF_SIZE) {
  67.172 -        memcpy(buf1, buf, size);
  67.173 -        memset(buf1 + size, 0, MIN_BUF_SIZE - size);
  67.174 -        buf = buf1;
  67.175 -        size = MIN_BUF_SIZE;
  67.176 -    }
  67.177 +    if (size < MIN_BUF_SIZE)
  67.178 +        pad = MIN_BUF_SIZE - size + 4;
  67.179 +    else 
  67.180 +	pad = 4;
  67.181  
  67.182      if (CSR_PROM(s) 
  67.183          || (is_padr=padr_match(s, buf, size)) 
  67.184 @@ -413,124 +388,74 @@ static void pcnet_receive(void *opaque, 
  67.185  
  67.186          pcnet_rdte_poll(s);
  67.187  
  67.188 -        if (!(CSR_CRST(s) & 0x8000) && s->rdra) {
  67.189 -            struct pcnet_RMD rmd;
  67.190 -            int rcvrc = CSR_RCVRC(s)-1,i;
  67.191 -            target_phys_addr_t nrda;
  67.192 -            for (i = CSR_RCVRL(s)-1; i > 0; i--, rcvrc--) {
  67.193 -                if (rcvrc <= 1)
  67.194 -                    rcvrc = CSR_RCVRL(s);
  67.195 -                nrda = s->rdra +
  67.196 -                    (CSR_RCVRL(s) - rcvrc) *
  67.197 -                    (BCR_SWSTYLE(s) ? 16 : 8 );
  67.198 -                RMDLOAD(&rmd, PHYSADDR(s,nrda));                  
  67.199 -                if (rmd.rmd1.own) {                
  67.200 +	if (size > 2000) {
  67.201  #ifdef PCNET_DEBUG_RMD
  67.202 -                    printf("pcnet - scan buffer: RCVRC=%d PREV_RCVRC=%d\n", 
  67.203 -                                rcvrc, CSR_RCVRC(s));
  67.204 +	    printf("pcnet - oversize packet discarded.\n");
  67.205  #endif
  67.206 -                    CSR_RCVRC(s) = rcvrc;
  67.207 -                    pcnet_rdte_poll(s);
  67.208 -                    break;
  67.209 -                }
  67.210 -            }
  67.211 -        }
  67.212 -
  67.213 -        if (!(CSR_CRST(s) & 0x8000)) {
  67.214 +	} else if (!(CSR_CRST(s) & 0x8000)) {
  67.215  #ifdef PCNET_DEBUG_RMD
  67.216              printf("pcnet - no buffer: RCVRC=%d\n", CSR_RCVRC(s));
  67.217  #endif
  67.218              s->csr[0] |= 0x1000; /* Set MISS flag */
  67.219              CSR_MISSC(s)++;
  67.220          } else {
  67.221 -            uint8_t *src = &s->buffer[8];
  67.222 +            uint8_t *src = &s->rx_buffer[8];
  67.223              target_phys_addr_t crda = CSR_CRDA(s);
  67.224 -            struct pcnet_RMD rmd;
  67.225 +            target_phys_addr_t nrda = CSR_NRDA(s);
  67.226 +            target_phys_addr_t nnrda = CSR_NNRD(s);
  67.227              int pktcount = 0;
  67.228 +	    int packet_size = size + pad;
  67.229  
  67.230              memcpy(src, buf, size);
  67.231 -            
  67.232 -            if (!CSR_ASTRP_RCV(s)) {
  67.233 -                uint32_t fcs = ~0;
  67.234 -#if 0            
  67.235 -                uint8_t *p = s->buffer;
  67.236 -                
  67.237 -                ((uint32_t *)p)[0] = ((uint32_t *)p)[1] = 0xaaaaaaaa;
  67.238 -                p[7] = 0xab;
  67.239 -#else
  67.240 -                uint8_t *p = src;
  67.241 -#endif
  67.242 -
  67.243 -                while (size < 46) {
  67.244 -                    src[size++] = 0;
  67.245 -                }
  67.246 -                
  67.247 -                while (p != &src[size]) {
  67.248 -                    CRC(fcs, *p++);
  67.249 -                }
  67.250 -                ((uint32_t *)&src[size])[0] = htonl(fcs);
  67.251 -                size += 4; /* FCS at end of packet */
  67.252 -            } else size += 4;
  67.253 +	    memset(src + size, 0, pad); 
  67.254 +            size += pad;
  67.255  
  67.256  #ifdef PCNET_DEBUG_MATCH
  67.257              PRINT_PKTHDR(buf);
  67.258  #endif
  67.259  
  67.260 -            RMDLOAD(&rmd, PHYSADDR(s,crda));
  67.261 -            /*if (!CSR_LAPPEN(s))*/
  67.262 -                rmd.rmd1.stp = 1;
  67.263 -
  67.264 -#define PCNET_RECV_STORE() do {                                 \
  67.265 -    int count = MIN(4096 - rmd.rmd1.bcnt,size);                 \
  67.266 -    target_phys_addr_t rbadr = PHYSADDR(s, rmd.rmd0.rbadr);     \
  67.267 -    cpu_physical_memory_write(rbadr, src, count);               \
  67.268 -    cpu_physical_memory_set_dirty(rbadr);                       \
  67.269 -    cpu_physical_memory_set_dirty(rbadr+count);                 \
  67.270 -    src += count; size -= count;                                \
  67.271 -    rmd.rmd2.mcnt = count; rmd.rmd1.own = 0;                    \
  67.272 -    RMDSTORE(&rmd, PHYSADDR(s,crda));                           \
  67.273 -    pktcount++;                                                 \
  67.274 -} while (0)
  67.275 +	    s->crmd.rmd1.stp = 1;
  67.276 +	    do {
  67.277 +		int count = MIN(4096 - s->crmd.rmd1.bcnt,size);
  67.278 +		target_phys_addr_t rbadr = PHYSADDR(s, s->crmd.rmd0.rbadr);
  67.279 +		cpu_physical_memory_write(rbadr, src, count);
  67.280 +		cpu_physical_memory_set_dirty(rbadr);
  67.281 +		cpu_physical_memory_set_dirty(rbadr+count);
  67.282 +		src += count; size -= count;
  67.283 +		if (size > 0 && s->nrmd.rmd1.own) {
  67.284 +		    RMDSTORE(&(s->crmd), PHYSADDR(s,crda));
  67.285 +		    crda = nrda;
  67.286 +		    nrda = nnrda;
  67.287 +		    s->crmd = s->nrmd;
  67.288 +		    s->nrmd = s->nnrmd;
  67.289 +		    s->nnrmd.rmd1.own = 0;
  67.290 +		}
  67.291 +		pktcount++;
  67.292 +	    } while (size > 0 && s->crmd.rmd1.own);
  67.293  
  67.294 -            PCNET_RECV_STORE();
  67.295 -            if ((size > 0) && CSR_NRDA(s)) {
  67.296 -                target_phys_addr_t nrda = CSR_NRDA(s);
  67.297 -                RMDLOAD(&rmd, PHYSADDR(s,nrda));
  67.298 -                if (rmd.rmd1.own) {
  67.299 -                    crda = nrda;
  67.300 -                    PCNET_RECV_STORE();
  67.301 -                    if ((size > 0) && (nrda=CSR_NNRD(s))) {
  67.302 -                        RMDLOAD(&rmd, PHYSADDR(s,nrda));
  67.303 -                        if (rmd.rmd1.own) {
  67.304 -                            crda = nrda;
  67.305 -                            PCNET_RECV_STORE();
  67.306 -                        }
  67.307 -                    }
  67.308 -                }                
  67.309 +            if (size == 0) {
  67.310 +                s->crmd.rmd1.enp = 1;
  67.311 +		s->crmd.rmd2.mcnt = packet_size;
  67.312 +                s->crmd.rmd1.pam = !CSR_PROM(s) && is_padr;
  67.313 +                s->crmd.rmd1.lafm = !CSR_PROM(s) && is_ladr;
  67.314 +                s->crmd.rmd1.bam = !CSR_PROM(s) && is_bcast;
  67.315 +            } else {
  67.316 +                s->crmd.rmd1.oflo = 1;
  67.317 +                s->crmd.rmd1.buff = 1;
  67.318 +                s->crmd.rmd1.err = 1;
  67.319              }
  67.320 -
  67.321 -#undef PCNET_RECV_STORE
  67.322 -
  67.323 -            RMDLOAD(&rmd, PHYSADDR(s,crda));
  67.324 -            if (size == 0) {
  67.325 -                rmd.rmd1.enp = 1;
  67.326 -                rmd.rmd1.pam = !CSR_PROM(s) && is_padr;
  67.327 -                rmd.rmd1.lafm = !CSR_PROM(s) && is_ladr;
  67.328 -                rmd.rmd1.bam = !CSR_PROM(s) && is_bcast;
  67.329 -            } else {
  67.330 -                rmd.rmd1.oflo = 1;
  67.331 -                rmd.rmd1.buff = 1;
  67.332 -                rmd.rmd1.err = 1;
  67.333 -            }
  67.334 -            RMDSTORE(&rmd, PHYSADDR(s,crda));
  67.335 +            RMDSTORE(&(s->crmd), PHYSADDR(s,crda));
  67.336              s->csr[0] |= 0x0400;
  67.337 +	    s->crmd = s->nrmd;
  67.338 +	    s->nrmd = s->nnrmd;
  67.339 +	    s->nnrmd.rmd1.own = 0;
  67.340  
  67.341  #ifdef PCNET_DEBUG
  67.342              printf("RCVRC=%d CRDA=0x%08x BLKS=%d\n", 
  67.343                  CSR_RCVRC(s), PHYSADDR(s,CSR_CRDA(s)), pktcount);
  67.344  #endif
  67.345  #ifdef PCNET_DEBUG_RMD
  67.346 -            PRINT_RMD(&rmd);
  67.347 +            PRINT_RMD(&s->crmd);
  67.348  #endif        
  67.349  
  67.350              while (pktcount--) {
  67.351 @@ -551,80 +476,88 @@ static void pcnet_receive(void *opaque, 
  67.352  
  67.353  static void pcnet_transmit(PCNetState *s)
  67.354  {
  67.355 -    target_phys_addr_t xmit_cxda = 0;
  67.356 +    target_phys_addr_t start_addr = 0;
  67.357 +    struct pcnet_TMD start_tmd;
  67.358      int count = CSR_XMTRL(s)-1;
  67.359 -    s->xmit_pos = -1;
  67.360 +    int xmit_pos = 0;
  67.361 +    int len;
  67.362 +
  67.363      
  67.364      if (!CSR_TXON(s)) {
  67.365          s->csr[0] &= ~0x0008;
  67.366          return;
  67.367      }
  67.368      
  67.369 -    txagain:
  67.370 -    if (pcnet_tdte_poll(s)) {
  67.371 -        struct pcnet_TMD tmd;
  67.372 -
  67.373 -        TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));                
  67.374 +    while (pcnet_tdte_poll(s)) {
  67.375  
  67.376  #ifdef PCNET_DEBUG_TMD
  67.377          printf("  TMDLOAD 0x%08x\n", PHYSADDR(s,CSR_CXDA(s)));
  67.378 -        PRINT_TMD(&tmd);
  67.379 +        PRINT_TMD(&(s->tmd));
  67.380  #endif
  67.381 -        if (tmd.tmd1.stp) {
  67.382 -            s->xmit_pos = 0;                
  67.383 -            if (!tmd.tmd1.enp) {
  67.384 -                cpu_physical_memory_read(PHYSADDR(s, tmd.tmd0.tbadr),
  67.385 -                        s->buffer, 4096 - tmd.tmd1.bcnt);
  67.386 -                s->xmit_pos += 4096 - tmd.tmd1.bcnt;
  67.387 -            } 
  67.388 -            xmit_cxda = PHYSADDR(s,CSR_CXDA(s));
  67.389 -        }
  67.390 -        if (tmd.tmd1.enp && (s->xmit_pos >= 0)) {
  67.391 -            cpu_physical_memory_read(PHYSADDR(s, tmd.tmd0.tbadr),
  67.392 -                    s->buffer + s->xmit_pos, 4096 - tmd.tmd1.bcnt);
  67.393 -            s->xmit_pos += 4096 - tmd.tmd1.bcnt;
  67.394 -
  67.395 -	    tmd.tmd1.own = 0;
  67.396 -	    TMDSTORE(&tmd, PHYSADDR(s,CSR_CXDA(s)));
  67.397 -
  67.398 -#ifdef PCNET_DEBUG
  67.399 -            printf("pcnet_transmit size=%d\n", s->xmit_pos);
  67.400 -#endif            
  67.401 -            if (CSR_LOOP(s))
  67.402 -                pcnet_receive(s, s->buffer, s->xmit_pos);
  67.403 -            else
  67.404 -                qemu_send_packet(s->nd, s->buffer, s->xmit_pos);
  67.405 -
  67.406 -            s->csr[0] &= ~0x0008;   /* clear TDMD */
  67.407 -            s->csr[4] |= 0x0004;    /* set TXSTRT */
  67.408 -            s->xmit_pos = -1;
  67.409 -        } else {
  67.410 -	    tmd.tmd1.own = 0;
  67.411 -	    TMDSTORE(&tmd, PHYSADDR(s,CSR_CXDA(s)));
  67.412 -	}
  67.413 -        if (!CSR_TOKINTD(s) || (CSR_LTINTEN(s) && tmd.tmd1.ltint))
  67.414 -            s->csr[0] |= 0x0200;    /* set TINT */
  67.415 -
  67.416 -        if (CSR_XMTRC(s)<=1)
  67.417 +	len = 4096 - s->tmd.tmd1.bcnt;
  67.418 +        if (CSR_XMTRC(s) <= 1)
  67.419              CSR_XMTRC(s) = CSR_XMTRL(s);
  67.420          else
  67.421              CSR_XMTRC(s)--;
  67.422 -        if (count--)
  67.423 -            goto txagain;
  67.424  
  67.425 -    } else 
  67.426 -    if (s->xmit_pos >= 0) {
  67.427 -        struct pcnet_TMD tmd;
  67.428 -        TMDLOAD(&tmd, PHYSADDR(s,xmit_cxda));                
  67.429 -        tmd.tmd2.buff = tmd.tmd2.uflo = tmd.tmd1.err = 1;
  67.430 -        tmd.tmd1.own = 0;
  67.431 -        TMDSTORE(&tmd, PHYSADDR(s,xmit_cxda));
  67.432 +	/* handle start followed by start */
  67.433 +        if (s->tmd.tmd1.stp && start_addr) {
  67.434 +	    TMDSTORE(&start_tmd, start_addr);
  67.435 +	    start_addr = 0;
  67.436 +	    xmit_pos = 0;
  67.437 +	}
  67.438 +	if ((xmit_pos + len) < sizeof(s->tx_buffer)) {
  67.439 +	    cpu_physical_memory_read(PHYSADDR(s, s->tmd.tmd0.tbadr),
  67.440 +			s->tx_buffer + xmit_pos, len);
  67.441 +	    xmit_pos += len;
  67.442 +	} else {
  67.443 +	    s->tmd.tmd2.buff = s->tmd.tmd2.uflo = s->tmd.tmd1.err = 1;
  67.444 +	    TMDSTORE(&(s->tmd), PHYSADDR(s,CSR_CXDA(s)));
  67.445 +	    if (start_addr == PHYSADDR(s,CSR_CXDA(s)))
  67.446 +	    	start_addr = 0;		/* don't clear own bit twice */
  67.447 +	    continue;
  67.448 +	}
  67.449 +        if (s->tmd.tmd1.stp) {
  67.450 +	    if (s->tmd.tmd1.enp) {
  67.451 +		if (CSR_LOOP(s))
  67.452 +		    pcnet_receive(s, s->tx_buffer, xmit_pos);
  67.453 +		else
  67.454 +		    qemu_send_packet(s->nd, s->tx_buffer, xmit_pos);
  67.455 +
  67.456 +		s->csr[4] |= 0x0008;    /* set TXSTRT */
  67.457 +		TMDSTORE(&(s->tmd), PHYSADDR(s,CSR_CXDA(s)));
  67.458 +		xmit_pos = 0;
  67.459 +		count--;
  67.460 +	    } else {
  67.461 +	        start_tmd = s->tmd;
  67.462 +		start_addr = PHYSADDR(s,CSR_CXDA(s));
  67.463 +	    }
  67.464 +        } else if (s->tmd.tmd1.enp) {
  67.465 +	    TMDSTORE(&(s->tmd), PHYSADDR(s,CSR_CXDA(s)));
  67.466 +	    if (start_addr) {
  67.467 +		TMDSTORE(&start_tmd, start_addr);
  67.468 +	    }
  67.469 +	    start_addr = 0;
  67.470 +	    xmit_pos = 0;
  67.471 +	    count--;
  67.472 +
  67.473 +        } else {
  67.474 +	    TMDSTORE(&(s->tmd), PHYSADDR(s,CSR_CXDA(s)));
  67.475 +	}
  67.476 +        if (!CSR_TOKINTD(s) || (CSR_LTINTEN(s) && s->tmd.tmd1.ltint))
  67.477 +            s->csr[0] |= 0x0200;    /* set TINT */
  67.478 +
  67.479 +        if (count <= 0)
  67.480 +            break;
  67.481 +
  67.482 +    }
  67.483 +    if (start_addr) {
  67.484 +        start_tmd.tmd2.buff = start_tmd.tmd2.uflo = start_tmd.tmd1.err = 1;
  67.485 +        TMDSTORE(&start_tmd, PHYSADDR(s,start_addr));
  67.486          s->csr[0] |= 0x0200;    /* set TINT */
  67.487          if (!CSR_DXSUFLO(s)) {
  67.488              s->csr[0] &= ~0x0010;
  67.489 -        } else
  67.490 -        if (count--)
  67.491 -          goto txagain;
  67.492 +        }
  67.493      }
  67.494  }
  67.495  
    68.1 --- a/tools/ioemu/hw/pcnet.h	Mon Mar 27 15:36:47 2006 -0700
    68.2 +++ b/tools/ioemu/hw/pcnet.h	Tue Mar 28 08:54:58 2006 -0700
    68.3 @@ -177,6 +177,26 @@ struct pcnet_RMD {
    68.4      } rmd3;    
    68.5  };
    68.6  
    68.7 +typedef struct PCNetState_st PCNetState;
    68.8 +
    68.9 +struct PCNetState_st {
   68.10 +    PCIDevice dev;
   68.11 +    NetDriverState *nd;
   68.12 +    int mmio_io_addr, rap, isr, lnkst;
   68.13 +    target_phys_addr_t rdra, tdra;
   68.14 +    uint8_t prom[16];
   68.15 +    uint16_t csr[128];
   68.16 +    uint16_t bcr[32];
   68.17 +    uint64_t timer;
   68.18 +    int recv_pos;
   68.19 +    uint8_t tx_buffer[2048];
   68.20 +    uint8_t rx_buffer[2048];
   68.21 +    struct pcnet_TMD tmd;
   68.22 +    struct pcnet_RMD crmd;
   68.23 +    struct pcnet_RMD nrmd;
   68.24 +    struct pcnet_RMD nnrmd;
   68.25 +};
   68.26 +
   68.27  
   68.28  #define PRINT_TMD(T) printf(    \
   68.29          "TMD0 : TBADR=0x%08x\n" \
   68.30 @@ -230,18 +250,17 @@ static inline void pcnet_tmd_load(PCNetS
   68.31          cpu_physical_memory_read(addr+4, (void *)&tmd->tmd1, 4);
   68.32          cpu_physical_memory_read(addr, (void *)&tmd->tmd0, 4);
   68.33      } else {
   68.34 -        uint32_t xda[4];
   68.35 -        cpu_physical_memory_read(addr,
   68.36 -                (void *)&xda[0], sizeof(xda));
   68.37 -        ((uint32_t *)tmd)[0] = xda[2];
   68.38 -        ((uint32_t *)tmd)[1] = xda[1];
   68.39 -        ((uint32_t *)tmd)[2] = xda[0];
   68.40 -        ((uint32_t *)tmd)[3] = xda[3];
   68.41 +        uint32_t xda[2];
   68.42 +        cpu_physical_memory_read(addr+4, (void *)&xda[0], sizeof(xda));
   68.43 +        ((uint32_t *)tmd)[0] = xda[1];
   68.44 +        ((uint32_t *)tmd)[1] = xda[0];
   68.45 +        ((uint32_t *)tmd)[2] = 0;
   68.46      }
   68.47  }
   68.48  
   68.49  static inline void pcnet_tmd_store(PCNetState *s, struct pcnet_TMD *tmd, target_phys_addr_t addr)
   68.50  {
   68.51 +    tmd->tmd1.own = 0;
   68.52      cpu_physical_memory_set_dirty(addr);
   68.53      if (!BCR_SWSTYLE(s)) {
   68.54          uint16_t xda[4];
   68.55 @@ -259,13 +278,10 @@ static inline void pcnet_tmd_store(PCNet
   68.56              cpu_physical_memory_write(addr+8, (void *)&tmd->tmd2, 4);
   68.57              cpu_physical_memory_write(addr+4, (void *)&tmd->tmd1, 4);
   68.58          } else {
   68.59 -            uint32_t xda[4];
   68.60 +            uint32_t xda[2];
   68.61              xda[0] = ((uint32_t *)tmd)[2];
   68.62              xda[1] = ((uint32_t *)tmd)[1];
   68.63 -            xda[2] = ((uint32_t *)tmd)[0];
   68.64 -            xda[3] = ((uint32_t *)tmd)[3];
   68.65 -            cpu_physical_memory_write(addr,
   68.66 -                    (void *)&xda[0], sizeof(xda));
   68.67 +            cpu_physical_memory_write(addr, (void *)&xda[0], sizeof(xda));
   68.68          }
   68.69          cpu_physical_memory_set_dirty(addr+15);
   68.70      }
   68.71 @@ -286,22 +302,21 @@ static inline void pcnet_rmd_load(PCNetS
   68.72      }
   68.73      else
   68.74      if (BCR_SWSTYLE(s) != 3) {
   68.75 -        rmd->rmd2.zeros = 0;
   68.76 +        ((uint32_t *)rmd)[2] = 0;
   68.77          cpu_physical_memory_read(addr+4, (void *)&rmd->rmd1, 4);
   68.78          cpu_physical_memory_read(addr, (void *)&rmd->rmd0, 4);
   68.79      } else {
   68.80 -        uint32_t rda[4];
   68.81 -        cpu_physical_memory_read(addr,
   68.82 -                (void *)&rda[0], sizeof(rda));
   68.83 -        ((uint32_t *)rmd)[0] = rda[2];
   68.84 -        ((uint32_t *)rmd)[1] = rda[1];
   68.85 -        ((uint32_t *)rmd)[2] = rda[0];
   68.86 -        ((uint32_t *)rmd)[3] = rda[3];
   68.87 +        uint32_t rda[2];
   68.88 +        cpu_physical_memory_read(addr+4, (void *)&rda[0], sizeof(rda));
   68.89 +        ((uint32_t *)rmd)[0] = rda[1];
   68.90 +        ((uint32_t *)rmd)[1] = rda[0];
   68.91 +        ((uint32_t *)rmd)[2] = 0;
   68.92      }
   68.93  }
   68.94  
   68.95  static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd, target_phys_addr_t addr)
   68.96  {
   68.97 +    rmd->rmd1.own = 0;
   68.98      cpu_physical_memory_set_dirty(addr);
   68.99      if (!BCR_SWSTYLE(s)) {
  68.100          uint16_t rda[4];                        \
  68.101 @@ -319,13 +334,10 @@ static inline void pcnet_rmd_store(PCNet
  68.102              cpu_physical_memory_write(addr+8, (void *)&rmd->rmd2, 4);
  68.103              cpu_physical_memory_write(addr+4, (void *)&rmd->rmd1, 4);
  68.104          } else {
  68.105 -            uint32_t rda[4];
  68.106 +            uint32_t rda[2];
  68.107              rda[0] = ((uint32_t *)rmd)[2];
  68.108              rda[1] = ((uint32_t *)rmd)[1];
  68.109 -            rda[2] = ((uint32_t *)rmd)[0];
  68.110 -            rda[3] = ((uint32_t *)rmd)[3];
  68.111 -            cpu_physical_memory_write(addr,
  68.112 -                    (void *)&rda[0], sizeof(rda));
  68.113 +            cpu_physical_memory_write(addr, (void *)&rda[0], sizeof(rda));
  68.114          }
  68.115          cpu_physical_memory_set_dirty(addr+15);
  68.116      }
  68.117 @@ -340,79 +352,16 @@ static inline void pcnet_rmd_store(PCNet
  68.118  
  68.119  #define RMDSTORE(RMD,ADDR) pcnet_rmd_store(s,RMD,ADDR)
  68.120  
  68.121 -#if 1
  68.122 -
  68.123 -#define CHECK_RMD(ADDR,RES) do {                \
  68.124 -    struct pcnet_RMD rmd;                       \
  68.125 -    RMDLOAD(&rmd,(ADDR));                       \
  68.126 -    (RES) |= (rmd.rmd1.ones != 15);             \
  68.127 -} while (0)
  68.128 -
  68.129 -#define CHECK_TMD(ADDR,RES) do {                \
  68.130 -    struct pcnet_TMD tmd;                       \
  68.131 -    TMDLOAD(&tmd,(ADDR));                       \
  68.132 -    (RES) |= (tmd.tmd1.ones != 15);             \
  68.133 +#define CHECK_RMD(RMD,ADDR,RES) do {            \
  68.134 +    RMDLOAD((RMD),(ADDR));                      \
  68.135 +    (RES) |= ((RMD)->rmd1.ones != 15);          \
  68.136  } while (0)
  68.137  
  68.138 -#else
  68.139 -
  68.140 -#define CHECK_RMD(ADDR,RES) do {                \
  68.141 -    switch (BCR_SWSTYLE(s)) {                   \
  68.142 -    case 0x00:                                  \
  68.143 -        do {                                    \
  68.144 -            uint16_t rda[4];                    \
  68.145 -            cpu_physical_memory_read((ADDR),    \
  68.146 -                (void *)&rda[0], sizeof(rda));  \
  68.147 -            (RES) |= (rda[2] & 0xf000)!=0xf000; \
  68.148 -            (RES) |= (rda[3] & 0xf000)!=0x0000; \
  68.149 -        } while (0);                            \
  68.150 -        break;                                  \
  68.151 -    case 0x01:                                  \
  68.152 -    case 0x02:                                  \
  68.153 -        do {                                    \
  68.154 -            uint32_t rda[4];                    \
  68.155 -            cpu_physical_memory_read((ADDR),    \
  68.156 -                (void *)&rda[0], sizeof(rda)); \
  68.157 -            (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
  68.158 -            (RES) |= (rda[2] & 0x0000f000L)!=0x00000000L; \
  68.159 -        } while (0);                            \
  68.160 -        break;                                  \
  68.161 -    case 0x03:                                  \
  68.162 -        do {                                    \
  68.163 -            uint32_t rda[4];                    \
  68.164 -            cpu_physical_memory_read((ADDR),    \
  68.165 -                (void *)&rda[0], sizeof(rda)); \
  68.166 -            (RES) |= (rda[0] & 0x0000f000L)!=0x00000000L; \
  68.167 -            (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
  68.168 -        } while (0);                            \
  68.169 -        break;                                  \
  68.170 -    }                                           \
  68.171 +#define CHECK_TMD(ADDR,RES) do {            \
  68.172 +    TMDLOAD(&(s->tmd),(ADDR));                       \
  68.173 +    (RES) |= (s->tmd.tmd1.ones != 15);             \
  68.174  } while (0)
  68.175  
  68.176 -#define CHECK_TMD(ADDR,RES) do {                \
  68.177 -    switch (BCR_SWSTYLE(s)) {                   \
  68.178 -    case 0x00:                                  \
  68.179 -        do {                                    \
  68.180 -            uint16_t xda[4];                    \
  68.181 -            cpu_physical_memory_read((ADDR),    \
  68.182 -                (void *)&xda[0], sizeof(xda));  \
  68.183 -            (RES) |= (xda[2] & 0xf000)!=0xf000;\
  68.184 -        } while (0);                            \
  68.185 -        break;                                  \
  68.186 -    case 0x01:                                  \
  68.187 -    case 0x02:                                  \
  68.188 -    case 0x03:                                  \
  68.189 -        do {                                    \
  68.190 -            uint32_t xda[4];                    \
  68.191 -            cpu_physical_memory_read((ADDR),    \
  68.192 -                (void *)&xda[0], sizeof(xda));  \
  68.193 -            (RES) |= (xda[1] & 0x0000f000L)!=0x0000f000L; \
  68.194 -        } while (0);                            \
  68.195 -        break;                                  \
  68.196 -    }                                           \
  68.197 -} while (0)
  68.198 -
  68.199 -#endif
  68.200  
  68.201  #define PRINT_PKTHDR(BUF) do {                  \
  68.202      struct ether_header *hdr = (void *)(BUF);   \
    69.1 --- a/tools/libxc/Makefile	Mon Mar 27 15:36:47 2006 -0700
    69.2 +++ b/tools/libxc/Makefile	Tue Mar 28 08:54:58 2006 -0700
    69.3 @@ -21,16 +21,12 @@ SRCS       += xc_private.c
    69.4  SRCS       += xc_sedf.c
    69.5  SRCS       += xc_tbuf.c
    69.6  
    69.7 -ifeq ($(XEN_TARGET_ARCH),x86_32)
    69.8 +ifeq ($(patsubst x86%,x86,$(XEN_TARGET_ARCH)),x86)
    69.9  SRCS       += xc_ptrace.c
   69.10  SRCS       += xc_ptrace_core.c
   69.11  SRCS       += xc_pagetab.c
   69.12  endif
   69.13  
   69.14 -ifeq ($(XEN_TARGET_ARCH),x86_64)
   69.15 -SRCS       += xc_pagetab.c
   69.16 -endif
   69.17 -
   69.18  BUILD_SRCS :=
   69.19  BUILD_SRCS += xc_linux_build.c
   69.20  BUILD_SRCS += xc_load_bin.c
    70.1 --- a/tools/libxc/xc_core.c	Mon Mar 27 15:36:47 2006 -0700
    70.2 +++ b/tools/libxc/xc_core.c	Tue Mar 28 08:54:58 2006 -0700
    70.3 @@ -3,7 +3,6 @@
    70.4  #include "xc_elf.h"
    70.5  #include <stdlib.h>
    70.6  #include <unistd.h>
    70.7 -#include <zlib.h>
    70.8  
    70.9  /* number of pages to write at a time */
   70.10  #define DUMP_INCREMENT (4 * 1024)
    71.1 --- a/tools/libxc/xc_private.c	Mon Mar 27 15:36:47 2006 -0700
    71.2 +++ b/tools/libxc/xc_private.c	Tue Mar 28 08:54:58 2006 -0700
    71.3 @@ -4,7 +4,6 @@
    71.4   * Helper functions for the rest of the library.
    71.5   */
    71.6  
    71.7 -#include <zlib.h>
    71.8  #include "xc_private.h"
    71.9  #include <xen/memory.h>
   71.10  
    72.1 --- a/tools/libxc/xc_ptrace.c	Mon Mar 27 15:36:47 2006 -0700
    72.2 +++ b/tools/libxc/xc_ptrace.c	Tue Mar 28 08:54:58 2006 -0700
    72.3 @@ -38,9 +38,6 @@ static char *ptrace_names[] = {
    72.4  };
    72.5  #endif
    72.6  
    72.7 -/* XXX application state */
    72.8 -static long                     nr_pages = 0;
    72.9 -static unsigned long           *page_array = NULL;
   72.10  static int                      current_domid = -1;
   72.11  static int                      current_isfile;
   72.12  
   72.13 @@ -196,6 +193,60 @@ map_domain_va_pae(
   72.14      return (void *)((unsigned long)v | (va & (PAGE_SIZE - 1)));
   72.15  }
   72.16  
   72.17 +#ifdef __x86_64__
   72.18 +static void *
   72.19 +map_domain_va(
   72.20 +    int xc_handle,
   72.21 +    int cpu,
   72.22 +    void *guest_va,
   72.23 +    int perm)
   72.24 +{
   72.25 +    unsigned long l3p, l2p, l1p, p, va = (unsigned long)guest_va;
   72.26 +    uint64_t *l4, *l3, *l2, *l1;
   72.27 +    static void *v;
   72.28 +
   72.29 +    if ((ctxt[cpu].ctrlreg[4] & 0x20) == 0 ) /* legacy ia32 mode */
   72.30 +        return map_domain_va_pae(xc_handle, cpu, guest_va, perm);
   72.31 +
   72.32 +    if (fetch_regs(xc_handle, cpu, NULL))
   72.33 +        return NULL;
   72.34 +
   72.35 +    l4 = xc_map_foreign_range(
   72.36 +        xc_handle, current_domid, PAGE_SIZE, PROT_READ, ctxt[cpu].ctrlreg[3] >> PAGE_SHIFT);
   72.37 +    if ( l4 == NULL )
   72.38 +        return NULL;
   72.39 +
   72.40 +    l3p = l4[l4_table_offset(va)] >> PAGE_SHIFT;
   72.41 +    l3 = xc_map_foreign_range(xc_handle, current_domid, PAGE_SIZE, PROT_READ, l3p);
   72.42 +    if ( l3 == NULL )
   72.43 +        return NULL;
   72.44 +
   72.45 +    l2p = l3[l3_table_offset(va)] >> PAGE_SHIFT;
   72.46 +    l2 = xc_map_foreign_range(xc_handle, current_domid, PAGE_SIZE, PROT_READ, l2p);
   72.47 +    if ( l2 == NULL )
   72.48 +        return NULL;
   72.49 +
   72.50 +    l1p = l2[l2_table_offset(va)] >> PAGE_SHIFT;
   72.51 +    l1 = xc_map_foreign_range(xc_handle, current_domid, PAGE_SIZE, perm, l1p);
   72.52 +    if ( l1 == NULL )
   72.53 +        return NULL;
   72.54 +
   72.55 +    p = l1[l1_table_offset(va)] >> PAGE_SHIFT;
   72.56 +    if ( v != NULL )
   72.57 +        munmap(v, PAGE_SIZE);
   72.58 +    v = xc_map_foreign_range(xc_handle, current_domid, PAGE_SIZE, perm, p);
   72.59 +    if ( v == NULL )
   72.60 +        return NULL;
   72.61 +
   72.62 +    return (void *)((unsigned long)v | (va & (PAGE_SIZE - 1)));
   72.63 +}
   72.64 +#endif
   72.65 +
   72.66 +#ifdef __i386__
   72.67 +/* XXX application state */
   72.68 +static long                     nr_pages = 0;
   72.69 +static unsigned long           *page_array = NULL;
   72.70 +
   72.71  static void *
   72.72  map_domain_va(
   72.73      int xc_handle,
   72.74 @@ -216,15 +267,18 @@ map_domain_va(
   72.75      static unsigned long  page_phys[MAX_VIRT_CPUS];
   72.76      static unsigned long *page_virt[MAX_VIRT_CPUS];    
   72.77      static int            prev_perm[MAX_VIRT_CPUS];
   72.78 -    static enum { MODE_UNKNOWN, MODE_32, MODE_PAE } mode;
   72.79 +    static enum { MODE_UNKNOWN, MODE_32, MODE_PAE, MODE_64 } mode;
   72.80  
   72.81      if ( mode == MODE_UNKNOWN )
   72.82      {
   72.83          xen_capabilities_info_t caps;
   72.84          (void)xc_version(xc_handle, XENVER_capabilities, caps);
   72.85 -        mode = MODE_32;
   72.86 -        if ( strstr(caps, "_x86_32p") )
   72.87 +        if ( strstr(caps, "-x86_64") )
   72.88 +            mode = MODE_64;
   72.89 +        else if ( strstr(caps, "-x86_32p") )
   72.90              mode = MODE_PAE;
   72.91 +        else if ( strstr(caps, "-x86_32") ) 
   72.92 +            mode = MODE_32;
   72.93      }
   72.94  
   72.95      if ( mode == MODE_PAE )
   72.96 @@ -304,6 +358,8 @@ map_domain_va(
   72.97      return (void *)(((unsigned long)page_virt[cpu]) | (va & BSD_PAGE_MASK));
   72.98  }
   72.99  
  72.100 +#endif
  72.101 +
  72.102  static int 
  72.103  __xc_waitdomain(
  72.104      int xc_handle,
    73.1 --- a/tools/libxc/xc_ptrace.h	Mon Mar 27 15:36:47 2006 -0700
    73.2 +++ b/tools/libxc/xc_ptrace.h	Tue Mar 28 08:54:58 2006 -0700
    73.3 @@ -10,6 +10,96 @@
    73.4  #define PDRSHIFT        22
    73.5  #define PSL_T  0x00000100 /* trace enable bit */
    73.6  
    73.7 +#ifdef __x86_64__
    73.8 +struct gdb_regs
    73.9 +{
   73.10 +  unsigned long r15;
   73.11 +  unsigned long r14;
   73.12 +  unsigned long r13;
   73.13 +  unsigned long r12;
   73.14 +  unsigned long rbp;
   73.15 +  unsigned long rbx;
   73.16 +  unsigned long r11;
   73.17 +  unsigned long r10;
   73.18 +  unsigned long r9;
   73.19 +  unsigned long r8;
   73.20 +  unsigned long rax;
   73.21 +  unsigned long rcx;
   73.22 +  unsigned long rdx;
   73.23 +  unsigned long rsi;
   73.24 +  unsigned long rdi;
   73.25 +  unsigned long orig_rax;
   73.26 +  unsigned long rip;
   73.27 +  unsigned long xcs;
   73.28 +  unsigned long eflags;
   73.29 +  unsigned long rsp;
   73.30 +  unsigned long xss;
   73.31 +  unsigned long fs_base;
   73.32 +  unsigned long gs_base;
   73.33 +  unsigned long xds;
   73.34 +  unsigned long xes;
   73.35 +  unsigned long xfs;
   73.36 +  unsigned long xgs;
   73.37 +};
   73.38 +
   73.39 +#define SET_PT_REGS(pt, xc)                     \
   73.40 +{                                               \
   73.41 +    pt.r8 = xc.r8;                              \
   73.42 +    pt.r9 = xc.r9;                              \
   73.43 +    pt.r10 = xc.r10;                            \
   73.44 +    pt.r11 = xc.r11;                            \
   73.45 +    pt.r12 = xc.r12;                            \
   73.46 +    pt.r13 = xc.r13;                            \
   73.47 +    pt.r14 = xc.r14;                            \
   73.48 +    pt.r15 = xc.r15;                            \
   73.49 +    pt.rbx = xc.rbx;                            \
   73.50 +    pt.rcx = xc.rcx;                            \
   73.51 +    pt.rdx = xc.rdx;                            \
   73.52 +    pt.rsi = xc.rsi;                            \
   73.53 +    pt.rdi = xc.rdi;                            \
   73.54 +    pt.rbp = xc.rbp;                            \
   73.55 +    pt.rax = xc.rax;                            \
   73.56 +    pt.rip = xc.rip;                            \
   73.57 +    pt.xcs = xc.cs;                             \
   73.58 +    pt.eflags = xc.eflags;                      \
   73.59 +    pt.rsp = xc.rsp;                            \
   73.60 +    pt.xss = xc.ss;                             \
   73.61 +    pt.xes = xc.es;                             \
   73.62 +    pt.xds = xc.ds;                             \
   73.63 +    pt.xfs = xc.fs;                             \
   73.64 +    pt.xgs = xc.gs;                             \
   73.65 +}
   73.66 +
   73.67 +#define SET_XC_REGS(pt, xc)                     \
   73.68 +{                                               \
   73.69 +    xc.r8 = pt->r8;                             \
   73.70 +    xc.r9 = pt->r9;                             \
   73.71 +    xc.r10 = pt->r10;                           \
   73.72 +    xc.r11 = pt->r11;                           \
   73.73 +    xc.r12 = pt->r12;                           \
   73.74 +    xc.r13 = pt->r13;                           \
   73.75 +    xc.r14 = pt->r14;                           \
   73.76 +    xc.r15 = pt->r15;                           \
   73.77 +    xc.rbx = pt->rbx;                           \
   73.78 +    xc.rcx = pt->rcx;                           \
   73.79 +    xc.rdx = pt->rdx;                           \
   73.80 +    xc.rsi = pt->rsi;                           \
   73.81 +    xc.rdi = pt->rdi;                           \
   73.82 +    xc.rbp = pt->rbp;                           \
   73.83 +    xc.rax = pt->rax;                           \
   73.84 +    xc.rip = pt->rip;                           \
   73.85 +    xc.cs = pt->xcs;                            \
   73.86 +    xc.eflags = pt->eflags;                     \
   73.87 +    xc.rsp = pt->rsp;                           \
   73.88 +    xc.ss = pt->xss;                            \
   73.89 +    xc.es = pt->xes;                            \
   73.90 +    xc.ds = pt->xds;                            \
   73.91 +    xc.fs = pt->xfs;                            \
   73.92 +    xc.gs = pt->xgs;                            \
   73.93 +}
   73.94 +
   73.95 +#elif __i386__
   73.96 +
   73.97  struct gdb_regs {
   73.98      long ebx; /* 0 */
   73.99      long ecx; /* 4 */
  73.100 @@ -30,8 +120,6 @@ struct gdb_regs {
  73.101      int  xss;    /* 64 */
  73.102  };
  73.103  
  73.104 -
  73.105 -#define printval(x) printf("%s = %lx\n", #x, (long)x);
  73.106  #define SET_PT_REGS(pt, xc)                     \
  73.107  {                                               \
  73.108      pt.ebx = xc.ebx;                            \
  73.109 @@ -71,7 +159,9 @@ struct gdb_regs {
  73.110      xc.fs = pt->xfs;                            \
  73.111      xc.gs = pt->xgs;                            \
  73.112  }
  73.113 +#endif
  73.114  
  73.115 +#define printval(x) printf("%s = %lx\n", #x, (long)x);
  73.116  #define vtopdi(va) ((va) >> PDRSHIFT)
  73.117  #define vtopti(va) (((va) >> PAGE_SHIFT) & 0x3ff)
  73.118  #endif
    74.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    74.2 +++ b/tools/python/xen/util/xmlrpclib2.py	Tue Mar 28 08:54:58 2006 -0700
    74.3 @@ -0,0 +1,111 @@
    74.4 +#============================================================================
    74.5 +# This library is free software; you can redistribute it and/or
    74.6 +# modify it under the terms of version 2.1 of the GNU Lesser General Public
    74.7 +# License as published by the Free Software Foundation.
    74.8 +#
    74.9 +# This library is distributed in the hope that it will be useful,
   74.10 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
   74.11 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   74.12 +# Lesser General Public License for more details.
   74.13 +#
   74.14 +# You should have received a copy of the GNU Lesser General Public
   74.15 +# License along with this library; if not, write to the Free Software
   74.16 +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   74.17 +#============================================================================
   74.18 +# Copyright (C) 2006 Anthony Liguori <aliguori@us.ibm.com>
   74.19 +# Copyright (C) 2006 XenSource Ltd.
   74.20 +#============================================================================
   74.21 +
   74.22 +"""
   74.23 +An enhanced XML-RPC client/server interface for Python.
   74.24 +"""
   74.25 +
   74.26 +from httplib import HTTPConnection, HTTP
   74.27 +from xmlrpclib import Transport
   74.28 +from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
   74.29 +import xmlrpclib, socket, os, traceback
   74.30 +import SocketServer
   74.31 +
   74.32 +# A new ServerProxy that also supports httpu urls.  An http URL comes in the
   74.33 +# form:
   74.34 +#
   74.35 +# httpu:///absolute/path/to/socket.sock
   74.36 +#
   74.37 +# It assumes that the RPC handler is /RPC2.  This probably needs to be improved
   74.38 +
   74.39 +class HTTPUnixConnection(HTTPConnection):
   74.40 +    def connect(self):
   74.41 +        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
   74.42 +        self.sock.connect(self.host)
   74.43 +
   74.44 +class HTTPUnix(HTTP):
   74.45 +    _connection_class = HTTPUnixConnection
   74.46 +
   74.47 +class UnixTransport(Transport):
   74.48 +    def request(self, host, handler, request_body, verbose=0):
   74.49 +        self.__handler = handler
   74.50 +        return Transport.request(self, host, '/RPC2', request_body, verbose)
   74.51 +    def make_connection(self, host):
   74.52 +        return HTTPUnix(self.__handler)
   74.53 +
   74.54 +class ServerProxy(xmlrpclib.ServerProxy):
   74.55 +    def __init__(self, uri, transport=None, encoding=None, verbose=0,
   74.56 +                 allow_none=1):
   74.57 +        if transport == None:
   74.58 +            (protocol, rest) = uri.split(':', 1)
   74.59 +            if protocol == 'httpu':
   74.60 +                uri = 'http:' + rest
   74.61 +                transport = UnixTransport()
   74.62 +        xmlrpclib.ServerProxy.__init__(self, uri, transport, encoding,
   74.63 +                                       verbose, allow_none)
   74.64 +
   74.65 +# This is a base XML-RPC server for TCP.  It sets allow_reuse_address to
   74.66 +# true, and has an improved marshaller that serializes unknown exceptions
   74.67 +# with full traceback information.
   74.68 +
   74.69 +class TCPXMLRPCServer(SocketServer.ThreadingMixIn, SimpleXMLRPCServer):
   74.70 +    allow_reuse_address = True
   74.71 +
   74.72 +    def _marshaled_dispatch(self, data, dispatch_method = None):
   74.73 +        params, method = xmlrpclib.loads(data)
   74.74 +        try:
   74.75 +            if dispatch_method is not None:
   74.76 +                response = dispatch_method(method, params)
   74.77 +            else:
   74.78 +                response = self._dispatch(method, params)
   74.79 +
   74.80 +            response = (response,)
   74.81 +            response = xmlrpclib.dumps(response,
   74.82 +                                       methodresponse=1,
   74.83 +                                       allow_none=1)
   74.84 +        except xmlrpclib.Fault, fault:
   74.85 +            response = xmlrpclib.dumps(fault)
   74.86 +        except:
   74.87 +            response = xmlrpclib.dumps(
   74.88 +                xmlrpclib.Fault(1, traceback.format_exc())
   74.89 +                )
   74.90 +
   74.91 +        return response
   74.92 +
   74.93 +# This is a XML-RPC server that sits on a Unix domain socket.
   74.94 +# It implements proper support for allow_reuse_address by
   74.95 +# unlink()'ing an existing socket.
   74.96 +
   74.97 +class UnixXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
   74.98 +    def address_string(self):
   74.99 +        try:
  74.100 +            return SimpleXMLRPCRequestHandler.address_string(self)
  74.101 +        except ValueError, e:
  74.102 +            return self.client_address[:2]
  74.103 +
  74.104 +class UnixXMLRPCServer(TCPXMLRPCServer):
  74.105 +    address_family = socket.AF_UNIX
  74.106 +
  74.107 +    def __init__(self, addr, logRequests):
  74.108 +        if self.allow_reuse_address:
  74.109 +            try:
  74.110 +                os.unlink(addr)
  74.111 +            except OSError, exc:
  74.112 +                pass
  74.113 +        TCPXMLRPCServer.__init__(self, addr, UnixXMLRPCRequestHandler,
  74.114 +                                 logRequests)
    75.1 --- a/tools/python/xen/xend/XendClient.py	Mon Mar 27 15:36:47 2006 -0700
    75.2 +++ b/tools/python/xen/xend/XendClient.py	Tue Mar 28 08:54:58 2006 -0700
    75.3 @@ -14,403 +14,15 @@
    75.4  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    75.5  #============================================================================
    75.6  # Copyright (C) 2004, 2005 Mike Wray <mike.wray@hp.com>
    75.7 +# Copyright (C) 2006 Anthony Liguori <aliguori@us.ibm.com>
    75.8  #============================================================================
    75.9  
   75.10 -"""Client API for the HTTP interface on xend.
   75.11 -Callable as a script - see main().
   75.12 -Supports inet or unix connection to xend.
   75.13 -
   75.14 -This API is the 'control-plane' for xend.
   75.15 -The 'data-plane' is done separately.
   75.16 -"""
   75.17 -import os
   75.18 -import sys
   75.19 -import types
   75.20 -
   75.21 -import sxp
   75.22 -import PrettyPrint
   75.23 -from XendProtocol import HttpXendClientProtocol, \
   75.24 -                         UnixXendClientProtocol, \
   75.25 -                         XendError
   75.26 -
   75.27 -def fileof(val):
   75.28 -    """Converter for passing configs or other 'large' data.
   75.29 -    Handles lists, files directly.
   75.30 -    Assumes a string is a file name and passes its contents.
   75.31 -    """
   75.32 -    if isinstance(val, types.ListType):
   75.33 -        return sxp.to_string(val)
   75.34 -    if isinstance(val, types.StringType):
   75.35 -        return file(val)
   75.36 -    if hasattr(val, 'readlines'):
   75.37 -        return val
   75.38 -    raise XendError('cannot convert value')
   75.39 -
   75.40 -class URL:
   75.41 -    """A URL.
   75.42 -    """
   75.43 -
   75.44 -    def __init__(self, proto='http', host='localhost', port=None, path='', query=None, frag=None):
   75.45 -        self.proto = proto
   75.46 -        self.host = host
   75.47 -        if port: port = int(port)
   75.48 -        self.port = port
   75.49 -        self.path = path
   75.50 -        self.query = query
   75.51 -        self.frag = frag
   75.52 -
   75.53 -    def url(self):
   75.54 -        """Get the full URL string including protocol, location and the full path.
   75.55 -        """
   75.56 -        return self.proto + '://' + self.location() + self.fullpath()
   75.57 -
   75.58 -    def location(self):
   75.59 -        """Get the location part of the URL, including host and port, if present.
   75.60 -        """
   75.61 -        if self.port:
   75.62 -            return self.host + ':' + str(self.port)
   75.63 -        else:
   75.64 -            return self.host
   75.65 -
   75.66 -    def fullpath(self):
   75.67 -        """Get the full path part of the URL, including query and fragment if present.
   75.68 -        """
   75.69 -        u = [ self.path ]
   75.70 -        if self.query:
   75.71 -            u.append('?')
   75.72 -            u.append(self.query)
   75.73 -        if self.frag:
   75.74 -            u.append('#')
   75.75 -            u.append(self.frag)
   75.76 -        return ''.join(u)
   75.77 -
   75.78 -    def relative(self, path='', query=None, frag=None):
   75.79 -        """Create a URL relative to this one.
   75.80 -        """
   75.81 -        return URL(proto=self.proto,
   75.82 -                   host=self.host,
   75.83 -                   port=self.port,
   75.84 -                   path=self.path + path,
   75.85 -                   query=query,
   75.86 -                   frag=frag)
   75.87 -
   75.88 -class Xend:
   75.89 -    """Client interface to Xend.
   75.90 -    """
   75.91 -
   75.92 -    """Default location of the xend server."""
   75.93 -    SRV_DEFAULT = "localhost:8000"
   75.94 -
   75.95 -    """Environment variable to set the location of xend."""
   75.96 -    SRV_VAR = "XEND"
   75.97 -
   75.98 -    """Default path to the xend root on the server."""
   75.99 -    ROOT_DEFAULT = "/xend/"
  75.100 -
  75.101 -    """Environment variable to set the xend root path."""
  75.102 -    ROOT_VAR = "XEND_ROOT"
  75.103 -
  75.104 -    def __init__(self, client=None, srv=None, root=None):
  75.105 -        """Create a xend client interface.
  75.106 -        If the client protocol is not specified, the default
  75.107 -        is to use a synchronous protocol.
  75.108 -
  75.109 -        @param client:  client protocol to use
  75.110 -        @param srv:     server host, and optional port (format host:port)
  75.111 -        @param root:    xend root path on the server
  75.112 -        """
  75.113 -        if client is None:
  75.114 -            client = HttpXendClientProtocol()
  75.115 -        self.client = client
  75.116 -        self.bind(srv, root)
  75.117 -
  75.118 -    def default_server(self):
  75.119 -        """Get the default location of the xend server.
  75.120 -        """
  75.121 -        return os.getenv(self.SRV_VAR, self.SRV_DEFAULT)
  75.122 -
  75.123 -    def default_root(self):
  75.124 -        """Get the default root path on the xend server.
  75.125 -        """
  75.126 -        return os.getenv(self.ROOT_VAR, self.ROOT_DEFAULT)
  75.127 -
  75.128 -    def bind(self, srv=None, root=None):
  75.129 -        """Bind to a given server.
  75.130 -
  75.131 -        @param srv:  server location (host:port)
  75.132 -        @param root: xend root path on the server
  75.133 -        """
  75.134 -        if srv is None: srv = self.default_server()
  75.135 -        if root is None: root = self.default_root()
  75.136 -        if not root.endswith('/'): root += '/'
  75.137 -        (host, port) = srv.split(':', 1)
  75.138 -        self.url = URL(host=host, port=port, path=root)
  75.139 -
  75.140 -    def xendGet(self, url, args=None):
  75.141 -        return self.client.xendGet(url, args)
  75.142 -
  75.143 -    def xendPost(self, url, data):
  75.144 -        return self.client.xendPost(url, data)
  75.145 -
  75.146 -    def nodeurl(self, id=''):
  75.147 -        return self.url.relative('node/' + str(id))
  75.148 -
  75.149 -    def domainurl(self, id=''):
  75.150 -        return self.url.relative('domain/' + str(id))
  75.151 -
  75.152 -    def deviceurl(self, id=''):
  75.153 -        return self.url.relative('device/' + str(id))
  75.154 -
  75.155 -    def vneturl(self, id=''):
  75.156 -        return self.url.relative('vnet/' + str(id))
  75.157 -
  75.158 -    def xend(self):
  75.159 -        return self.xendGet(self.url)
  75.160 -
  75.161 -    def xend_node(self):
  75.162 -        return self.xendGet(self.nodeurl())
  75.163 -        
  75.164 -    def xend_node_shutdown(self):
  75.165 -        return self.xendPost(self.nodeurl(),
  75.166 -                             {'op'      : 'shutdown'})
  75.167 -                
  75.168 -    def xend_node_restart(self):
  75.169 -        return self.xendPost(self.nodeurl(),
  75.170 -                             {'op'      : 'reboot'})
  75.171 -
  75.172 -    def xend_node_get_dmesg(self):
  75.173 -            return self.xendGet(self.nodeurl('dmesg'))
  75.174 -
  75.175 -    def xend_node_clear_dmesg(self):
  75.176 -        return self.xendPost(self.nodeurl('dmesg'),
  75.177 -                             {'op' : 'clear' } )
  75.178 -
  75.179 -    def xend_node_log(self):
  75.180 -        return self.xendGet(self.nodeurl('log'))
  75.181 -
  75.182 -    def xend_node_cpu_bvt_slice_set(self, ctx_allow):
  75.183 -        return self.xendPost(self.nodeurl(),
  75.184 -                             {'op'      : 'cpu_bvt_slice_set',
  75.185 -                              'ctx_allow' : ctx_allow })
  75.186 -
  75.187 -    def xend_domains(self):
  75.188 -        return self.xendGet(self.domainurl())
  75.189 -
  75.190 -    def xend_list_domains(self, detail = True):
  75.191 -        return self.xendGet(self.domainurl(),
  75.192 -                            {'detail': detail and '1' or '0'})
  75.193 -
  75.194 -    def xend_domain_vcpuinfo(self, dom):
  75.195 -        return self.xendGet(self.domainurl(dom), {'op': 'vcpuinfo'})
  75.196 -
  75.197 -    def xend_domain_create(self, conf):
  75.198 -        return self.xendPost(self.domainurl(),
  75.199 -                             {'op'      : 'create',
  75.200 -                              'config'  : fileof(conf) })
  75.201 -
  75.202 -    def xend_domain_restore(self, filename):
  75.203 -        return self.xendPost(self.domainurl(),
  75.204 -                             {'op'      : 'restore',
  75.205 -                              'file'    : filename })
  75.206 +from xen.util.xmlrpclib2 import ServerProxy
  75.207  
  75.208 -    def xend_domain_configure(self, id, conf):
  75.209 -        return self.xendPost(self.domainurl(id),
  75.210 -                             {'op'      : 'configure',
  75.211 -                              'config'  : fileof(conf) })
  75.212 -
  75.213 -    def xend_domain(self, id):
  75.214 -        return self.xendGet(self.domainurl(id))
  75.215 -
  75.216 -    def xend_domain_wait_for_devices(self, id):
  75.217 -        return self.xendPost(self.domainurl(id),
  75.218 -                             {'op'      : 'wait_for_devices' })
  75.219 -
  75.220 -    def xend_domain_unpause(self, id):
  75.221 -        return self.xendPost(self.domainurl(id),
  75.222 -                             {'op'      : 'unpause' })
  75.223 -
  75.224 -    def xend_domain_pause(self, id):
  75.225 -        return self.xendPost(self.domainurl(id),
  75.226 -                             {'op'      : 'pause' })
  75.227 -
  75.228 -    def xend_domain_rename(self, id, name):
  75.229 -        return self.xendPost(self.domainurl(id),
  75.230 -                             {'op'      : 'rename',
  75.231 -                              'name'    : name})
  75.232 -
  75.233 -    def xend_domain_shutdown(self, id, reason):
  75.234 -        return self.xendPost(self.domainurl(id),
  75.235 -                             {'op'      : 'shutdown',
  75.236 -                              'reason'  : reason})
  75.237 -
  75.238 -    def xend_domain_sysrq(self, id, key):
  75.239 -        return self.xendPost(self.domainurl(id),
  75.240 -                             {'op'      : 'sysrq',
  75.241 -                              'key'     : key})
  75.242 -
  75.243 -    def xend_domain_destroy(self, id):
  75.244 -        return self.xendPost(self.domainurl(id),
  75.245 -                             {'op'      : 'destroy' })
  75.246 -
  75.247 -    def xend_domain_save(self, id, filename):
  75.248 -        return self.xendPost(self.domainurl(id),
  75.249 -                             {'op'      : 'save',
  75.250 -                              'file'    : filename })
  75.251 -
  75.252 -    def xend_domain_migrate(self, id, dst, live=0, resource=0, port=0):
  75.253 -        return self.xendPost(self.domainurl(id),
  75.254 -                             {'op'         : 'migrate',
  75.255 -                              'destination': dst,
  75.256 -                              'live'       : live,
  75.257 -                              'resource'   : resource,
  75.258 -                              'port'       : port })
  75.259 -
  75.260 -    def xend_domain_pincpu(self, id, vcpu, cpumap):
  75.261 -        return self.xendPost(self.domainurl(id),
  75.262 -                             {'op'      : 'pincpu',
  75.263 -                              'vcpu'    : vcpu,
  75.264 -                              'cpumap'  : str(cpumap) })
  75.265 -
  75.266 -    def xend_domain_cpu_bvt_set(self, id, mcuadv, warpback, warpvalue, warpl, warpu):
  75.267 -        return self.xendPost(self.domainurl(id),
  75.268 -                             {'op'       : 'cpu_bvt_set',
  75.269 -                              'mcuadv'   : mcuadv,
  75.270 -                              'warpback' : warpback,
  75.271 -                              'warpvalue': warpvalue,
  75.272 -                              'warpl'    : warpl,
  75.273 -                              'warpu'    : warpu })
  75.274 -
  75.275 -    def xend_domain_cpu_sedf_get(self, id):
  75.276 -        return self.xendPost(self.domainurl(id),
  75.277 -                             {'op' : 'cpu_sedf_get'})
  75.278 -
  75.279 -    def xend_domain_cpu_sedf_set(self, id, period, slice, latency, extratime, weight):
  75.280 -        return self.xendPost(self.domainurl(id),
  75.281 -                             {'op'        : 'cpu_sedf_set',
  75.282 -                              'period'    : period,
  75.283 -                              'slice'     : slice,
  75.284 -			      'latency'   : latency,
  75.285 -			      'extratime' : extratime,
  75.286 -			      'weight'    : weight })
  75.287 -
  75.288 -    def xend_domain_maxmem_set(self, id, memory):
  75.289 -        return self.xendPost(self.domainurl(id),
  75.290 -                             { 'op'      : 'maxmem_set',
  75.291 -                               'memory'  : memory })
  75.292 -
  75.293 -    def xend_domain_mem_target_set(self, id, mem_target):
  75.294 -        val = self.xendPost(self.domainurl(id),
  75.295 -                            {'op'        : 'mem_target_set',
  75.296 -                             'target'    : mem_target })
  75.297 -        return val
  75.298 -
  75.299 -    def xend_domain_set_vcpus(self, dom, vcpus):
  75.300 -        return self.xendPost(self.domainurl(dom),
  75.301 -                            {'op'    : 'set_vcpus',
  75.302 -                             'vcpus' : vcpus })
  75.303 +XML_RPC_SOCKET = "/var/run/xend-xmlrpc.sock"
  75.304  
  75.305 -    def xend_domain_devices(self, id, type):
  75.306 -        return self.xendPost(self.domainurl(id),
  75.307 -                             {'op'      : 'devices',
  75.308 -                              'type'    : type })
  75.309 -
  75.310 -    def xend_domain_device_create(self, id, config):
  75.311 -        return self.xendPost(self.domainurl(id),
  75.312 -                             {'op'      : 'device_create',
  75.313 -                              'config'  : fileof(config) })
  75.314 -
  75.315 -    def xend_domain_device_refresh(self, id, type, dev):
  75.316 -        return self.xendPost(self.domainurl(id),
  75.317 -                             {'op'      : 'device_refresh',
  75.318 -                              'type'    : type,
  75.319 -                              'dev'     : dev })
  75.320 -
  75.321 -    def xend_domain_device_destroy(self, id, type, dev):
  75.322 -        return self.xendPost(self.domainurl(id),
  75.323 -                             {'op'      : 'device_destroy',
  75.324 -                              'type'    : type,
  75.325 -                              'dev'     : dev })
  75.326 -
  75.327 -    def xend_domain_device_configure(self, id, config, dev):
  75.328 -        return self.xendPost(self.domainurl(id),
  75.329 -                             {'op'      : 'device_configure',
  75.330 -                              'dev'     : dev,
  75.331 -                              'config'  : fileof(config) })
  75.332 -
  75.333 -    def xend_vnets(self):
  75.334 -        return self.xendGet(self.vneturl())
  75.335 -
  75.336 -    def xend_vnet_create(self, conf):
  75.337 -        return self.xendPost(self.vneturl(),
  75.338 -                             {'op'      : 'create',
  75.339 -                              'config'  : fileof(conf) })
  75.340 -
  75.341 -    def xend_vnet(self, id):
  75.342 -        return self.xendGet(self.vneturl(id))
  75.343 -
  75.344 -    def xend_vnet_delete(self, id):
  75.345 -        return self.xendPost(self.vneturl(id),
  75.346 -                              {'op'     : 'delete' })
  75.347 -
  75.348 -def getHttpServer(srv=None):
  75.349 -    """Create and return a xend client.
  75.350 -    """
  75.351 -    return Xend(srv=srv, client=HttpXendClientProtocol())
  75.352 +ERROR_INTERNAL = 1
  75.353 +ERROR_GENERIC = 2
  75.354 +ERROR_INVALID_DOMAIN = 3
  75.355  
  75.356 -def getUnixServer(srv=None):
  75.357 -    """Create and return a unix-domain xend client.
  75.358 -    """
  75.359 -    return Xend(client=UnixXendClientProtocol(srv))
  75.360 -
  75.361 -def xendmain(srv, fn, args, unix=False):
  75.362 -    if unix:
  75.363 -        xend = getUnixServer(srv)
  75.364 -    else:
  75.365 -        xend = getHttpServer(srv)
  75.366 -    xend.rc = 0
  75.367 -    try:
  75.368 -        v = getattr(xend, fn)(*args)
  75.369 -        PrettyPrint.prettyprint(v)
  75.370 -        return 0
  75.371 -    except XendError, err:
  75.372 -        print 'ERROR:', err
  75.373 -        return 1
  75.374 -
  75.375 -def main(argv):
  75.376 -    """Call an API function:
  75.377 -
  75.378 -    python XendClient.py fn args...
  75.379 -
  75.380 -    The leading 'xend_' on the function can be omitted.
  75.381 -    Example:
  75.382 -
  75.383 -python XendClient.py domains
  75.384 -    (0 8)
  75.385 -python XendClient.py domain 0
  75.386 -    (domain (id 0) (name Domain-0) (memory 128))
  75.387 -    """
  75.388 -    from getopt import getopt
  75.389 -    short_options = 'x:au:d'
  75.390 -    long_options = ['xend=', 'unix=', 'debug']
  75.391 -    (options, args) = getopt(argv[1:], short_options, long_options)
  75.392 -    srv = None
  75.393 -    unix = 1
  75.394 -    for k, v in options:
  75.395 -        if k in ['-x', '--xend']:
  75.396 -            srv = v
  75.397 -        elif k in ['-u', '--unix']:
  75.398 -            unix = int(v)
  75.399 -    if len(args):
  75.400 -        fn = args[0]
  75.401 -        args = args[1:]
  75.402 -    else:
  75.403 -        fn = 'xend'
  75.404 -        args = []
  75.405 -    if not fn.startswith('xend'):
  75.406 -        fn = 'xend_' + fn
  75.407 -    sys.exit(xendmain(srv, fn, args, unix=unix))
  75.408 -
  75.409 -if __name__ == "__main__":
  75.410 -    main(sys.argv)
  75.411 -else:    
  75.412 -    server = getUnixServer()
  75.413 +server = ServerProxy('httpu:///var/run/xend-xmlrpc.sock')
    76.1 --- a/tools/python/xen/xend/XendDomain.py	Mon Mar 27 15:36:47 2006 -0700
    76.2 +++ b/tools/python/xen/xend/XendDomain.py	Tue Mar 28 08:54:58 2006 -0700
    76.3 @@ -81,7 +81,8 @@ class XendDomain:
    76.4              # that we're sure that we haven't missed any releases, but inside
    76.5              # the domains_lock, as we don't want the watch to fire until after
    76.6              # the refresh call has completed.
    76.7 -            xswatch("@releaseDomain", self.onReleaseDomain)
    76.8 +            xswatch("@introduceDomain", self.onChangeDomain)
    76.9 +            xswatch("@releaseDomain",   self.onChangeDomain)
   76.10              
   76.11              self.refresh(True)
   76.12          finally:
   76.13 @@ -121,7 +122,7 @@ class XendDomain:
   76.14  
   76.15      ## private:
   76.16  
   76.17 -    def onReleaseDomain(self, _):
   76.18 +    def onChangeDomain(self, _):
   76.19          self.domains_lock.acquire()
   76.20          try:
   76.21              self.refresh()
   76.22 @@ -355,7 +356,7 @@ class XendDomain:
   76.23      def domain_unpause(self, domid):
   76.24          """Unpause domain execution."""
   76.25          try:
   76.26 -            dominfo = self.domain_lookup(domid)
   76.27 +            dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.28              log.info("Domain %s (%d) unpaused.", dominfo.getName(),
   76.29                       dominfo.getDomid())
   76.30              return dominfo.unpause()
   76.31 @@ -366,7 +367,7 @@ class XendDomain:
   76.32      def domain_pause(self, domid):
   76.33          """Pause domain execution."""
   76.34          try:
   76.35 -            dominfo = self.domain_lookup(domid)
   76.36 +            dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.37              log.info("Domain %s (%d) paused.", dominfo.getName(),
   76.38                       dominfo.getDomid())
   76.39              return dominfo.pause()
   76.40 @@ -377,10 +378,10 @@ class XendDomain:
   76.41      def domain_destroy(self, domid):
   76.42          """Terminate domain immediately."""
   76.43  
   76.44 -        if domid == PRIV_DOMAIN:
   76.45 -            raise XendError("Cannot destroy privileged domain %i" % domid)
   76.46 -        
   76.47 -        dominfo = self.domain_lookup(domid)
   76.48 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.49 +	if dominfo and dominfo.getDomid() == PRIV_DOMAIN:
   76.50 +            raise XendError("Cannot destroy privileged domain %s" % domid)
   76.51 +
   76.52          if dominfo:
   76.53              val = dominfo.destroy()
   76.54          else:
   76.55 @@ -393,7 +394,7 @@ class XendDomain:
   76.56      def domain_migrate(self, domid, dst, live=False, resource=0, port=0):
   76.57          """Start domain migration."""
   76.58  
   76.59 -        dominfo = self.domain_lookup(domid)
   76.60 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.61  
   76.62          if dominfo.getDomid() == PRIV_DOMAIN:
   76.63              raise XendError("Cannot migrate privileged domain %i" % domid)
   76.64 @@ -418,7 +419,7 @@ class XendDomain:
   76.65          """
   76.66  
   76.67          try:
   76.68 -            dominfo = self.domain_lookup(domid)
   76.69 +            dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.70  
   76.71              if dominfo.getDomid() == PRIV_DOMAIN:
   76.72                  raise XendError("Cannot save privileged domain %i" % domid)
   76.73 @@ -438,7 +439,7 @@ class XendDomain:
   76.74  
   76.75          @param cpumap:  string repr of list of usable cpus
   76.76          """
   76.77 -        dominfo = self.domain_lookup(domid)
   76.78 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.79          # convert cpumap string into a list of ints
   76.80          cpumap = map(lambda x: int(x),
   76.81                       cpumap.replace("[", "").replace("]", "").split(","))
   76.82 @@ -451,7 +452,7 @@ class XendDomain:
   76.83                             warpu):
   76.84          """Set BVT (Borrowed Virtual Time) scheduler parameters for a domain.
   76.85          """
   76.86 -        dominfo = self.domain_lookup(domid)
   76.87 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.88          try:
   76.89              return xc.bvtsched_domain_set(dom=dominfo.getDomid(),
   76.90                                            mcuadv=mcuadv,
   76.91 @@ -464,7 +465,7 @@ class XendDomain:
   76.92      def domain_cpu_bvt_get(self, domid):
   76.93          """Get BVT (Borrowed Virtual Time) scheduler parameters for a domain.
   76.94          """
   76.95 -        dominfo = self.domain_lookup(domid)
   76.96 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
   76.97          try:
   76.98              return xc.bvtsched_domain_get(dominfo.getDomid())
   76.99          except Exception, ex:
  76.100 @@ -475,7 +476,7 @@ class XendDomain:
  76.101                              weight):
  76.102          """Set Simple EDF scheduler parameters for a domain.
  76.103          """
  76.104 -        dominfo = self.domain_lookup(domid)
  76.105 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
  76.106          try:
  76.107              return xc.sedf_domain_set(dominfo.getDomid(), period, slice_,
  76.108                                        latency, extratime, weight)
  76.109 @@ -485,7 +486,7 @@ class XendDomain:
  76.110      def domain_cpu_sedf_get(self, domid):
  76.111          """Get Simple EDF scheduler parameters for a domain.
  76.112          """
  76.113 -        dominfo = self.domain_lookup(domid)
  76.114 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
  76.115          try:
  76.116              
  76.117              sedf_info = xc.sedf_domain_get(dominfo.getDomid())
  76.118 @@ -507,7 +508,7 @@ class XendDomain:
  76.119          @param mem: memory limit (in MiB)
  76.120          @return: 0 on success, -1 on error
  76.121          """
  76.122 -        dominfo = self.domain_lookup(domid)
  76.123 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
  76.124          maxmem = int(mem) * 1024
  76.125          try:
  76.126              return xc.domain_setmaxmem(dominfo.getDomid(), maxmem)
  76.127 @@ -521,7 +522,7 @@ class XendDomain:
  76.128          @param last: last IO port
  76.129          @return: 0 on success, -1 on error
  76.130          """
  76.131 -        dominfo = self.domain_lookup(domid)
  76.132 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
  76.133          nr_ports = last - first + 1
  76.134          try:
  76.135              return xc.domain_ioport_permission(dominfo.getDomid(),
  76.136 @@ -538,7 +539,7 @@ class XendDomain:
  76.137          @param last: last IO port
  76.138          @return: 0 on success, -1 on error
  76.139          """
  76.140 -        dominfo = self.domain_lookup(domid)
  76.141 +        dominfo = self.domain_lookup_by_name_or_id_nr(domid)
  76.142          nr_ports = last - first + 1
  76.143          try:
  76.144              return xc.domain_ioport_permission(dominfo.getDomid(),
    77.1 --- a/tools/python/xen/xend/XendError.py	Mon Mar 27 15:36:47 2006 -0700
    77.2 +++ b/tools/python/xen/xend/XendError.py	Tue Mar 28 08:54:58 2006 -0700
    77.3 @@ -15,9 +15,18 @@
    77.4  # Copyright (C) 2004, 2005 Mike Wray <mike.wray@hp.com>
    77.5  #============================================================================
    77.6  
    77.7 -class XendError(ValueError):
    77.8 +from xmlrpclib import Fault
    77.9 +
   77.10 +import XendClient
   77.11 +
   77.12 +class XendInvalidDomain(Fault):
   77.13 +    def __init__(self, value):
   77.14 +        Fault.__init__(self, XendClient.ERROR_INVALID_DOMAIN, value)
   77.15 +
   77.16 +class XendError(Fault):
   77.17      
   77.18      def __init__(self, value):
   77.19 +        Fault.__init__(self, XendClient.ERROR_GENERIC, value)
   77.20          self.value = value
   77.21  
   77.22      def __str__(self):
    78.1 --- a/tools/python/xen/xend/XendRoot.py	Mon Mar 27 15:36:47 2006 -0700
    78.2 +++ b/tools/python/xen/xend/XendRoot.py	Tue Mar 28 08:54:58 2006 -0700
    78.3 @@ -57,9 +57,14 @@ class XendRoot:
    78.4      """Default level of information to be logged."""
    78.5      loglevel_default = 'DEBUG'
    78.6  
    78.7 -    """Default for the flag indicating whether xend should run an http server."""
    78.8 +    """Default for the flag indicating whether xend should run an http server
    78.9 +    (deprecated)."""
   78.10      xend_http_server_default = 'no'
   78.11  
   78.12 +    xend_tcp_xmlrpc_server_default = 'no'
   78.13 +
   78.14 +    xend_unix_xmlrpc_server_default = 'yes'
   78.15 +
   78.16      """Default interface address xend listens at. """
   78.17      xend_address_default      = ''
   78.18  
   78.19 @@ -77,8 +82,9 @@ class XendRoot:
   78.20  
   78.21      xend_relocation_hosts_allow_default = ''
   78.22  
   78.23 -    """Default for the flag indicating whether xend should run a unix-domain server."""
   78.24 -    xend_unix_server_default = 'yes'
   78.25 +    """Default for the flag indicating whether xend should run a unix-domain
   78.26 +    server (deprecated)."""
   78.27 +    xend_unix_server_default = 'no'
   78.28  
   78.29      """Default path the unix-domain server listens at."""
   78.30      xend_unix_path_default = '/var/lib/xend/xend-socket'
   78.31 @@ -180,6 +186,12 @@ class XendRoot:
   78.32          """
   78.33          return self.get_config_bool("xend-http-server", self.xend_http_server_default)
   78.34  
   78.35 +    def get_xend_tcp_xmlrpc_server(self):
   78.36 +        return self.get_config_bool("xend-tcp-xmlrpc-server", self.xend_tcp_xmlrpc_server_default)
   78.37 +
   78.38 +    def get_xend_unix_xmlrpc_server(self):
   78.39 +        return self.get_config_bool("xend-unix-xmlrpc-server", self.xend_unix_xmlrpc_server_default)
   78.40 +
   78.41      def get_xend_relocation_server(self):
   78.42          """Get the flag indicating whether xend should run a relocation server.
   78.43          """
    79.1 --- a/tools/python/xen/xend/server/SrvServer.py	Mon Mar 27 15:36:47 2006 -0700
    79.2 +++ b/tools/python/xen/xend/server/SrvServer.py	Tue Mar 28 08:54:58 2006 -0700
    79.3 @@ -52,6 +52,7 @@ from xen.xend.XendLogging import log
    79.4  from xen.web.SrvDir import SrvDir
    79.5  
    79.6  from SrvRoot import SrvRoot
    79.7 +from XMLRPCServer import XMLRPCServer
    79.8  
    79.9  
   79.10  xroot = XendRoot.instance()
   79.11 @@ -114,4 +115,10 @@ def create():
   79.12          path = xroot.get_xend_unix_path()
   79.13          log.info('unix path=' + path)
   79.14          servers.add(UnixHttpServer(root, path))
   79.15 +
   79.16 +    if xroot.get_xend_tcp_xmlrpc_server():
   79.17 +        servers.add(XMLRPCServer(True))
   79.18 +
   79.19 +    if xroot.get_xend_unix_xmlrpc_server():
   79.20 +        servers.add(XMLRPCServer())
   79.21      return servers
    80.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    80.2 +++ b/tools/python/xen/xend/server/XMLRPCServer.py	Tue Mar 28 08:54:58 2006 -0700
    80.3 @@ -0,0 +1,113 @@
    80.4 +#============================================================================
    80.5 +# This library is free software; you can redistribute it and/or
    80.6 +# modify it under the terms of version 2.1 of the GNU Lesser General Public
    80.7 +# License as published by the Free Software Foundation.
    80.8 +#
    80.9 +# This library is distributed in the hope that it will be useful,
   80.10 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
   80.11 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   80.12 +# Lesser General Public License for more details.
   80.13 +#
   80.14 +# You should have received a copy of the GNU Lesser General Public
   80.15 +# License along with this library; if not, write to the Free Software
   80.16 +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   80.17 +#============================================================================
   80.18 +# Copyright (C) 2006 Anthony Liguori <aliguori@us.ibm.com>
   80.19 +# Copyright (C) 2006 XenSource Ltd.
   80.20 +#============================================================================
   80.21 +
   80.22 +import xmlrpclib
   80.23 +
   80.24 +from xen.xend import XendDomain, XendDomainInfo, XendNode, \
   80.25 +                     XendLogging, XendDmesg
   80.26 +from xen.util.xmlrpclib2 import UnixXMLRPCServer, TCPXMLRPCServer
   80.27 +
   80.28 +from xen.xend.XendClient import XML_RPC_SOCKET, ERROR_INVALID_DOMAIN
   80.29 +from xen.xend.XendError import *
   80.30 +
   80.31 +def lookup(domid):
   80.32 +    info = XendDomain.instance().domain_lookup_by_name_or_id(domid)
   80.33 +    if not info:
   80.34 +        raise XendInvalidDomain(str(domid))
   80.35 +    return info
   80.36 +
   80.37 +def dispatch(domid, fn, args):
   80.38 +    info = lookup(domid)
   80.39 +    return getattr(info, fn)(*args)
   80.40 +
   80.41 +def domain(domid):
   80.42 +    info = lookup(domid)
   80.43 +    return info.sxpr()
   80.44 +
   80.45 +def domains(detail=1):
   80.46 +    if detail < 1:
   80.47 +        return XendDomain.instance().list_names()
   80.48 +    else:
   80.49 +        domains = XendDomain.instance().list_sorted()
   80.50 +        return map(lambda dom: dom.sxpr(), domains)
   80.51 +
   80.52 +def domain_create(config):
   80.53 +    info = XendDomain.instance().domain_create(config)
   80.54 +    return info.sxpr()
   80.55 +
   80.56 +def domain_restore(src):
   80.57 +    info = XendDomain.instance().domain_restore(src)
   80.58 +    return info.sxpr()    
   80.59 +
   80.60 +def get_log():
   80.61 +    f = open(XendLogging.getLogFilename(), 'r')
   80.62 +    try:
   80.63 +        return f.read()
   80.64 +    finally:
   80.65 +        f.close()
   80.66 +
   80.67 +methods = ['device_create', 'destroyDevice', 'getDeviceSxprs',
   80.68 +           'setMemoryTarget', 'setName', 'setVCpuCount', 'shutdown',
   80.69 +           'send_sysrq', 'getVCPUInfo', 'waitForDevices']
   80.70 +
   80.71 +exclude = ['domain_create', 'domain_restore']
   80.72 +
   80.73 +class XMLRPCServer:
   80.74 +    def __init__(self, use_tcp=False):
   80.75 +        self.ready = False
   80.76 +        self.use_tcp = use_tcp
   80.77 +        
   80.78 +    def run(self):
   80.79 +        if self.use_tcp:
   80.80 +            # bind to something fixed for now as we may eliminate
   80.81 +            # tcp support completely.
   80.82 +            self.server = TCPXMLRPCServer(("localhost", 8005), logRequests=False)
   80.83 +        else:
   80.84 +            self.server = UnixXMLRPCServer(XML_RPC_SOCKET, False)
   80.85 +
   80.86 +        # Functions in XendDomainInfo
   80.87 +        for name in methods:
   80.88 +            fn = eval("lambda domid, *args: dispatch(domid, '%s', args)"%name)
   80.89 +            self.server.register_function(fn, "xend.domain.%s" % name)
   80.90 +
   80.91 +        # Functions in XendDomain
   80.92 +        inst = XendDomain.instance()
   80.93 +        for name in dir(inst):
   80.94 +            fn = getattr(inst, name)
   80.95 +            if name.startswith("domain_") and callable(fn):
   80.96 +                if name not in exclude:
   80.97 +                    self.server.register_function(fn, "xend.domain.%s" % name[7:])
   80.98 +
   80.99 +        # Functions in XendNode and XendDmesg
  80.100 +        for type, lst, n in [(XendNode, ['info', 'cpu_bvt_slice_set'], 'node'),
  80.101 +                             (XendDmesg, ['info', 'clear'], 'node.dmesg')]:
  80.102 +            inst = type.instance()
  80.103 +            for name in lst:
  80.104 +                self.server.register_function(getattr(inst, name),
  80.105 +                                              "xend.%s.%s" % (n, name))
  80.106 +
  80.107 +        # A few special cases
  80.108 +        self.server.register_function(domain, 'xend.domain')
  80.109 +        self.server.register_function(domains, 'xend.domains')
  80.110 +        self.server.register_function(get_log, 'xend.node.log')
  80.111 +        self.server.register_function(domain_create, 'xend.domain.create')
  80.112 +        self.server.register_function(domain_restore, 'xend.domain.restore')
  80.113 +
  80.114 +        self.server.register_introspection_functions()
  80.115 +        self.ready = True
  80.116 +        self.server.serve_forever()
    81.1 --- a/tools/python/xen/xend/server/pciif.py	Mon Mar 27 15:36:47 2006 -0700
    81.2 +++ b/tools/python/xen/xend/server/pciif.py	Tue Mar 28 08:54:58 2006 -0700
    81.3 @@ -118,10 +118,12 @@ class PciController(DevController):
    81.4                      "parse it's resources - %s"+str(e))
    81.5  
    81.6          if dev.driver!='pciback':
    81.7 -            raise VmError(("pci: PCI Backend does not own device "+
    81.8 -                    "%s\n"+
    81.9 -                    "See the pciback.hide kernel "+
   81.10 -                    "command-line parameter")%(dev.name))
   81.11 +            raise VmError(("pci: PCI Backend does not own device "+ \
   81.12 +                    "%s\n"+ \
   81.13 +                    "See the pciback.hide kernel "+ \
   81.14 +                    "command-line parameter or\n"+ \
   81.15 +                    "bind your slot/device to the PCI backend using sysfs" \
   81.16 +                    )%(dev.name))
   81.17  
   81.18          for (start, size) in dev.ioports:
   81.19              log.debug('pci: enabling ioport 0x%x/0x%x'%(start,size))
    82.1 --- a/tools/python/xen/xm/create.py	Mon Mar 27 15:36:47 2006 -0700
    82.2 +++ b/tools/python/xen/xm/create.py	Tue Mar 28 08:54:58 2006 -0700
    82.3 @@ -30,7 +30,7 @@ import re
    82.4  
    82.5  from xen.xend import sxp
    82.6  from xen.xend import PrettyPrint
    82.7 -from xen.xend.XendClient import server, XendError
    82.8 +from xen.xend.XendClient import server
    82.9  from xen.xend.XendBootloader import bootloader
   82.10  from xen.util import blkif
   82.11  
   82.12 @@ -813,8 +813,8 @@ def make_domain(opts, config):
   82.13      """
   82.14  
   82.15      try:
   82.16 -        dominfo = server.xend_domain_create(config)
   82.17 -    except XendError, ex:
   82.18 +        dominfo = server.xend.domain.create(config)
   82.19 +    except Exception, ex:
   82.20          import signal
   82.21          if vncpid:
   82.22              os.kill(vncpid, signal.SIGKILL)
   82.23 @@ -822,13 +822,17 @@ def make_domain(opts, config):
   82.24  
   82.25      dom = sxp.child_value(dominfo, 'name')
   82.26  
   82.27 -    if server.xend_domain_wait_for_devices(dom) < 0:
   82.28 -        server.xend_domain_destroy(dom)
   82.29 +    try:
   82.30 +        server.xend.domain.waitForDevices(dom)
   82.31 +    except:
   82.32 +        server.xend.domain.destroy(dom)
   82.33          err("Device creation failed for domain %s" % dom)
   82.34  
   82.35      if not opts.vals.paused:
   82.36 -        if server.xend_domain_unpause(dom) < 0:
   82.37 -            server.xend_domain_destroy(dom)
   82.38 +        try:
   82.39 +            server.xend.domain.unpause(dom)
   82.40 +        except:
   82.41 +            server.xend.domain.destroy(dom)
   82.42              err("Failed to unpause domain %s" % dom)
   82.43      opts.info("Started domain %s" % (dom))
   82.44      return int(sxp.child_value(dominfo, 'domid'))
    83.1 --- a/tools/python/xen/xm/main.py	Mon Mar 27 15:36:47 2006 -0700
    83.2 +++ b/tools/python/xen/xm/main.py	Tue Mar 28 08:54:58 2006 -0700
    83.3 @@ -1,6 +1,6 @@
    83.4  # (C) Copyright IBM Corp. 2005
    83.5  # Copyright (C) 2004 Mike Wray
    83.6 -# Copyright (c) 2005 XenSource Ltd
    83.7 +# Copyright (c) 2005-2006 XenSource Ltd.
    83.8  #
    83.9  # Authors:
   83.10  #     Sean Dague <sean at dague dot net>
   83.11 @@ -29,8 +29,8 @@ import getopt
   83.12  import socket
   83.13  import warnings
   83.14  warnings.filterwarnings('ignore', category=FutureWarning)
   83.15 +import xmlrpclib
   83.16  
   83.17 -import xen.xend.XendError
   83.18  import xen.xend.XendProtocol
   83.19  
   83.20  from xen.xend import PrettyPrint
   83.21 @@ -38,7 +38,8 @@ from xen.xend import sxp
   83.22  from xen.xm.opts import *
   83.23  
   83.24  import console
   83.25 -
   83.26 +import xen.xend.XendClient
   83.27 +from xen.xend.XendClient import server
   83.28  
   83.29  # getopt.gnu_getopt is better, but only exists in Python 2.3+.  Use
   83.30  # getopt.getopt if gnu_getopt is not available.  This will mean that options
   83.31 @@ -319,8 +320,7 @@ def xm_save(args):
   83.32          err("xm save: Unable to create file %s" % savefile)
   83.33          sys.exit(1)
   83.34      
   83.35 -    from xen.xend.XendClient import server
   83.36 -    server.xend_domain_save(dom, savefile)
   83.37 +    server.xend.domain.save(dom, savefile)
   83.38      
   83.39  def xm_restore(args):
   83.40      arg_check(args, "restore", 1)
   83.41 @@ -331,16 +331,14 @@ def xm_restore(args):
   83.42          err("xm restore: Unable to read file %s" % savefile)
   83.43          sys.exit(1)
   83.44  
   83.45 -    from xen.xend.XendClient import server
   83.46 -    server.xend_domain_restore(savefile)
   83.47 +    server.xend.domain.restore(savefile)
   83.48  
   83.49  
   83.50  def getDomains(domain_names):
   83.51 -    from xen.xend.XendClient import server
   83.52      if domain_names:
   83.53 -        return map(server.xend_domain, domain_names)
   83.54 +        return map(server.xend.domain, domain_names)
   83.55      else:
   83.56 -        return server.xend_list_domains()
   83.57 +        return server.xend.domains(1)
   83.58  
   83.59  
   83.60  def xm_list(args):
   83.61 @@ -416,12 +414,11 @@ def xm_brief_list(doms):
   83.62  
   83.63  def xm_vcpu_list(args):
   83.64  
   83.65 -    from xen.xend.XendClient import server
   83.66      if args:
   83.67 -        dominfo = map(server.xend_domain_vcpuinfo, args)
   83.68 +        dominfo = map(server.xend.domain.getVCPUInfo, args)
   83.69      else:
   83.70 -        doms = server.xend_list_domains(False)
   83.71 -        dominfo = map(server.xend_domain_vcpuinfo, doms)
   83.72 +        doms = server.xend.domains(False)
   83.73 +        dominfo = map(server.xend.domain.getVCPUInfo, doms)
   83.74  
   83.75      print 'Name                              ID  VCPU  CPU  State  Time(s)  CPU Affinity'
   83.76  
   83.77 @@ -475,8 +472,7 @@ def xm_vcpu_list(args):
   83.78              cpumap = map(lambda x: int(x), cpumap)
   83.79              cpumap.sort()
   83.80  
   83.81 -            from xen.xend.XendClient import server
   83.82 -            for x in server.xend_node()[1:]:
   83.83 +            for x in server.xend.node.info()[1:]:
   83.84                  if len(x) > 1 and x[0] == 'nr_cpus':
   83.85                      nr_cpus = int(x[1])
   83.86                      # normalize cpumap by modulus nr_cpus, and drop duplicates
   83.87 @@ -532,21 +528,18 @@ def xm_pause(args):
   83.88      arg_check(args, "pause", 1)
   83.89      dom = args[0]
   83.90  
   83.91 -    from xen.xend.XendClient import server
   83.92 -    server.xend_domain_pause(dom)
   83.93 +    server.xend.domain.pause(dom)
   83.94  
   83.95  def xm_unpause(args):
   83.96      arg_check(args, "unpause", 1)
   83.97      dom = args[0]
   83.98  
   83.99 -    from xen.xend.XendClient import server
  83.100 -    server.xend_domain_unpause(dom)
  83.101 +    server.xend.domain.unpause(dom)
  83.102  
  83.103  def xm_rename(args):
  83.104      arg_check(args, "rename", 2)
  83.105  
  83.106 -    from xen.xend.XendClient import server
  83.107 -    server.xend_domain_rename(args[0], args[1])
  83.108 +    server.xend.domain.setName(args[0], args[1])
  83.109  
  83.110  def xm_subcommand(command, args):
  83.111      cmd = __import__(command, globals(), locals(), 'xen.xm')
  83.112 @@ -574,8 +567,7 @@ def xm_vcpu_pin(args):
  83.113      vcpu = int(args[1])
  83.114      cpumap = cpu_make_map(args[2])
  83.115      
  83.116 -    from xen.xend.XendClient import server
  83.117 -    server.xend_domain_pincpu(dom, vcpu, cpumap)
  83.118 +    server.xend.domain.pincpu(dom, vcpu, cpumap)
  83.119  
  83.120  def xm_mem_max(args):
  83.121      arg_check(args, "mem-max", 2)
  83.122 @@ -583,8 +575,7 @@ def xm_mem_max(args):
  83.123      dom = args[0]
  83.124      mem = int_unit(args[1], 'm')
  83.125  
  83.126 -    from xen.xend.XendClient import server
  83.127 -    server.xend_domain_maxmem_set(dom, mem)
  83.128 +    server.xend.domain.maxmem_set(dom, mem)
  83.129      
  83.130  def xm_mem_set(args):
  83.131      arg_check(args, "mem-set", 2)
  83.132 @@ -592,20 +583,17 @@ def xm_mem_set(args):
  83.133      dom = args[0]
  83.134      mem_target = int_unit(args[1], 'm')
  83.135  
  83.136 -    from xen.xend.XendClient import server
  83.137 -    server.xend_domain_mem_target_set(dom, mem_target)
  83.138 +    server.xend.domain.setMemoryTarget(dom, mem_target)
  83.139      
  83.140  def xm_vcpu_set(args):
  83.141      arg_check(args, "vcpu-set", 2)
  83.142      
  83.143 -    from xen.xend.XendClient import server
  83.144 -    server.xend_domain_set_vcpus(args[0], int(args[1]))
  83.145 +    server.xend.domain.setVCpuCount(args[0], int(args[1]))
  83.146  
  83.147  
  83.148  def xm_destroy(args):
  83.149      arg_check(args, "destroy", 1)
  83.150 -    from xen.xend.XendClient import server
  83.151 -    server.xend_domain_destroy(args[0])
  83.152 +    server.xend.domain.destroy(args[0])
  83.153  
  83.154  
  83.155  def xm_domid(args):
  83.156 @@ -613,8 +601,7 @@ def xm_domid(args):
  83.157  
  83.158      name = args[0]
  83.159  
  83.160 -    from xen.xend.XendClient import server
  83.161 -    dom = server.xend_domain(name)
  83.162 +    dom = server.xend.domain(name)
  83.163      print sxp.child_value(dom, 'domid')
  83.164      
  83.165  def xm_domname(args):
  83.166 @@ -622,23 +609,20 @@ def xm_domname(args):
  83.167  
  83.168      name = args[0]
  83.169  
  83.170 -    from xen.xend.XendClient import server
  83.171 -    dom = server.xend_domain(name)
  83.172 +    dom = server.xend.domain(name)
  83.173      print sxp.child_value(dom, 'name')
  83.174  
  83.175  def xm_sched_bvt(args):
  83.176      arg_check(args, "sched-bvt", 6)
  83.177      dom = args[0]
  83.178      v = map(long, args[1:6])
  83.179 -    from xen.xend.XendClient import server
  83.180 -    server.xend_domain_cpu_bvt_set(dom, *v)
  83.181 +    server.xend.domain.cpu_bvt_set(dom, *v)
  83.182  
  83.183  def xm_sched_bvt_ctxallow(args):
  83.184      arg_check(args, "sched-bvt-ctxallow", 1)
  83.185  
  83.186      slice = int(args[0])
  83.187 -    from xen.xend.XendClient import server
  83.188 -    server.xend_node_cpu_bvt_slice_set(slice)
  83.189 +    server.xend.node.cpu_bvt_slice_set(slice)
  83.190  
  83.191  def xm_sched_sedf(args):
  83.192      def ns_to_ms(val):
  83.193 @@ -695,13 +679,12 @@ def xm_sched_sedf(args):
  83.194                                                       'Slice(ms)', 'Lat(ms)',
  83.195                                                       'Extra','Weight')
  83.196  
  83.197 -    from xen.xend.XendClient import server
  83.198      doms = filter(lambda x : domid_match(domid, x),
  83.199                          [parse_doms_info(dom) for dom in getDomains("")])
  83.200      for d in doms:
  83.201          # fetch current values so as not to clobber them
  83.202          sedf_info = \
  83.203 -            parse_sedf_info(server.xend_domain_cpu_sedf_get(d['dom']))
  83.204 +            parse_sedf_info(server.xend.domain.cpu_sedf_get(d['dom']))
  83.205          sedf_info['name'] = d['name']
  83.206  
  83.207          # update values in case of call to set
  83.208 @@ -713,7 +696,7 @@ def xm_sched_sedf(args):
  83.209              v = map(int, [sedf_info['period'], sedf_info['slice'],
  83.210                            sedf_info['latency'],sedf_info['extratime'], 
  83.211                            sedf_info['weight']])
  83.212 -            rv = server.xend_domain_cpu_sedf_set(d['dom'], *v)
  83.213 +            rv = server.xend.domain.cpu_sedf_set(d['dom'], *v)
  83.214              if int(rv) != 0:
  83.215                  err("Failed to set sedf parameters (rv=%d)."%(rv))
  83.216  
  83.217 @@ -725,8 +708,7 @@ def xm_sched_sedf(args):
  83.218  def xm_info(args):
  83.219      arg_check(args, "info", 0)
  83.220  
  83.221 -    from xen.xend.XendClient import server
  83.222 -    info = server.xend_node()
  83.223 +    info = server.xend.node.info()
  83.224      
  83.225      for x in info[1:]:
  83.226          if len(x) < 2: 
  83.227 @@ -738,8 +720,7 @@ def xm_console(args):
  83.228      arg_check(args, "console", 1)
  83.229  
  83.230      dom = args[0]
  83.231 -    from xen.xend.XendClient import server
  83.232 -    info = server.xend_domain(dom)
  83.233 +    info = server.xend.domain(dom)
  83.234      domid = int(sxp.child_value(info, 'domid', '-1'))
  83.235      console.execConsole(domid)
  83.236  
  83.237 @@ -768,17 +749,15 @@ its contents if the [-c|--clear] flag is
  83.238      if not (1 <= len(myargs) <= 2):
  83.239          err('Invalid arguments: ' + str(myargs))
  83.240  
  83.241 -    from xen.xend.XendClient import server
  83.242      if not gopts.vals.clear:
  83.243 -        print server.xend_node_get_dmesg()
  83.244 +        print server.xend.node.dmesg.info()
  83.245      else:
  83.246 -        server.xend_node_clear_dmesg()
  83.247 +        server.xend.node.dmesg.clear()
  83.248  
  83.249  def xm_log(args):
  83.250      arg_check(args, "log", 0)
  83.251      
  83.252 -    from xen.xend.XendClient import server
  83.253 -    print server.xend_node_log()
  83.254 +    print server.xend.node.log()
  83.255  
  83.256  def parse_dev_info(info):
  83.257      def get_info(n, t, d):
  83.258 @@ -826,13 +805,12 @@ def xm_network_list(args):
  83.259          print 'No domain parameter given'
  83.260          sys.exit(1)
  83.261      dom = params[0]
  83.262 -    from xen.xend.XendClient import server
  83.263      if use_long:
  83.264 -        devs = server.xend_domain_devices(dom, 'vif')
  83.265 +        devs = server.xend.domain.getDeviceSxprs(dom, 'vif')
  83.266          map(PrettyPrint.prettyprint, devs)
  83.267      else:
  83.268          hdr = 0
  83.269 -        for x in server.xend_domain_devices(dom, 'vif'):
  83.270 +        for x in server.xend.domain.getDeviceSxprs(dom, 'vif'):
  83.271              if hdr == 0:
  83.272                  print 'Idx BE     MAC Addr.     handle state evt-ch tx-/rx-ring-ref BE-path'
  83.273                  hdr = 1
  83.274 @@ -857,13 +835,12 @@ def xm_block_list(args):
  83.275          print 'No domain parameter given'
  83.276          sys.exit(1)
  83.277      dom = params[0]
  83.278 -    from xen.xend.XendClient import server
  83.279      if use_long:
  83.280 -        devs = server.xend_domain_devices(dom, 'vbd')
  83.281 +        devs = server.xend.domain.getDeviceSxprs(dom, 'vbd')
  83.282          map(PrettyPrint.prettyprint, devs)
  83.283      else:
  83.284          hdr = 0
  83.285 -        for x in server.xend_domain_devices(dom, 'vbd'):
  83.286 +        for x in server.xend.domain.getDeviceSxprs(dom, 'vbd'):
  83.287              if hdr == 0:
  83.288                  print 'Vdev  BE handle state evt-ch ring-ref BE-path'
  83.289                  hdr = 1
  83.290 @@ -887,13 +864,12 @@ def xm_vtpm_list(args):
  83.291          print 'No domain parameter given'
  83.292          sys.exit(1)
  83.293      dom = params[0]
  83.294 -    from xen.xend.XendClient import server
  83.295      if use_long:
  83.296 -        devs = server.xend_domain_devices(dom, 'vtpm')
  83.297 +        devs = server.xend.domain.getDeviceSxprs(dom, 'vtpm')
  83.298          map(PrettyPrint.prettyprint, devs)
  83.299      else:
  83.300          hdr = 0
  83.301 -        for x in server.xend_domain_devices(dom, 'vtpm'):
  83.302 +        for x in server.xend.domain.getDeviceSxprs(dom, 'vtpm'):
  83.303              if hdr == 0:
  83.304                  print 'Idx  BE handle state evt-ch ring-ref BE-path'
  83.305                  hdr = 1
  83.306 @@ -919,8 +895,7 @@ def xm_block_attach(args):
  83.307      if len(args) == 5:
  83.308          vbd.append(['backend', args[4]])
  83.309  
  83.310 -    from xen.xend.XendClient import server
  83.311 -    server.xend_domain_device_create(dom, vbd)
  83.312 +    server.xend.domain.device_create(dom, vbd)
  83.313  
  83.314  
  83.315  def xm_network_attach(args):
  83.316 @@ -932,8 +907,7 @@ def xm_network_attach(args):
  83.317      for a in args[1:]:
  83.318          vif.append(a.split("="))
  83.319  
  83.320 -    from xen.xend.XendClient import server
  83.321 -    server.xend_domain_device_create(dom, vif)
  83.322 +    server.xend.domain.device_create(dom, vif)
  83.323  
  83.324  
  83.325  def detach(args, command, deviceClass):
  83.326 @@ -942,8 +916,7 @@ def detach(args, command, deviceClass):
  83.327      dom = args[0]
  83.328      dev = args[1]
  83.329  
  83.330 -    from xen.xend.XendClient import server
  83.331 -    server.xend_domain_device_destroy(dom, deviceClass, dev)
  83.332 +    server.xend.domain.destroyDevice(dom, deviceClass, dev)
  83.333  
  83.334  
  83.335  def xm_block_detach(args):
  83.336 @@ -955,7 +928,6 @@ def xm_network_detach(args):
  83.337  
  83.338  
  83.339  def xm_vnet_list(args):
  83.340 -    from xen.xend.XendClient import server
  83.341      try:
  83.342          (options, params) = getopt.gnu_getopt(args, 'l', ['long'])
  83.343      except getopt.GetoptError, opterr:
  83.344 @@ -990,13 +962,11 @@ def xm_vnet_create(args):
  83.345          print "File not found: %s" % conf
  83.346          sys.exit(1)
  83.347  
  83.348 -    from xen.xend.XendClient import server
  83.349      server.xend_vnet_create(conf)
  83.350  
  83.351  def xm_vnet_delete(args):
  83.352      arg_check(args, "vnet-delete", 1)
  83.353      vnet = args[0]
  83.354 -    from xen.xend.XendClient import server
  83.355      server.xend_vnet_delete(vnet)
  83.356  
  83.357  commands = {
  83.358 @@ -1132,23 +1102,13 @@ def main(argv=sys.argv):
  83.359              else:
  83.360                  err("Error connecting to xend: %s." % ex[1])
  83.361              sys.exit(1)
  83.362 -        except xen.xend.XendError.XendError, ex:
  83.363 -            if len(args) > 0:
  83.364 -                handle_xend_error(argv[1], args, ex)
  83.365 +        except SystemExit:
  83.366 +            sys.exit(1)
  83.367 +        except xmlrpclib.Fault, ex:
  83.368 +            if ex.faultCode == xen.xend.XendClient.ERROR_INVALID_DOMAIN:
  83.369 +                print "Error: the domain '%s' does not exist." % ex.faultString
  83.370              else:
  83.371 -                print "Unexpected error:", sys.exc_info()[0]
  83.372 -                print
  83.373 -                print "Please report to xen-devel@lists.xensource.com"
  83.374 -                raise
  83.375 -        except xen.xend.XendProtocol.XendError, ex:
  83.376 -            if len(args) > 0:
  83.377 -                handle_xend_error(argv[1], args, ex)
  83.378 -            else:
  83.379 -                print "Unexpected error:", sys.exc_info()[0]
  83.380 -                print
  83.381 -                print "Please report to xen-devel@lists.xensource.com"
  83.382 -                raise
  83.383 -        except SystemExit:
  83.384 +                print "Error: %s" % ex.faultString
  83.385              sys.exit(1)
  83.386          except:
  83.387              print "Unexpected error:", sys.exc_info()[0]
    84.1 --- a/tools/python/xen/xm/migrate.py	Mon Mar 27 15:36:47 2006 -0700
    84.2 +++ b/tools/python/xen/xm/migrate.py	Tue Mar 28 08:54:58 2006 -0700
    84.3 @@ -60,4 +60,4 @@ def main(argv):
    84.4          opts.err('Invalid arguments: ' + str(args))
    84.5      dom = args[0]
    84.6      dst = args[1]
    84.7 -    server.xend_domain_migrate(dom, dst, opts.vals.live, opts.vals.resource, opts.vals.port)
    84.8 +    server.xend.domain.migrate(dom, dst, opts.vals.live, opts.vals.resource, opts.vals.port)
    85.1 --- a/tools/python/xen/xm/shutdown.py	Mon Mar 27 15:36:47 2006 -0700
    85.2 +++ b/tools/python/xen/xm/shutdown.py	Tue Mar 28 08:54:58 2006 -0700
    85.3 @@ -53,8 +53,8 @@ gopts.opt('reboot', short='R',
    85.4            use='Shutdown and reboot.')
    85.5  
    85.6  def shutdown(opts, doms, mode, wait):
    85.7 -    if doms == None: doms = server.xend_domains()
    85.8 -    dom0_name = sxp.child_value(server.xend_domain(0), 'name')
    85.9 +    if doms == None: doms = server.xend.domains(0)
   85.10 +    dom0_name = sxp.child_value(server.xend.domain(0), 'name')
   85.11      for x in [dom0_name, DOM0_ID]:
   85.12          if x in doms:
   85.13              if opts.vals.all:
   85.14 @@ -62,10 +62,10 @@ def shutdown(opts, doms, mode, wait):
   85.15              else:
   85.16                  opts.err("Can't specify Domain-0")
   85.17      for d in doms:
   85.18 -        server.xend_domain_shutdown(d, mode)
   85.19 +        server.xend.domain.shutdown(d, mode)
   85.20      if wait:
   85.21          while doms:
   85.22 -            alive = server.xend_domains()
   85.23 +            alive = server.xend.domains(0)
   85.24              dead = []
   85.25              for d in doms:
   85.26                  if d in alive: continue
    86.1 --- a/tools/python/xen/xm/sysrq.py	Mon Mar 27 15:36:47 2006 -0700
    86.2 +++ b/tools/python/xen/xm/sysrq.py	Tue Mar 28 08:54:58 2006 -0700
    86.3 @@ -28,4 +28,4 @@ def main(argv):
    86.4      if len(args) < 2: opts.err('Missing sysrq character')
    86.5      dom = args[0]
    86.6      req = ord(args[1][0])
    86.7 -    server.xend_domain_sysrq(dom, req)
    86.8 +    server.xend.domain.send_sysrq(dom, req)
    87.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    87.2 +++ b/tools/xenstore/README	Tue Mar 28 08:54:58 2006 -0700
    87.3 @@ -0,0 +1,5 @@
    87.4 +The following files are imported from the Samba project.  We use the versions
    87.5 +from Samba 3, the current stable branch.
    87.6 +
    87.7 +talloc.c: samba-trunk/source/lib/talloc.c     r14291 2006-03-13 04:27:47 +0000
    87.8 +talloc.h: samba-trunk/source/include/talloc.h r11986 2005-12-01 00:43:36 +0000
    88.1 --- a/tools/xenstore/talloc.c	Mon Mar 27 15:36:47 2006 -0700
    88.2 +++ b/tools/xenstore/talloc.c	Tue Mar 28 08:54:58 2006 -0700
    88.3 @@ -1,4 +1,4 @@
    88.4 -/* 
    88.5 +/*
    88.6     Samba Unix SMB/CIFS implementation.
    88.7  
    88.8     Samba trivial allocation library - new interface
    88.9 @@ -6,27 +6,30 @@
   88.10     NOTE: Please read talloc_guide.txt for full documentation
   88.11  
   88.12     Copyright (C) Andrew Tridgell 2004
   88.13 -   
   88.14 -   This program is free software; you can redistribute it and/or modify
   88.15 -   it under the terms of the GNU General Public License as published by
   88.16 -   the Free Software Foundation; either version 2 of the License, or
   88.17 -   (at your option) any later version.
   88.18 -   
   88.19 -   This program is distributed in the hope that it will be useful,
   88.20 +
   88.21 +     ** NOTE! The following LGPL license applies to the talloc
   88.22 +     ** library. This does NOT imply that all of Samba is released
   88.23 +     ** under the LGPL
   88.24 +
   88.25 +   This library is free software; you can redistribute it and/or
   88.26 +   modify it under the terms of the GNU Lesser General Public
   88.27 +   License as published by the Free Software Foundation; either
   88.28 +   version 2 of the License, or (at your option) any later version.
   88.29 +
   88.30 +   This library is distributed in the hope that it will be useful,
   88.31     but WITHOUT ANY WARRANTY; without even the implied warranty of
   88.32 -   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   88.33 -   GNU General Public License for more details.
   88.34 -   
   88.35 -   You should have received a copy of the GNU General Public License
   88.36 -   along with this program; if not, write to the Free Software
   88.37 -   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   88.38 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   88.39 +   Lesser General Public License for more details.
   88.40 +
   88.41 +   You should have received a copy of the GNU Lesser General Public
   88.42 +   License along with this library; if not, write to the Free Software
   88.43 +   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   88.44  */
   88.45  
   88.46  /*
   88.47    inspired by http://swapped.cc/halloc/
   88.48  */
   88.49  
   88.50 -
   88.51  #ifdef _SAMBA_BUILD_
   88.52  #include "includes.h"
   88.53  #if ((SAMBA_VERSION_MAJOR==3)&&(SAMBA_VERSION_MINOR<9))
   88.54 @@ -52,15 +55,13 @@
   88.55  
   88.56  /* use this to force every realloc to change the pointer, to stress test
   88.57     code that might not cope */
   88.58 -#ifdef TESTING
   88.59 -#define ALWAYS_REALLOC 1
   88.60 -void *test_malloc(size_t size);
   88.61 -#define malloc test_malloc
   88.62 -#endif
   88.63 +#define ALWAYS_REALLOC 0
   88.64 +
   88.65  
   88.66  #define MAX_TALLOC_SIZE 0x10000000
   88.67 -#define TALLOC_MAGIC 0xe814ec4f
   88.68 -#define TALLOC_MAGIC_FREE 0x7faebef3
   88.69 +#define TALLOC_MAGIC 0xe814ec70
   88.70 +#define TALLOC_FLAG_FREE 0x01
   88.71 +#define TALLOC_FLAG_LOOP 0x02
   88.72  #define TALLOC_MAGIC_REFERENCE ((const char *)1)
   88.73  
   88.74  /* by default we abort when given a bad pointer (such as when talloc_free() is called 
   88.75 @@ -83,8 +84,7 @@ void *test_malloc(size_t size);
   88.76  */
   88.77  static const void *null_context;
   88.78  static void *cleanup_context;
   88.79 -static int (*malloc_fail_handler)(void *);
   88.80 -static void *malloc_fail_data;
   88.81 +
   88.82  
   88.83  struct talloc_reference_handle {
   88.84  	struct talloc_reference_handle *next, *prev;
   88.85 @@ -97,24 +97,27 @@ struct talloc_chunk {
   88.86  	struct talloc_chunk *next, *prev;
   88.87  	struct talloc_chunk *parent, *child;
   88.88  	struct talloc_reference_handle *refs;
   88.89 -	size_t size;
   88.90 -	unsigned magic;
   88.91  	talloc_destructor_t destructor;
   88.92  	const char *name;
   88.93 +	size_t size;
   88.94 +	unsigned flags;
   88.95  };
   88.96  
   88.97 +/* 16 byte alignment seems to keep everyone happy */
   88.98 +#define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
   88.99 +#define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
  88.100 +
  88.101  /* panic if we get a bad magic value */
  88.102  static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
  88.103  {
  88.104 -	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, ptr)-1;
  88.105 -	if (tc->magic != TALLOC_MAGIC) { 
  88.106 -		if (tc->magic == TALLOC_MAGIC_FREE) {
  88.107 -			TALLOC_ABORT("Bad talloc magic value - double free"); 
  88.108 -		} else {
  88.109 -			TALLOC_ABORT("Bad talloc magic value - unknown value"); 
  88.110 -		}
  88.111 +	const char *pp = ptr;
  88.112 +	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
  88.113 +	if ((tc->flags & ~0xF) != TALLOC_MAGIC) { 
  88.114 +		TALLOC_ABORT("Bad talloc magic value - unknown value"); 
  88.115  	}
  88.116 -
  88.117 +	if (tc->flags & TALLOC_FLAG_FREE) {
  88.118 +		TALLOC_ABORT("Bad talloc magic value - double free"); 
  88.119 +	}
  88.120  	return tc;
  88.121  }
  88.122  
  88.123 @@ -159,7 +162,7 @@ static struct talloc_chunk *talloc_paren
  88.124  void *talloc_parent(const void *ptr)
  88.125  {
  88.126  	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
  88.127 -	return (void *)(tc+1);
  88.128 +	return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
  88.129  }
  88.130  
  88.131  /* 
  88.132 @@ -177,17 +180,11 @@ void *_talloc(const void *context, size_
  88.133  		return NULL;
  88.134  	}
  88.135  
  88.136 -	tc = malloc(sizeof(*tc)+size);
  88.137 -	if (tc == NULL) {
  88.138 -		if (malloc_fail_handler)
  88.139 -			if (malloc_fail_handler(malloc_fail_data))
  88.140 -				tc = malloc(sizeof(*tc)+size);
  88.141 -		if (!tc)
  88.142 -			return NULL;
  88.143 -	}
  88.144 +	tc = malloc(TC_HDR_SIZE+size);
  88.145 +	if (tc == NULL) return NULL;
  88.146  
  88.147  	tc->size = size;
  88.148 -	tc->magic = TALLOC_MAGIC;
  88.149 +	tc->flags = TALLOC_MAGIC;
  88.150  	tc->destructor = NULL;
  88.151  	tc->child = NULL;
  88.152  	tc->name = NULL;
  88.153 @@ -207,7 +204,7 @@ void *_talloc(const void *context, size_
  88.154  		tc->next = tc->prev = tc->parent = NULL;
  88.155  	}
  88.156  
  88.157 -	return (void *)(tc+1);
  88.158 +	return TC_PTR_FROM_CHUNK(tc);
  88.159  }
  88.160  
  88.161  
  88.162 @@ -292,7 +289,11 @@ static int talloc_unreference(const void
  88.163  
  88.164  	for (h=tc->refs;h;h=h->next) {
  88.165  		struct talloc_chunk *p = talloc_parent_chunk(h);
  88.166 -		if ((p==NULL && context==NULL) || p+1 == context) break;
  88.167 +		if (p == NULL) {
  88.168 +			if (context == NULL) break;
  88.169 +		} else if (TC_PTR_FROM_CHUNK(p) == context) {
  88.170 +			break;
  88.171 +		}
  88.172  	}
  88.173  	if (h == NULL) {
  88.174  		return -1;
  88.175 @@ -343,7 +344,7 @@ int talloc_unlink(const void *context, v
  88.176  
  88.177  	new_p = talloc_parent_chunk(tc_p->refs);
  88.178  	if (new_p) {
  88.179 -		new_parent = new_p+1;
  88.180 +		new_parent = TC_PTR_FROM_CHUNK(new_p);
  88.181  	} else {
  88.182  		new_parent = NULL;
  88.183  	}
  88.184 @@ -471,6 +472,8 @@ void *talloc_init(const char *fmt, ...)
  88.185  	va_list ap;
  88.186  	void *ptr;
  88.187  
  88.188 +	talloc_enable_null_tracking();
  88.189 +
  88.190  	ptr = _talloc(NULL, 0);
  88.191  	if (ptr == NULL) return NULL;
  88.192  
  88.193 @@ -502,16 +505,16 @@ void talloc_free_children(void *ptr)
  88.194  		   choice is owner of any remaining reference to this
  88.195  		   pointer, the second choice is our parent, and the
  88.196  		   final choice is the null context. */
  88.197 -		void *child = tc->child+1;
  88.198 +		void *child = TC_PTR_FROM_CHUNK(tc->child);
  88.199  		const void *new_parent = null_context;
  88.200  		if (tc->child->refs) {
  88.201  			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
  88.202 -			if (p) new_parent = p+1;
  88.203 +			if (p) new_parent = TC_PTR_FROM_CHUNK(p);
  88.204  		}
  88.205  		if (talloc_free(child) == -1) {
  88.206  			if (new_parent == null_context) {
  88.207  				struct talloc_chunk *p = talloc_parent_chunk(ptr);
  88.208 -				if (p) new_parent = p+1;
  88.209 +				if (p) new_parent = TC_PTR_FROM_CHUNK(p);
  88.210  			}
  88.211  			talloc_steal(new_parent, child);
  88.212  		}
  88.213 @@ -541,6 +544,11 @@ int talloc_free(void *ptr)
  88.214  		return -1;
  88.215  	}
  88.216  
  88.217 +	if (tc->flags & TALLOC_FLAG_LOOP) {
  88.218 +		/* we have a free loop - stop looping */
  88.219 +		return 0;
  88.220 +	}
  88.221 +
  88.222  	if (tc->destructor) {
  88.223  		talloc_destructor_t d = tc->destructor;
  88.224  		if (d == (talloc_destructor_t)-1) {
  88.225 @@ -554,6 +562,8 @@ int talloc_free(void *ptr)
  88.226  		tc->destructor = NULL;
  88.227  	}
  88.228  
  88.229 +	tc->flags |= TALLOC_FLAG_LOOP;
  88.230 +
  88.231  	talloc_free_children(ptr);
  88.232  
  88.233  	if (tc->parent) {
  88.234 @@ -566,7 +576,7 @@ int talloc_free(void *ptr)
  88.235  		if (tc->next) tc->next->prev = tc->prev;
  88.236  	}
  88.237  
  88.238 -	tc->magic = TALLOC_MAGIC_FREE;
  88.239 +	tc->flags |= TALLOC_FLAG_FREE;
  88.240  
  88.241  	free(tc);
  88.242  	return 0;
  88.243 @@ -606,36 +616,24 @@ void *_talloc_realloc(const void *contex
  88.244  	}
  88.245  
  88.246  	/* by resetting magic we catch users of the old memory */
  88.247 -	tc->magic = TALLOC_MAGIC_FREE;
  88.248 +	tc->flags |= TALLOC_FLAG_FREE;
  88.249  
  88.250  #if ALWAYS_REALLOC
  88.251 -	new_ptr = malloc(size + sizeof(*tc));
  88.252 -	if (!new_ptr) {
  88.253 -		tc->magic = TALLOC_MAGIC; 
  88.254 -		if (malloc_fail_handler)
  88.255 -			if (malloc_fail_handler(malloc_fail_data))
  88.256 -				new_ptr = malloc(size + sizeof(*tc));
  88.257 -	}
  88.258 +	new_ptr = malloc(size + TC_HDR_SIZE);
  88.259  	if (new_ptr) {
  88.260 -		memcpy(new_ptr, tc, tc->size + sizeof(*tc));
  88.261 +		memcpy(new_ptr, tc, tc->size + TC_HDR_SIZE);
  88.262  		free(tc);
  88.263  	}
  88.264  #else
  88.265 -	new_ptr = realloc(tc, size + sizeof(*tc));
  88.266 -	if (!new_ptr) {
  88.267 -		tc->magic = TALLOC_MAGIC; 
  88.268 -		if (malloc_fail_handler)
  88.269 -			if (malloc_fail_handler(malloc_fail_data))
  88.270 -				new_ptr = realloc(tc, size + sizeof(*tc));
  88.271 -	}
  88.272 +	new_ptr = realloc(tc, size + TC_HDR_SIZE);
  88.273  #endif
  88.274  	if (!new_ptr) {	
  88.275 -		tc->magic = TALLOC_MAGIC; 
  88.276 +		tc->flags &= ~TALLOC_FLAG_FREE; 
  88.277  		return NULL; 
  88.278  	}
  88.279  
  88.280  	tc = new_ptr;
  88.281 -	tc->magic = TALLOC_MAGIC;
  88.282 +	tc->flags &= ~TALLOC_FLAG_FREE; 
  88.283  	if (tc->parent) {
  88.284  		tc->parent->child = new_ptr;
  88.285  	}
  88.286 @@ -651,9 +649,9 @@ void *_talloc_realloc(const void *contex
  88.287  	}
  88.288  
  88.289  	tc->size = size;
  88.290 -	talloc_set_name_const(tc+1, name);
  88.291 +	talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
  88.292  
  88.293 -	return (void *)(tc+1);
  88.294 +	return TC_PTR_FROM_CHUNK(tc);
  88.295  }
  88.296  
  88.297  /* 
  88.298 @@ -730,10 +728,19 @@ off_t talloc_total_size(const void *ptr)
  88.299  
  88.300  	tc = talloc_chunk_from_ptr(ptr);
  88.301  
  88.302 +	if (tc->flags & TALLOC_FLAG_LOOP) {
  88.303 +		return 0;
  88.304 +	}
  88.305 +
  88.306 +	tc->flags |= TALLOC_FLAG_LOOP;
  88.307 +
  88.308  	total = tc->size;
  88.309  	for (c=tc->child;c;c=c->next) {
  88.310 -		total += talloc_total_size(c+1);
  88.311 +		total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
  88.312  	}
  88.313 +
  88.314 +	tc->flags &= ~TALLOC_FLAG_LOOP;
  88.315 +
  88.316  	return total;
  88.317  }
  88.318  
  88.319 @@ -743,20 +750,21 @@ off_t talloc_total_size(const void *ptr)
  88.320  off_t talloc_total_blocks(const void *ptr)
  88.321  {
  88.322  	off_t total = 0;
  88.323 -	struct talloc_chunk *c, *tc;
  88.324 +	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
  88.325  
  88.326 -	if (ptr == NULL) {
  88.327 -		ptr = null_context;
  88.328 -	}
  88.329 -	if (ptr == NULL) {
  88.330 +	if (tc->flags & TALLOC_FLAG_LOOP) {
  88.331  		return 0;
  88.332  	}
  88.333 -	tc = talloc_chunk_from_ptr(ptr);
  88.334 +
  88.335 +	tc->flags |= TALLOC_FLAG_LOOP;
  88.336  
  88.337  	total++;
  88.338  	for (c=tc->child;c;c=c->next) {
  88.339 -		total += talloc_total_blocks(c+1);
  88.340 +		total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
  88.341  	}
  88.342 +
  88.343 +	tc->flags &= ~TALLOC_FLAG_LOOP;
  88.344 +
  88.345  	return total;
  88.346  }
  88.347  
  88.348 @@ -782,23 +790,29 @@ void talloc_report_depth(const void *ptr
  88.349  {
  88.350  	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
  88.351  
  88.352 +	if (tc->flags & TALLOC_FLAG_LOOP) {
  88.353 +		return;
  88.354 +	}
  88.355 +
  88.356 +	tc->flags |= TALLOC_FLAG_LOOP;
  88.357 +
  88.358  	for (c=tc->child;c;c=c->next) {
  88.359  		if (c->name == TALLOC_MAGIC_REFERENCE) {
  88.360 -			struct talloc_reference_handle *handle = (void *)(c+1);
  88.361 +			struct talloc_reference_handle *handle = TC_PTR_FROM_CHUNK(c);
  88.362  			const char *name2 = talloc_get_name(handle->ptr);
  88.363  			fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
  88.364  		} else {
  88.365 -			const char *name = talloc_get_name(c+1);
  88.366 +			const char *name = talloc_get_name(TC_PTR_FROM_CHUNK(c));
  88.367  			fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
  88.368  				depth*4, "",
  88.369  				name,
  88.370 -				(unsigned long)talloc_total_size(c+1),
  88.371 -				(unsigned long)talloc_total_blocks(c+1),
  88.372 -				talloc_reference_count(c+1));
  88.373 -			talloc_report_depth(c+1, f, depth+1);
  88.374 +				(unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
  88.375 +				(unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)),
  88.376 +				talloc_reference_count(TC_PTR_FROM_CHUNK(c)));
  88.377 +			talloc_report_depth(TC_PTR_FROM_CHUNK(c), f, depth+1);
  88.378  		}
  88.379  	}
  88.380 -
  88.381 +	tc->flags &= ~TALLOC_FLAG_LOOP;
  88.382  }
  88.383  
  88.384  /*
  88.385 @@ -841,9 +855,9 @@ void talloc_report(const void *ptr, FILE
  88.386  
  88.387  	for (c=tc->child;c;c=c->next) {
  88.388  		fprintf(f, "\t%-30s contains %6lu bytes in %3lu blocks\n", 
  88.389 -			talloc_get_name(c+1),
  88.390 -			(unsigned long)talloc_total_size(c+1),
  88.391 -			(unsigned long)talloc_total_blocks(c+1));
  88.392 +			talloc_get_name(TC_PTR_FROM_CHUNK(c)),
  88.393 +			(unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
  88.394 +			(unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)));
  88.395  	}
  88.396  	fflush(f);
  88.397  }
  88.398 @@ -878,6 +892,74 @@ void talloc_enable_null_tracking(void)
  88.399  	}
  88.400  }
  88.401  
  88.402 +#ifdef _SAMBA_BUILD_
  88.403 +/* Ugly calls to Samba-specific sprintf_append... JRA. */
  88.404 +
  88.405 +/*
  88.406 +  report on memory usage by all children of a pointer, giving a full tree view
  88.407 +*/
  88.408 +static void talloc_report_depth_str(const void *ptr, char **pps, ssize_t *plen, size_t *pbuflen, int depth)
  88.409 +{
  88.410 +	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
  88.411 +
  88.412 +	if (tc->flags & TALLOC_FLAG_LOOP) {
  88.413 +		return;
  88.414 +	}
  88.415 +
  88.416 +	tc->flags |= TALLOC_FLAG_LOOP;
  88.417 +
  88.418 +	for (c=tc->child;c;c=c->next) {
  88.419 +		if (c->name == TALLOC_MAGIC_REFERENCE) {
  88.420 +			struct talloc_reference_handle *handle = TC_PTR_FROM_CHUNK(c);
  88.421 +			const char *name2 = talloc_get_name(handle->ptr);
  88.422 +
  88.423 +			sprintf_append(NULL, pps, plen, pbuflen,
  88.424 +				"%*sreference to: %s\n", depth*4, "", name2);
  88.425 +
  88.426 +		} else {
  88.427 +			const char *name = talloc_get_name(TC_PTR_FROM_CHUNK(c));
  88.428 +
  88.429 +			sprintf_append(NULL, pps, plen, pbuflen,
  88.430 +				"%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
  88.431 +				depth*4, "",
  88.432 +				name,
  88.433 +				(unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
  88.434 +				(unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)),
  88.435 +				talloc_reference_count(TC_PTR_FROM_CHUNK(c)));
  88.436 +
  88.437 +			talloc_report_depth_str(TC_PTR_FROM_CHUNK(c), pps, plen, pbuflen, depth+1);
  88.438 +		}
  88.439 +	}
  88.440 +	tc->flags &= ~TALLOC_FLAG_LOOP;
  88.441 +}
  88.442 +
  88.443 +/*
  88.444 +  report on memory usage by all children of a pointer
  88.445 +*/
  88.446 +char *talloc_describe_all(void)
  88.447 +{
  88.448 +	ssize_t len = 0;
  88.449 +	size_t buflen = 512;
  88.450 +	char *s = NULL;
  88.451 +
  88.452 +	if (null_context == NULL) {
  88.453 +		return NULL;
  88.454 +	}
  88.455 +
  88.456 +	sprintf_append(NULL, &s, &len, &buflen,
  88.457 +		"full talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
  88.458 +		talloc_get_name(null_context), 
  88.459 +		(unsigned long)talloc_total_size(null_context),
  88.460 +		(unsigned long)talloc_total_blocks(null_context));
  88.461 +
  88.462 +	if (!s) {
  88.463 +		return NULL;
  88.464 +	}
  88.465 +	talloc_report_depth_str(null_context, &s, &len, &buflen, 1);
  88.466 +	return s;
  88.467 +}
  88.468 +#endif
  88.469 +
  88.470  /*
  88.471    enable leak reporting on exit
  88.472  */
  88.473 @@ -942,6 +1024,30 @@ char *talloc_strdup(const void *t, const
  88.474  }
  88.475  
  88.476  /*
  88.477 + append to a talloced string 
  88.478 +*/
  88.479 +char *talloc_append_string(const void *t, char *orig, const char *append)
  88.480 +{
  88.481 +	char *ret;
  88.482 +	size_t olen = strlen(orig);
  88.483 +	size_t alenz;
  88.484 +
  88.485 +	if (!append)
  88.486 +		return orig;
  88.487 +
  88.488 +	alenz = strlen(append) + 1;
  88.489 +
  88.490 +	ret = talloc_realloc(t, orig, char, olen + alenz);
  88.491 +	if (!ret)
  88.492 +		return NULL;
  88.493 +
  88.494 +	/* append the string with the trailing \0 */
  88.495 +	memcpy(&ret[olen], append, alenz);
  88.496 +
  88.497 +	return ret;
  88.498 +}
  88.499 +
  88.500 +/*
  88.501    strndup with a talloc 
  88.502  */
  88.503  char *talloc_strndup(const void *t, const char *p, size_t n)
  88.504 @@ -949,7 +1055,7 @@ char *talloc_strndup(const void *t, cons
  88.505  	size_t len;
  88.506  	char *ret;
  88.507  
  88.508 -	for (len=0; p[len] && len<n; len++) ;
  88.509 +	for (len=0; len<n && p[len]; len++) ;
  88.510  
  88.511  	ret = _talloc(t, len + 1);
  88.512  	if (!ret) { return NULL; }
  88.513 @@ -974,10 +1080,14 @@ char *talloc_vasprintf(const void *t, co
  88.514  	int len;
  88.515  	char *ret;
  88.516  	va_list ap2;
  88.517 +	char c;
  88.518  	
  88.519  	VA_COPY(ap2, ap);
  88.520  
  88.521 -	len = vsnprintf(NULL, 0, fmt, ap2);
  88.522 +	/* this call looks strange, but it makes it work on older solaris boxes */
  88.523 +	if ((len = vsnprintf(&c, 1, fmt, ap2)) < 0) {
  88.524 +		return NULL;
  88.525 +	}
  88.526  
  88.527  	ret = _talloc(t, len+1);
  88.528  	if (ret) {
  88.529 @@ -1029,7 +1139,15 @@ static char *talloc_vasprintf_append(cha
  88.530  	VA_COPY(ap2, ap);
  88.531  
  88.532  	s_len = tc->size - 1;
  88.533 -	len = vsnprintf(NULL, 0, fmt, ap2);
  88.534 +	if ((len = vsnprintf(NULL, 0, fmt, ap2)) <= 0) {
  88.535 +		/* Either the vsnprintf failed or the format resulted in
  88.536 +		 * no characters being formatted. In the former case, we
  88.537 +		 * ought to return NULL, in the latter we ought to return
  88.538 +		 * the original string. Most current callers of this 
  88.539 +		 * function expect it to never return NULL.
  88.540 +		 */
  88.541 +		return s;
  88.542 +	}
  88.543  
  88.544  	s = talloc_realloc(NULL, s, char, s_len + len+1);
  88.545  	if (!s) return NULL;
  88.546 @@ -1133,11 +1251,45 @@ size_t talloc_get_size(const void *conte
  88.547  	return tc->size;
  88.548  }
  88.549  
  88.550 -talloc_fail_handler *talloc_set_fail_handler(talloc_fail_handler *handler,
  88.551 -					     void *data)
  88.552 +/*
  88.553 +  find a parent of this context that has the given name, if any
  88.554 +*/
  88.555 +void *talloc_find_parent_byname(const void *context, const char *name)
  88.556  {
  88.557 -	talloc_fail_handler *old = malloc_fail_handler;
  88.558 -	malloc_fail_handler = handler;
  88.559 -	malloc_fail_data = data;
  88.560 -	return old;
  88.561 +	struct talloc_chunk *tc;
  88.562 +
  88.563 +	if (context == NULL) {
  88.564 +		return NULL;
  88.565 +	}
  88.566 +
  88.567 +	tc = talloc_chunk_from_ptr(context);
  88.568 +	while (tc) {
  88.569 +		if (tc->name && strcmp(tc->name, name) == 0) {
  88.570 +			return TC_PTR_FROM_CHUNK(tc);
  88.571 +		}
  88.572 +		while (tc && tc->prev) tc = tc->prev;
  88.573 +		tc = tc->parent;
  88.574 +	}
  88.575 +	return NULL;
  88.576  }
  88.577 +
  88.578 +/*
  88.579 +  show the parentage of a context
  88.580 +*/
  88.581 +void talloc_show_parents(const void *context, FILE *file)
  88.582 +{
  88.583 +	struct talloc_chunk *tc;
  88.584 +
  88.585 +	if (context == NULL) {
  88.586 +		fprintf(file, "talloc no parents for NULL\n");
  88.587 +		return;
  88.588 +	}
  88.589 +
  88.590 +	tc = talloc_chunk_from_ptr(context);
  88.591 +	fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
  88.592 +	while (tc) {
  88.593 +		fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
  88.594 +		while (tc && tc->prev) tc = tc->prev;
  88.595 +		tc = tc->parent;
  88.596 +	}
  88.597 +}
    89.1 --- a/tools/xenstore/talloc.h	Mon Mar 27 15:36:47 2006 -0700
    89.2 +++ b/tools/xenstore/talloc.h	Tue Mar 28 08:54:58 2006 -0700
    89.3 @@ -6,19 +6,23 @@
    89.4  
    89.5     Copyright (C) Andrew Tridgell 2004-2005
    89.6     
    89.7 -   This program is free software; you can redistribute it and/or modify
    89.8 -   it under the terms of the GNU General Public License as published by
    89.9 -   the Free Software Foundation; either version 2 of the License, or
   89.10 -   (at your option) any later version.
   89.11 +     ** NOTE! The following LGPL license applies to the talloc
   89.12 +     ** library. This does NOT imply that all of Samba is released
   89.13 +     ** under the LGPL
   89.14     
   89.15 -   This program is distributed in the hope that it will be useful,
   89.16 +   This library is free software; you can redistribute it and/or
   89.17 +   modify it under the terms of the GNU Lesser General Public
   89.18 +   License as published by the Free Software Foundation; either
   89.19 +   version 2 of the License, or (at your option) any later version.
   89.20 +
   89.21 +   This library is distributed in the hope that it will be useful,
   89.22     but WITHOUT ANY WARRANTY; without even the implied warranty of
   89.23 -   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   89.24 -   GNU General Public License for more details.
   89.25 -   
   89.26 -   You should have received a copy of the GNU General Public License
   89.27 -   along with this program; if not, write to the Free Software
   89.28 -   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   89.29 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   89.30 +   Lesser General Public License for more details.
   89.31 +
   89.32 +   You should have received a copy of the GNU Lesser General Public
   89.33 +   License along with this library; if not, write to the Free Software
   89.34 +   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   89.35  */
   89.36  
   89.37  /* this is only needed for compatibility with the old talloc */
   89.38 @@ -58,13 +62,18 @@ typedef void TALLOC_CTX;
   89.39  #define malloc_array_p(type, count) (type *)realloc_array(NULL, sizeof(type), count)
   89.40  #define realloc_p(p, type, count) (type *)realloc_array(p, sizeof(type), count)
   89.41  
   89.42 +#if 0 
   89.43 +/* Not correct for Samba3. */
   89.44  #define data_blob(ptr, size) data_blob_named(ptr, size, "DATA_BLOB: "__location__)
   89.45  #define data_blob_talloc(ctx, ptr, size) data_blob_talloc_named(ctx, ptr, size, "DATA_BLOB: "__location__)
   89.46  #define data_blob_dup_talloc(ctx, blob) data_blob_talloc_named(ctx, (blob)->data, (blob)->length, "DATA_BLOB: "__location__)
   89.47 +#endif
   89.48  
   89.49  #define talloc_set_type(ptr, type) talloc_set_name_const(ptr, #type)
   89.50  #define talloc_get_type(ptr, type) (type *)talloc_check_name(ptr, #type)
   89.51  
   89.52 +#define talloc_find_parent_bytype(ptr, type) (type *)talloc_find_parent_byname(ptr, #type)
   89.53 +
   89.54  
   89.55  #if TALLOC_DEPRECATED
   89.56  #define talloc_zero_p(ctx, type) talloc_zero(ctx, type)
   89.57 @@ -117,6 +126,7 @@ void *_talloc_zero(const void *ctx, size
   89.58  void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name);
   89.59  char *talloc_strdup(const void *t, const char *p);
   89.60  char *talloc_strndup(const void *t, const char *p, size_t n);
   89.61 +char *talloc_append_string(const void *t, char *orig, const char *append);
   89.62  char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
   89.63  char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
   89.64  char *talloc_asprintf_append(char *s,
   89.65 @@ -127,8 +137,8 @@ void *_talloc_realloc_array(const void *
   89.66  void *talloc_realloc_fn(const void *context, void *ptr, size_t size);
   89.67  void *talloc_autofree_context(void);
   89.68  size_t talloc_get_size(const void *ctx);
   89.69 +void *talloc_find_parent_byname(const void *ctx, const char *name);
   89.70 +void talloc_show_parents(const void *context, FILE *file);
   89.71  
   89.72 -typedef int talloc_fail_handler(void *);
   89.73 -talloc_fail_handler *talloc_set_fail_handler(talloc_fail_handler *, void *);
   89.74  #endif
   89.75  
    90.1 --- a/tools/xenstore/xenstored_core.c	Mon Mar 27 15:36:47 2006 -0700
    90.2 +++ b/tools/xenstore/xenstored_core.c	Tue Mar 28 08:54:58 2006 -0700
    90.3 @@ -1231,39 +1231,17 @@ static void process_message(struct conne
    90.4  	conn->transaction = NULL;
    90.5  }
    90.6  
    90.7 -static int out_of_mem(void *data)
    90.8 -{
    90.9 -	longjmp(*(jmp_buf *)data, 1);
   90.10 -}
   90.11 -
   90.12  static void consider_message(struct connection *conn)
   90.13  {
   90.14 -	jmp_buf talloc_fail;
   90.15 -
   90.16  	if (verbose)
   90.17  		xprintf("Got message %s len %i from %p\n",
   90.18  			sockmsg_string(conn->in->hdr.msg.type),
   90.19  			conn->in->hdr.msg.len, conn);
   90.20  
   90.21 -	/* For simplicity, we kill the connection on OOM. */
   90.22 -	talloc_set_fail_handler(out_of_mem, &talloc_fail);
   90.23 -	if (setjmp(talloc_fail)) {
   90.24 -		talloc_free(conn);
   90.25 -		goto end;
   90.26 -	}
   90.27 -
   90.28  	process_message(conn, conn->in);
   90.29  
   90.30  	talloc_free(conn->in);
   90.31  	conn->in = new_buffer(conn);
   90.32 -
   90.33 -end:
   90.34 -	talloc_set_fail_handler(NULL, NULL);
   90.35 -	if (talloc_total_blocks(NULL)
   90.36 -	    != talloc_total_blocks(talloc_autofree_context()) + 1) {
   90.37 -		talloc_report_full(NULL, stderr);
   90.38 -		abort();
   90.39 -	}
   90.40  }
   90.41  
   90.42  /* Errors in reading or allocating here mean we get out of sync, so we
    91.1 --- a/tools/xentrace/Makefile	Mon Mar 27 15:36:47 2006 -0700
    91.2 +++ b/tools/xentrace/Makefile	Tue Mar 28 08:54:58 2006 -0700
    91.3 @@ -6,7 +6,7 @@ INSTALL_DATA	= $(INSTALL) -m0644
    91.4  XEN_ROOT=../..
    91.5  include $(XEN_ROOT)/tools/Rules.mk
    91.6  
    91.7 -CFLAGS  += -Werror
    91.8 +CFLAGS  += -Werror -D_LARGEFILE64_SOURCE
    91.9  
   91.10  CFLAGS  += -I $(XEN_XC)
   91.11  CFLAGS  += -I $(XEN_LIBXC)
    92.1 --- a/tools/xentrace/formats	Mon Mar 27 15:36:47 2006 -0700
    92.2 +++ b/tools/xentrace/formats	Tue Mar 28 08:54:58 2006 -0700
    92.3 @@ -16,6 +16,6 @@ 0x00080001	CPU%(cpu)d      %(tsc)d		VMX_
    92.4  0x00080002	CPU%(cpu)d      %(tsc)d		VMX_VECTOR		[ domid = 0x%(1)08x, eip = 0x%(2)08x, vector = 0x%(3)08x ]
    92.5  0x00080003	CPU%(cpu)d      %(tsc)d		VMX_INT			[ domid = 0x%(1)08x, trap = 0x%(2)08x, va = 0x%(3)08x ]
    92.6  
    92.7 -0x00090001      CPU%(cpu)d      %(tsc)d         VMENTRY                 0x%(1)08x 0x%(2)08x 0x%(3)08x 0x%(4)08x 0x%(5)08x
    92.8 -0x00090002      CPU%(cpu)d      %(tsc)d         VMEXIT                  0x%(1)08x 0x%(2)08x 0x%(3)08x 
    92.9 +0x00081001      CPU%(cpu)d      %(tsc)d         VMEXIT                  0x%(1)08x 0x%(2)08x 0x%(3)08x 
   92.10 +0x00081002      CPU%(cpu)d      %(tsc)d         VMENTRY                 0x%(1)08x 0x%(2)08x 0x%(3)08x 0x%(4)08x 0x%(5)08x
   92.11  
    93.1 --- a/tools/xentrace/xentrace.c	Mon Mar 27 15:36:47 2006 -0700
    93.2 +++ b/tools/xentrace/xentrace.c	Tue Mar 28 08:54:58 2006 -0700
    93.3 @@ -498,7 +498,7 @@ int main(int argc, char **argv)
    93.4      }
    93.5  
    93.6      if ( opts.outfile )
    93.7 -        outfd = open(opts.outfile, O_WRONLY | O_CREAT);
    93.8 +        outfd = open(opts.outfile, O_WRONLY | O_CREAT | O_LARGEFILE, 0644);
    93.9  
   93.10      if(outfd < 0)
   93.11      {
    94.1 --- a/tools/xm-test/lib/XmTestLib/Test.py	Mon Mar 27 15:36:47 2006 -0700
    94.2 +++ b/tools/xm-test/lib/XmTestLib/Test.py	Tue Mar 28 08:54:58 2006 -0700
    94.3 @@ -131,12 +131,12 @@ def becomeNonRoot():
    94.4          if os.geteuid() == 0:
    94.5              FAIL("Could not become a non-root user")
    94.6  
    94.7 -def FAIL(reason):
    94.8 -    print "\nREASON: %s" % reason
    94.9 +def FAIL(format, *args):
   94.10 +    print "\nREASON:", (format % args)
   94.11      sys.exit(TEST_FAIL)
   94.12  
   94.13 -def SKIP(reason):
   94.14 -    print "\nREASON: %s" % reason
   94.15 +def SKIP(format, *args):
   94.16 +    print "\nREASON:", (format % args)
   94.17      sys.exit(TEST_SKIP)
   94.18  
   94.19  def saveLog(logText, filename=None):
    95.1 --- a/tools/xm-test/ramdisk/Makefile.am	Mon Mar 27 15:36:47 2006 -0700
    95.2 +++ b/tools/xm-test/ramdisk/Makefile.am	Tue Mar 28 08:54:58 2006 -0700
    95.3 @@ -1,3 +1,4 @@
    95.4 +INITRD ?= http://xm-test.xensource.com/ramdisks
    95.5  
    95.6  EXTRA_DIST = skel configs patches
    95.7  
    95.8 @@ -60,7 +61,7 @@ disk.img: existing
    95.9  	fi
   95.10  
   95.11  existing:
   95.12 -	@if test -n "$(INITRD)"; then \
   95.13 +	@if [ -n "$(INITRD)" ] && [ ! -f $(XMTEST_VER_IMG) ] ; then \
   95.14  		wget $(INITRD)/$(XMTEST_VER_IMG); \
   95.15  	fi
   95.16  	@if [ -f $(XMTEST_VER_IMG) ] ; then \
    96.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    96.2 +++ b/tools/xm-test/ramdisk/README-XenSource-initrd-0.7-img	Tue Mar 28 08:54:58 2006 -0700
    96.3 @@ -0,0 +1,42 @@
    96.4 +XenSource xm-test 0.7 initrd.img
    96.5 +================================
    96.6 +
    96.7 +http://xm-test.xensource.com/ramdisks/initrd-0.7.img is an initrd suitable for
    96.8 +use with Xen's xm-test regression testing suite.  It has been built and
    96.9 +provided by XenSource, for the convenience of Xen users.  xm-test initrds may
   96.10 +be mixed across minor xm-test versions, but not across major versions; this
   96.11 +initrd is suitable for all 0.7.x versions of xm-test (as shipped with Xen
   96.12 +3.0.x).
   96.13 +
   96.14 +In order to use this initrd, run "./autogen; ./configure; make existing"
   96.15 +inside the xm-test directory, and the initrd will be downloaded automatically.
   96.16 +Alternatively, if you have already downloaded this file, place it into the
   96.17 +xm-test/ramdisk directory and run the same command.  In either case,
   96.18 +runtest.sh can then be used as normal.  See xm-test/README for more details.
   96.19 +
   96.20 +This initrd was built using the infrastructure provided by xm-test.  It is a
   96.21 +full guest operating system and filesystem, and as such includes a large
   96.22 +number of pieces of software.  The source code for the majority of these are
   96.23 +included in full inside the file
   96.24 +http://xm-test.xensource.com/ramdisks/initrd.0.7.img-buildroot.tar.bz2, or
   96.25 +alongside this file.  Copyright statements and licences are contained therein.
   96.26 +The remaining source code is included in the Xen distribution, at
   96.27 +http://www.xensource.com/xen/downloads/archives.html.  The configurations used
   96.28 +for BusyBox, uClibc, and Buildroot are available as
   96.29 +http://xm-test.xensource.com/ramdisks/initrd-0.7-busybox-config,
   96.30 +http://xm-test.xensource.com/ramdisks/initrd-0.7-uClibc-config, and
   96.31 +http://xm-test.xensource.com/ramdisks/initrd-0.7-buildroot-config
   96.32 +respectively, or alongside this file.
   96.33 +
   96.34 +XenSource and the Xen contributors are grateful to the authors of these
   96.35 +software packages for their contributions to free and open-source software.
   96.36 +
   96.37 +
   96.38 +Buildroot and BusyBox are Copyright (c) Erik Andersen <andersen@codepoet.org>.
   96.39 +BusyBox is licensed under the GNU General Public License (GPL).  A copy of
   96.40 +this license is available in the file GPL-2,
   96.41 +http://xm-test.xensource.com/ramdisks/GPL-2, or alongside this file.
   96.42 +
   96.43 +uClibc is licensed under the GNU Lesser General Public License (LGPL).  A copy
   96.44 +of this license is available in the file
   96.45 +http://xm-test.xensource.com/ramdisks/LGPL-2, or alongside this file.
    97.1 --- a/tools/xm-test/tests/block-create/Makefile.am	Mon Mar 27 15:36:47 2006 -0700
    97.2 +++ b/tools/xm-test/tests/block-create/Makefile.am	Tue Mar 28 08:54:58 2006 -0700
    97.3 @@ -12,7 +12,7 @@ TESTS = 01_block_attach_device_pos.test 
    97.4  	11_block_attach_shared_dom0.test \
    97.5  	12_block_attach_shared_domU.test
    97.6  
    97.7 -EXTRA_DIST = $(TESTS) $(XFAIL_TESTS)
    97.8 +EXTRA_DIST = $(TESTS)
    97.9  
   97.10  TESTS_ENVIRONMENT=@TENV@
   97.11  
    98.1 --- a/tools/xm-test/tests/create/Makefile.am	Mon Mar 27 15:36:47 2006 -0700
    98.2 +++ b/tools/xm-test/tests/create/Makefile.am	Tue Mar 28 08:54:58 2006 -0700
    98.3 @@ -15,7 +15,7 @@ TESTS = 01_create_basic_pos.test \
    98.4  	14_create_blockroot_pos.test \
    98.5  	15_create_smallmem_pos.test
    98.6  
    98.7 -EXTRA_DIST = $(TESTS) $(XFAIL_TESTS)
    98.8 +EXTRA_DIST = $(TESTS)
    98.9  
   98.10  TESTS_ENVIRONMENT=@TENV@
   98.11  
    99.1 --- a/xen/arch/x86/dom0_ops.c	Mon Mar 27 15:36:47 2006 -0700
    99.2 +++ b/xen/arch/x86/dom0_ops.c	Tue Mar 28 08:54:58 2006 -0700
    99.3 @@ -460,8 +460,7 @@ void arch_getdomaininfo_ctxt(
    99.4  
    99.5      if ( hvm_guest(v) )
    99.6      {
    99.7 -        hvm_store_cpu_guest_regs(v, &c->user_regs);
    99.8 -        hvm_store_cpu_guest_ctrl_regs(v, c->ctrlreg);
    99.9 +        hvm_store_cpu_guest_regs(v, &c->user_regs, c->ctrlreg);
   99.10      }
   99.11      else
   99.12      {
   100.1 --- a/xen/arch/x86/hvm/platform.c	Mon Mar 27 15:36:47 2006 -0700
   100.2 +++ b/xen/arch/x86/hvm/platform.c	Tue Mar 28 08:54:58 2006 -0700
   100.3 @@ -773,7 +773,7 @@ void handle_mmio(unsigned long va, unsig
   100.4      mmio_opp = &v->arch.hvm_vcpu.mmio_op;
   100.5  
   100.6      regs = mmio_opp->inst_decoder_regs;
   100.7 -    hvm_store_cpu_guest_regs(v, regs);
   100.8 +    hvm_store_cpu_guest_regs(v, regs, NULL);
   100.9  
  100.10      if ((inst_len = hvm_instruction_length(v)) <= 0) {
  100.11          printf("handle_mmio: failed to get instruction length\n");
   101.1 --- a/xen/arch/x86/hvm/svm/intr.c	Mon Mar 27 15:36:47 2006 -0700
   101.2 +++ b/xen/arch/x86/hvm/svm/intr.c	Tue Mar 28 08:54:58 2006 -0700
   101.3 @@ -44,6 +44,58 @@
   101.4   */
   101.5  #define BSP_CPU(v)    (!(v->vcpu_id))
   101.6  
   101.7 +u64 svm_get_guest_time(struct vcpu *v)
   101.8 +{
   101.9 +    struct hvm_virpit *vpit = &(v->domain->arch.hvm_domain.vpit);
  101.10 +    u64    host_tsc;
  101.11 +    
  101.12 +    rdtscll(host_tsc);
  101.13 +    return host_tsc + vpit->cache_tsc_offset;
  101.14 +}
  101.15 +
  101.16 +void svm_set_guest_time(struct vcpu *v, u64 gtime)
  101.17 +{
  101.18 +    struct hvm_virpit *vpit = &(v->domain->arch.hvm_domain.vpit);
  101.19 +    u64    host_tsc;
  101.20 +   
  101.21 +    rdtscll(host_tsc);
  101.22 +    
  101.23 +    vpit->cache_tsc_offset = gtime - host_tsc;
  101.24 +    v->arch.hvm_svm.vmcb->tsc_offset = vpit->cache_tsc_offset;
  101.25 +}
  101.26 +
  101.27 +static inline void
  101.28 +interrupt_post_injection(struct vcpu * v, int vector, int type)
  101.29 +{
  101.30 +    struct hvm_virpit *vpit = &(v->domain->arch.hvm_domain.vpit);
  101.31 +
  101.32 +    if ( is_pit_irq(v, vector, type) ) {
  101.33 +        if ( !vpit->first_injected ) {
  101.34 +            vpit->pending_intr_nr = 0;
  101.35 +            vpit->last_pit_gtime = svm_get_guest_time(v);
  101.36 +            vpit->scheduled = NOW() + vpit->period;
  101.37 +            set_timer(&vpit->pit_timer, vpit->scheduled);
  101.38 +            vpit->first_injected = 1;
  101.39 +        } else {
  101.40 +            vpit->pending_intr_nr--;
  101.41 +        }
  101.42 +        vpit->inject_point = NOW();
  101.43 +
  101.44 +        vpit->last_pit_gtime += vpit->period;
  101.45 +        svm_set_guest_time(v, vpit->last_pit_gtime);
  101.46 +    }
  101.47 +
  101.48 +    switch(type)
  101.49 +    {
  101.50 +    case VLAPIC_DELIV_MODE_EXT:
  101.51 +        break;
  101.52 +
  101.53 +    default:
  101.54 +        vlapic_post_injection(v, vector, type);
  101.55 +        break;
  101.56 +    }
  101.57 +}
  101.58 +
  101.59  static inline int svm_inject_extint(struct vcpu *v, int trap, int error_code)
  101.60  {
  101.61      struct vmcb_struct *vmcb = v->arch.hvm_svm.vmcb;
  101.62 @@ -64,45 +116,6 @@ static inline int svm_inject_extint(stru
  101.63      return 0;
  101.64  }
  101.65  
  101.66 -void svm_set_tsc_shift(struct vcpu *v, struct hvm_virpit *vpit)
  101.67 -{
  101.68 -    struct vmcb_struct *vmcb = v->arch.hvm_svm.vmcb;
  101.69 -    u64    drift;
  101.70 -
  101.71 -    if ( vpit->first_injected )
  101.72 -        drift = vpit->period_cycles * vpit->pending_intr_nr;
  101.73 -    else
  101.74 -        drift = 0;
  101.75 -    vmcb->tsc_offset = ( 0 - drift );
  101.76 -}
  101.77 -
  101.78 -static inline void
  101.79 -interrupt_post_injection(struct vcpu * v, int vector, int type)
  101.80 -{
  101.81 -    struct hvm_virpit *vpit = &(v->domain->arch.hvm_domain.vpit);
  101.82 -
  101.83 -    if ( is_pit_irq(v, vector, type) ) {
  101.84 -            if ( !vpit->first_injected ) {
  101.85 -                vpit->first_injected = 1;
  101.86 -                vpit->pending_intr_nr = 0;
  101.87 -            }
  101.88 -            else if (vpit->pending_intr_nr) {
  101.89 -                --vpit->pending_intr_nr;
  101.90 -            }
  101.91 -            vpit->inject_point = NOW();
  101.92 -            svm_set_tsc_shift (v, vpit);
  101.93 -    }
  101.94 -
  101.95 -    switch(type)
  101.96 -    {
  101.97 -    case VLAPIC_DELIV_MODE_EXT:
  101.98 -        break;
  101.99 -
 101.100 -    default:
 101.101 -        vlapic_post_injection(v, vector, type);
 101.102 -    }
 101.103 -}
 101.104 -
 101.105  asmlinkage void svm_intr_assist(void) 
 101.106  {
 101.107      struct vcpu *v = current;
   102.1 --- a/xen/arch/x86/hvm/svm/svm.c	Mon Mar 27 15:36:47 2006 -0700
   102.2 +++ b/xen/arch/x86/hvm/svm/svm.c	Tue Mar 28 08:54:58 2006 -0700
   102.3 @@ -201,31 +201,41 @@ int svm_initialize_guest_resources(struc
   102.4  }
   102.5  
   102.6  static void svm_store_cpu_guest_regs(
   102.7 -    struct vcpu *v, struct cpu_user_regs *regs)
   102.8 +    struct vcpu *v, struct cpu_user_regs *regs, unsigned long *crs)
   102.9  {
  102.10      struct vmcb_struct *vmcb = v->arch.hvm_svm.vmcb;
  102.11  
  102.12 +    if ( regs != NULL )
  102.13 +    {
  102.14  #if defined (__x86_64__)
  102.15 -    regs->rip    = vmcb->rip;
  102.16 -    regs->rsp    = vmcb->rsp;
  102.17 -    regs->rflags = vmcb->rflags;
  102.18 -    regs->cs     = vmcb->cs.sel;
  102.19 -    regs->ds     = vmcb->ds.sel;
  102.20 -    regs->es     = vmcb->es.sel;
  102.21 -    regs->ss     = vmcb->ss.sel;
  102.22 -    regs->gs     = vmcb->gs.sel;
  102.23 -    regs->fs     = vmcb->fs.sel;
  102.24 +        regs->rip    = vmcb->rip;
  102.25 +        regs->rsp    = vmcb->rsp;
  102.26 +        regs->rflags = vmcb->rflags;
  102.27 +        regs->cs     = vmcb->cs.sel;
  102.28 +        regs->ds     = vmcb->ds.sel;
  102.29 +        regs->es     = vmcb->es.sel;
  102.30 +        regs->ss     = vmcb->ss.sel;
  102.31 +        regs->gs     = vmcb->gs.sel;
  102.32 +        regs->fs     = vmcb->fs.sel;
  102.33  #elif defined (__i386__)
  102.34 -    regs->eip    = vmcb->rip;
  102.35 -    regs->esp    = vmcb->rsp;
  102.36 -    regs->eflags = vmcb->rflags;
  102.37 -    regs->cs     = vmcb->cs.sel;
  102.38 -    regs->ds     = vmcb->ds.sel;
  102.39 -    regs->es     = vmcb->es.sel;
  102.40 -    regs->ss     = vmcb->ss.sel;
  102.41 -    regs->gs     = vmcb->gs.sel;
  102.42 -    regs->fs     = vmcb->fs.sel;
  102.43 +        regs->eip    = vmcb->rip;
  102.44 +        regs->esp    = vmcb->rsp;
  102.45 +        regs->eflags = vmcb->rflags;
  102.46 +        regs->cs     = vmcb->cs.sel;
  102.47 +        regs->ds     = vmcb->ds.sel;
  102.48 +        regs->es     = vmcb->es.sel;
  102.49 +        regs->ss     = vmcb->ss.sel;
  102.50 +        regs->gs     = vmcb->gs.sel;
  102.51 +        regs->fs     = vmcb->fs.sel;
  102.52  #endif
  102.53 +    }
  102.54 +
  102.55 +    if ( crs != NULL )
  102.56 +    {
  102.57 +        crs[0] = vmcb->cr0;
  102.58 +        crs[3] = vmcb->cr3;
  102.59 +        crs[4] = vmcb->cr4;
  102.60 +    }
  102.61  }
  102.62  
  102.63  static void svm_load_cpu_guest_regs(
  102.64 @@ -372,15 +382,6 @@ static inline int long_mode_do_msr_write
  102.65      return 1;
  102.66  }
  102.67  
  102.68 -void svm_store_cpu_guest_ctrl_regs(struct vcpu *v, unsigned long crs[8])
  102.69 -{
  102.70 -    struct vmcb_struct *vmcb = v->arch.hvm_svm.vmcb;
  102.71 -
  102.72 -    crs[0] = vmcb->cr0;
  102.73 -    crs[3] = vmcb->cr3;
  102.74 -    crs[4] = vmcb->cr4;
  102.75 -}
  102.76 -
  102.77  void svm_modify_guest_state(struct vcpu *v)
  102.78  {
  102.79      svm_modify_vmcb(v, &v->arch.guest_context.user_regs);
  102.80 @@ -448,7 +449,6 @@ int start_svm(void)
  102.81      hvm_funcs.store_cpu_guest_regs = svm_store_cpu_guest_regs;
  102.82      hvm_funcs.load_cpu_guest_regs = svm_load_cpu_guest_regs;
  102.83  
  102.84 -    hvm_funcs.store_cpu_guest_ctrl_regs = svm_store_cpu_guest_ctrl_regs;
  102.85      hvm_funcs.modify_guest_state = svm_modify_guest_state;
  102.86  
  102.87      hvm_funcs.realmode = svm_realmode;
  102.88 @@ -670,8 +670,18 @@ static void arch_svm_do_launch(struct vc
  102.89      reset_stack_and_jump(svm_asm_do_launch);
  102.90  }
  102.91  
  102.92 +static void svm_freeze_time(struct vcpu *v)
  102.93 +{
  102.94 +    struct hvm_virpit *vpit = &v->domain->arch.hvm_domain.vpit;
  102.95 +    
  102.96 +    v->domain->arch.hvm_domain.guest_time = svm_get_guest_time(v);
  102.97 +    if ( vpit->first_injected )
  102.98 +        stop_timer(&(vpit->pit_timer));
  102.99 +}
 102.100 +
 102.101  static void svm_ctxt_switch_from(struct vcpu *v)
 102.102  {
 102.103 +    svm_freeze_time(v);
 102.104  }
 102.105  
 102.106  static void svm_ctxt_switch_to(struct vcpu *v)
 102.107 @@ -718,6 +728,8 @@ static void svm_relinquish_guest_resourc
 102.108  
 102.109      for_each_vcpu ( d, v )
 102.110      {
 102.111 +        if ( !test_bit(_VCPUF_initialised, &v->vcpu_flags) )
 102.112 +            continue;
 102.113  #if 0
 102.114          /* Memory leak by not freeing this. XXXKAF: *Why* is not per core?? */
 102.115          free_host_save_area(v->arch.hvm_svm.host_save_area);
 102.116 @@ -911,7 +923,7 @@ static void svm_vmexit_do_cpuid(struct v
 102.117  
 102.118      if (input == 1)
 102.119      {
 102.120 -        if ( hvm_apic_support(v->domain) &&
 102.121 +        if ( !hvm_apic_support(v->domain) ||
 102.122                  !vlapic_global_enabled((VLAPIC(v))) )
 102.123              clear_bit(X86_FEATURE_APIC, &edx);
 102.124  	    
 102.125 @@ -1251,11 +1263,6 @@ static void svm_io_instruction(struct vc
 102.126  
 102.127          /* Need the original rip, here. */
 102.128          addr = svm_get_io_address(vmcb, regs, dir, real);
 102.129 -        /* 
 102.130 -         * On SVM, the RIP of the intruction following the IN/OUT is saved in
 102.131 -         * ExitInfo2
 102.132 -         */
 102.133 -        vmcb->rip = vmcb->exitinfo2;
 102.134  
 102.135          /* "rep" prefix */
 102.136          if (info.fields.rep) 
 102.137 @@ -1288,6 +1295,8 @@ static void svm_io_instruction(struct vc
 102.138                  else
 102.139                      count = (addr & ~PAGE_MASK) / size;
 102.140              }
 102.141 +            else    
 102.142 +                vmcb->rip = vmcb->exitinfo2;
 102.143  
 102.144              send_pio_req(regs, port, count, size, addr, dir, 1);
 102.145          }
 102.146 @@ -1693,7 +1702,7 @@ static inline void svm_do_msr_access(str
 102.147  {
 102.148      struct vmcb_struct *vmcb = v->arch.hvm_svm.vmcb;
 102.149      int  inst_len;
 102.150 -    int64_t tsc_sum;
 102.151 +    u64 msr_content=0;
 102.152  
 102.153      ASSERT(vmcb);
 102.154  
 102.155 @@ -1708,24 +1717,27 @@ static inline void svm_do_msr_access(str
 102.156          inst_len = __get_instruction_length(vmcb, INSTR_RDMSR, NULL);
 102.157  
 102.158          regs->edx = 0;
 102.159 -        switch (regs->ecx)
 102.160 +        switch (regs->ecx) {
 102.161 +        case MSR_IA32_TIME_STAMP_COUNTER:
 102.162          {
 102.163 +            struct hvm_virpit *vpit;
 102.164 +
 102.165 +            rdtscll(msr_content);
 102.166 +            vpit = &(v->domain->arch.hvm_domain.vpit);
 102.167 +            msr_content += vpit->cache_tsc_offset;
 102.168 +            break;
 102.169 +        }
 102.170          case MSR_IA32_SYSENTER_CS:
 102.171 -            regs->eax = vmcb->sysenter_cs;
 102.172 +            msr_content = vmcb->sysenter_cs;
 102.173              break;
 102.174          case MSR_IA32_SYSENTER_ESP: 
 102.175 -            regs->eax = vmcb->sysenter_esp;
 102.176 +            msr_content = vmcb->sysenter_esp;
 102.177              break;
 102.178          case MSR_IA32_SYSENTER_EIP:     
 102.179 -            regs->eax = vmcb->sysenter_eip;
 102.180 +            msr_content = vmcb->sysenter_eip;
 102.181              break;
 102.182 -        case MSR_IA32_TIME_STAMP_COUNTER:
 102.183 -            __asm__ __volatile__("rdtsc" : "=a" (regs->eax), "=d" (regs->edx));
 102.184 -            tsc_sum = regs->edx;
 102.185 -            tsc_sum = (tsc_sum << 32) + regs->eax;
 102.186 -            tsc_sum += (int64_t) vmcb->tsc_offset;
 102.187 -            regs->eax = tsc_sum & 0xFFFFFFFF;
 102.188 -            regs->edx = (tsc_sum >> 32) & 0xFFFFFFFF;
 102.189 +        case MSR_IA32_APICBASE:
 102.190 +            msr_content = VLAPIC(v) ? VLAPIC(v)->apic_base_msr : 0;
 102.191              break;
 102.192          default:
 102.193              if (long_mode_do_msr_read(regs))
 102.194 @@ -1733,21 +1745,30 @@ static inline void svm_do_msr_access(str
 102.195              rdmsr_safe(regs->ecx, regs->eax, regs->edx);
 102.196              break;
 102.197          }
 102.198 +        regs->eax = msr_content & 0xFFFFFFFF;
 102.199 +        regs->edx = msr_content >> 32;
 102.200      }
 102.201      else
 102.202      {
 102.203          inst_len = __get_instruction_length(vmcb, INSTR_WRMSR, NULL);
 102.204 +        msr_content = (regs->eax & 0xFFFFFFFF) | ((u64)regs->edx << 32);
 102.205  
 102.206          switch (regs->ecx)
 102.207          {
 102.208 +        case MSR_IA32_TIME_STAMP_COUNTER:
 102.209 +            svm_set_guest_time(v, msr_content);
 102.210 +            break;
 102.211          case MSR_IA32_SYSENTER_CS:
 102.212 -            vmcb->sysenter_cs = regs->eax;
 102.213 +            vmcb->sysenter_cs = msr_content;
 102.214              break;
 102.215          case MSR_IA32_SYSENTER_ESP: 
 102.216 -            vmcb->sysenter_esp = regs->eax;
 102.217 +            vmcb->sysenter_esp = msr_content;
 102.218              break;
 102.219          case MSR_IA32_SYSENTER_EIP:     
 102.220 -            vmcb->sysenter_eip = regs->eax;
 102.221 +            vmcb->sysenter_eip = msr_content;
 102.222 +            break;
 102.223 +        case MSR_IA32_APICBASE:
 102.224 +            vlapic_msr_set(VLAPIC(v), msr_content);
 102.225              break;
 102.226          default:
 102.227              long_mode_do_msr_write(regs);
   103.1 --- a/xen/arch/x86/hvm/svm/vmcb.c	Mon Mar 27 15:36:47 2006 -0700
   103.2 +++ b/xen/arch/x86/hvm/svm/vmcb.c	Tue Mar 28 08:54:58 2006 -0700
   103.3 @@ -123,7 +123,7 @@ static int construct_vmcb_controls(struc
   103.4            GENERAL1_INTERCEPT_RDTSC         | GENERAL1_INTERCEPT_PUSHF      |
   103.5            GENERAL1_INTERCEPT_SWINT         | GENERAL1_INTERCEPT_POPF       | 
   103.6            GENERAL1_INTERCEPT_IRET          | GENERAL1_INTERCEPT_PAUSE      |
   103.7 -          GENERAL1_INTERCEPT_TASK_SWITCH   | GENERAL1_INTERCEPT_SMI
   103.8 +          GENERAL1_INTERCEPT_TASK_SWITCH
   103.9          );
  103.10  
  103.11      /* turn on the general 2 intercepts */
  103.12 @@ -467,6 +467,8 @@ void svm_do_launch(struct vcpu *v)
  103.13      v->arch.hvm_svm.injecting_event  = 0;
  103.14      v->arch.hvm_svm.saved_irq_vector = -1;
  103.15  
  103.16 +    svm_set_guest_time(v, 0);
  103.17 +	
  103.18      if (svm_dbg_on)
  103.19          svm_dump_vmcb(__func__, vmcb);
  103.20  }
  103.21 @@ -494,16 +496,17 @@ void svm_do_resume(struct vcpu *v)
  103.22      struct hvm_virpit *vpit = &d->arch.hvm_domain.vpit;
  103.23  
  103.24      svm_stts(v);
  103.25 +    
  103.26 +    /* pick up the elapsed PIT ticks and re-enable pit_timer */
  103.27 +    if ( vpit->first_injected) {
  103.28 +        svm_set_guest_time(v, v->domain->arch.hvm_domain.guest_time);
  103.29 +        pickup_deactive_ticks(vpit);
  103.30 +    }
  103.31  
  103.32      if ( test_bit(iopacket_port(v), &d->shared_info->evtchn_pending[0]) ||
  103.33           test_bit(ARCH_HVM_IO_WAIT, &v->arch.hvm_vcpu.ioflags) )
  103.34          hvm_wait_io();
  103.35  
  103.36 -    /* pick up the elapsed PIT ticks and re-enable pit_timer */
  103.37 -    if ( vpit->first_injected )
  103.38 -        pickup_deactive_ticks(vpit);
  103.39 -    svm_set_tsc_shift(v, vpit);
  103.40 -
  103.41      /* We can't resume the guest if we're waiting on I/O */
  103.42      ASSERT(!test_bit(ARCH_HVM_IO_WAIT, &v->arch.hvm_vcpu.ioflags));
  103.43  }
   104.1 --- a/xen/arch/x86/hvm/vmx/io.c	Mon Mar 27 15:36:47 2006 -0700
   104.2 +++ b/xen/arch/x86/hvm/vmx/io.c	Tue Mar 28 08:54:58 2006 -0700
   104.3 @@ -86,7 +86,7 @@ interrupt_post_injection(struct vcpu * v
   104.4          }
   104.5          vpit->inject_point = NOW();
   104.6  
   104.7 -        vpit->last_pit_gtime += vpit->period;
   104.8 +        vpit->last_pit_gtime += vpit->period_cycles;
   104.9          set_guest_time(v, vpit->last_pit_gtime);
  104.10      }
  104.11  
  104.12 @@ -206,8 +206,11 @@ void vmx_do_resume(struct vcpu *v)
  104.13      vmx_stts();
  104.14  
  104.15      /* pick up the elapsed PIT ticks and re-enable pit_timer */
  104.16 -    if ( vpit->first_injected) {
  104.17 -        set_guest_time(v, v->domain->arch.hvm_domain.guest_time);
  104.18 +    if ( vpit->first_injected ) {
  104.19 +        if ( v->domain->arch.hvm_domain.guest_time ) {
  104.20 +            set_guest_time(v, v->domain->arch.hvm_domain.guest_time);
  104.21 +            v->domain->arch.hvm_domain.guest_time = 0;
  104.22 +        }
  104.23          pickup_deactive_ticks(vpit);
  104.24      }
  104.25  
   105.1 --- a/xen/arch/x86/hvm/vmx/vmx.c	Mon Mar 27 15:36:47 2006 -0700
   105.2 +++ b/xen/arch/x86/hvm/vmx/vmx.c	Tue Mar 28 08:54:58 2006 -0700
   105.3 @@ -89,6 +89,8 @@ static void vmx_relinquish_guest_resourc
   105.4  
   105.5      for_each_vcpu ( d, v )
   105.6      {
   105.7 +        if ( !test_bit(_VCPUF_initialised, &v->vcpu_flags) )
   105.8 +            continue;
   105.9          vmx_request_clear_vmcs(v);
  105.10          destroy_vmcs(&v->arch.hvm_vmx);
  105.11          free_monitor_pagetable(v);
  105.12 @@ -358,9 +360,10 @@ static void vmx_freeze_time(struct vcpu 
  105.13  {
  105.14      struct hvm_virpit *vpit = &v->domain->arch.hvm_domain.vpit;
  105.15      
  105.16 -    v->domain->arch.hvm_domain.guest_time = get_guest_time(v);
  105.17 -    if ( vpit->first_injected )
  105.18 +    if ( vpit->first_injected && !v->domain->arch.hvm_domain.guest_time ) {
  105.19 +        v->domain->arch.hvm_domain.guest_time = get_guest_time(v);
  105.20          stop_timer(&(vpit->pit_timer));
  105.21 +    }
  105.22  }
  105.23  
  105.24  static void vmx_ctxt_switch_from(struct vcpu *v)
  105.25 @@ -397,31 +400,81 @@ void vmx_migrate_timers(struct vcpu *v)
  105.26          migrate_timer(&(VLAPIC(v)->vlapic_timer), v->processor);
  105.27  }
  105.28  
  105.29 -void vmx_store_cpu_guest_regs(struct vcpu *v, struct cpu_user_regs *regs)
  105.30 +struct vmx_store_cpu_guest_regs_callback_info {
  105.31 +    struct vcpu *v;
  105.32 +    struct cpu_user_regs *regs;
  105.33 +    unsigned long *crs;
  105.34 +};
  105.35 +
  105.36 +static void vmx_store_cpu_guest_regs(
  105.37 +    struct vcpu *v, struct cpu_user_regs *regs, unsigned long *crs);
  105.38 +
  105.39 +static void vmx_store_cpu_guest_regs_callback(void *data)
  105.40  {
  105.41 +    struct vmx_store_cpu_guest_regs_callback_info *info = data;
  105.42 +    vmx_store_cpu_guest_regs(info->v, info->regs, info->crs);
  105.43 +}
  105.44 +
  105.45 +static void vmx_store_cpu_guest_regs(
  105.46 +    struct vcpu *v, struct cpu_user_regs *regs, unsigned long *crs)
  105.47 +{
  105.48 +    if ( v != current )
  105.49 +    {
  105.50 +        /* Non-current VCPUs must be paused to get a register snapshot. */
  105.51 +        ASSERT(atomic_read(&v->pausecnt) != 0);
  105.52 +
  105.53 +        if ( v->arch.hvm_vmx.launch_cpu != smp_processor_id() )
  105.54 +        {
  105.55 +            /* Get register details from remote CPU. */
  105.56 +            struct vmx_store_cpu_guest_regs_callback_info info = {
  105.57 +                .v = v, .regs = regs, .crs = crs };
  105.58 +            cpumask_t cpumask = cpumask_of_cpu(v->arch.hvm_vmx.launch_cpu);
  105.59 +            on_selected_cpus(cpumask, vmx_store_cpu_guest_regs_callback,
  105.60 +                             &info, 1, 1);
  105.61 +            return;
  105.62 +        }
  105.63 +
  105.64 +        /* Register details are on this CPU. Load the correct VMCS. */
  105.65 +        __vmptrld(virt_to_maddr(v->arch.hvm_vmx.vmcs));
  105.66 +    }
  105.67 +
  105.68 +    ASSERT(v->arch.hvm_vmx.launch_cpu == smp_processor_id());
  105.69 +
  105.70 +    if ( regs != NULL )
  105.71 +    {
  105.72  #if defined (__x86_64__)
  105.73 -    __vmread(GUEST_RFLAGS, &regs->rflags);
  105.74 -    __vmread(GUEST_SS_SELECTOR, &regs->ss);
  105.75 -    __vmread(GUEST_CS_SELECTOR, &regs->cs);
  105.76 -    __vmread(GUEST_DS_SELECTOR, &regs->ds);
  105.77 -    __vmread(GUEST_ES_SELECTOR, &regs->es);
  105.78 -    __vmread(GUEST_GS_SELECTOR, &regs->gs);
  105.79 -    __vmread(GUEST_FS_SELECTOR, &regs->fs);
  105.80 -    __vmread(GUEST_RIP, &regs->rip);
  105.81 -    __vmread(GUEST_RSP, &regs->rsp);
  105.82 +        __vmread(GUEST_RFLAGS, &regs->rflags);
  105.83 +        __vmread(GUEST_SS_SELECTOR, &regs->ss);
  105.84 +        __vmread(GUEST_CS_SELECTOR, &regs->cs);
  105.85 +        __vmread(GUEST_DS_SELECTOR, &regs->ds);
  105.86 +        __vmread(GUEST_ES_SELECTOR, &regs->es);
  105.87 +        __vmread(GUEST_GS_SELECTOR, &regs->gs);
  105.88 +        __vmread(GUEST_FS_SELECTOR, &regs->fs);
  105.89 +        __vmread(GUEST_RIP, &regs->rip);
  105.90 +        __vmread(GUEST_RSP, &regs->rsp);
  105.91  #elif defined (__i386__)
  105.92 -    __vmread(GUEST_RFLAGS, &regs->eflags);
  105.93 -    __vmread(GUEST_SS_SELECTOR, &regs->ss);
  105.94 -    __vmread(GUEST_CS_SELECTOR, &regs->cs);
  105.95 -    __vmread(GUEST_DS_SELECTOR, &regs->ds);
  105.96 -    __vmread(GUEST_ES_SELECTOR, &regs->es);
  105.97 -    __vmread(GUEST_GS_SELECTOR, &regs->gs);
  105.98 -    __vmread(GUEST_FS_SELECTOR, &regs->fs);
  105.99 -    __vmread(GUEST_RIP, &regs->eip);
 105.100 -    __vmread(GUEST_RSP, &regs->esp);
 105.101 -#else
 105.102 -#error Unsupported architecture
 105.103 +        __vmread(GUEST_RFLAGS, &regs->eflags);
 105.104 +        __vmread(GUEST_SS_SELECTOR, &regs->ss);
 105.105 +        __vmread(GUEST_CS_SELECTOR, &regs->cs);
 105.106 +        __vmread(GUEST_DS_SELECTOR, &regs->ds);
 105.107 +        __vmread(GUEST_ES_SELECTOR, &regs->es);
 105.108 +        __vmread(GUEST_GS_SELECTOR, &regs->gs);
 105.109 +        __vmread(GUEST_FS_SELECTOR, &regs->fs);
 105.110 +        __vmread(GUEST_RIP, &regs->eip);
 105.111 +        __vmread(GUEST_RSP, &regs->esp);
 105.112  #endif
 105.113 +    }
 105.114 +
 105.115 +    if ( crs != NULL )
 105.116 +    {
 105.117 +        __vmread(CR0_READ_SHADOW, &crs[0]);
 105.118 +        __vmread(GUEST_CR3, &crs[3]);
 105.119 +        __vmread(CR4_READ_SHADOW, &crs[4]);
 105.120 +    }
 105.121 +
 105.122 +    /* Reload current VCPU's VMCS if it was temporarily unloaded. */
 105.123 +    if ( (v != current) && hvm_guest(current) )
 105.124 +        __vmptrld(virt_to_maddr(current->arch.hvm_vmx.vmcs));
 105.125  }
 105.126  
 105.127  void vmx_load_cpu_guest_regs(struct vcpu *v, struct cpu_user_regs *regs)
 105.128 @@ -455,13 +508,6 @@ void vmx_load_cpu_guest_regs(struct vcpu
 105.129  #endif
 105.130  }
 105.131  
 105.132 -void vmx_store_cpu_guest_ctrl_regs(struct vcpu *v, unsigned long crs[8])
 105.133 -{
 105.134 -    __vmread(CR0_READ_SHADOW, &crs[0]);
 105.135 -    __vmread(GUEST_CR3, &crs[3]);
 105.136 -    __vmread(CR4_READ_SHADOW, &crs[4]);
 105.137 -}
 105.138 -
 105.139  void vmx_modify_guest_state(struct vcpu *v)
 105.140  {
 105.141      modify_vmcs(&v->arch.hvm_vmx, &v->arch.guest_context.user_regs);
 105.142 @@ -615,7 +661,6 @@ int start_vmx(void)
 105.143      hvm_funcs.store_cpu_guest_regs = vmx_store_cpu_guest_regs;
 105.144      hvm_funcs.load_cpu_guest_regs = vmx_load_cpu_guest_regs;
 105.145  
 105.146 -    hvm_funcs.store_cpu_guest_ctrl_regs = vmx_store_cpu_guest_ctrl_regs;
 105.147      hvm_funcs.modify_guest_state = vmx_modify_guest_state;
 105.148  
 105.149      hvm_funcs.realmode = vmx_realmode;
 105.150 @@ -945,7 +990,7 @@ static void vmx_io_instruction(struct cp
 105.151          port = (exit_qualification >> 16) & 0xFFFF;
 105.152      else
 105.153          port = regs->edx & 0xffff;
 105.154 -    TRACE_VMEXIT(2, port);
 105.155 +    TRACE_VMEXIT(1, port);
 105.156      size = (exit_qualification & 7) + 1;
 105.157      dir = test_bit(3, &exit_qualification); /* direction */
 105.158  
 105.159 @@ -1308,7 +1353,8 @@ static int vmx_set_cr0(unsigned long val
 105.160              vm_entry_value |= VM_ENTRY_CONTROLS_IA32E_MODE;
 105.161              __vmwrite(VM_ENTRY_CONTROLS, vm_entry_value);
 105.162  
 105.163 -            if ( !shadow_set_guest_paging_levels(v->domain, 4) ) {
 105.164 +            if ( !shadow_set_guest_paging_levels(v->domain, PAGING_L4) )
 105.165 +            {
 105.166                  printk("Unsupported guest paging levels\n");
 105.167                  domain_crash_synchronous(); /* need to take a clean path */
 105.168              }
 105.169 @@ -1317,9 +1363,26 @@ static int vmx_set_cr0(unsigned long val
 105.170  #endif  /* __x86_64__ */
 105.171          {
 105.172  #if CONFIG_PAGING_LEVELS >= 3
 105.173 -            if ( !shadow_set_guest_paging_levels(v->domain, 2) ) {
 105.174 -                printk("Unsupported guest paging levels\n");
 105.175 -                domain_crash_synchronous(); /* need to take a clean path */
 105.176 +            /* seems it's a 32-bit or 32-bit PAE guest */
 105.177 +
 105.178 +            if ( test_bit(VMX_CPU_STATE_PAE_ENABLED,
 105.179 +                        &v->arch.hvm_vmx.cpu_state) )
 105.180 +            {
 105.181 +                /* The guest enables PAE first and then it enables PG, it is
 105.182 +                 * really a PAE guest */
 105.183 +                if ( !shadow_set_guest_paging_levels(v->domain, PAGING_L3) )
 105.184 +                {
 105.185 +                    printk("Unsupported guest paging levels\n");
 105.186 +                    domain_crash_synchronous();
 105.187 +                }
 105.188 +            }
 105.189 +            else
 105.190 +            {
 105.191 +                if ( !shadow_set_guest_paging_levels(v->domain, PAGING_L2) )
 105.192 +                {
 105.193 +                    printk("Unsupported guest paging levels\n");
 105.194 +                    domain_crash_synchronous(); /* need to take a clean path */
 105.195 +                }
 105.196              }
 105.197  #endif
 105.198          }
 105.199 @@ -1399,6 +1462,12 @@ static int vmx_set_cr0(unsigned long val
 105.200              return 0; /* do not update eip! */
 105.201          }
 105.202      }
 105.203 +    else if ( (value & (X86_CR0_PE | X86_CR0_PG)) == X86_CR0_PE )
 105.204 +    {
 105.205 +        /* we should take care of this kind of situation */
 105.206 +        clear_all_shadow_status(v->domain);
 105.207 +        __vmwrite(GUEST_CR3, pagetable_get_paddr(v->domain->arch.phys_table));
 105.208 +    }
 105.209  
 105.210      return 1;
 105.211  }
 105.212 @@ -1528,11 +1597,11 @@ static int mov_to_cr(int gp, int cr, str
 105.213  
 105.214              if ( vmx_pgbit_test(v) )
 105.215              {
 105.216 -                /* The guest is 32 bit. */
 105.217 +                /* The guest is a 32-bit PAE guest. */
 105.218  #if CONFIG_PAGING_LEVELS >= 4
 105.219                  unsigned long mfn, old_base_mfn;
 105.220  
 105.221 -                if( !shadow_set_guest_paging_levels(v->domain, 3) )
 105.222 +                if( !shadow_set_guest_paging_levels(v->domain, PAGING_L3) )
 105.223                  {
 105.224                      printk("Unsupported guest paging levels\n");
 105.225                      domain_crash_synchronous(); /* need to take a clean path */
 105.226 @@ -1572,12 +1641,31 @@ static int mov_to_cr(int gp, int cr, str
 105.227              }
 105.228              else
 105.229              {
 105.230 -                /*  The guest is 64 bit. */
 105.231 +                /*  The guest is a 64 bit or 32-bit PAE guest. */
 105.232  #if CONFIG_PAGING_LEVELS >= 4
 105.233 -                if ( !shadow_set_guest_paging_levels(v->domain, 4) )
 105.234 +                if ( (v->domain->arch.ops != NULL) &&
 105.235 +                        v->domain->arch.ops->guest_paging_levels == PAGING_L2)
 105.236                  {
 105.237 -                    printk("Unsupported guest paging levels\n");
 105.238 -                    domain_crash_synchronous(); /* need to take a clean path */
 105.239 +                    /* Seems the guest first enables PAE without enabling PG,
 105.240 +                     * it must enable PG after that, and it is a 32-bit PAE
 105.241 +                     * guest */
 105.242 +
 105.243 +                    if ( !shadow_set_guest_paging_levels(v->domain,
 105.244 +                                                            PAGING_L3) )
 105.245 +                    {
 105.246 +                        printk("Unsupported guest paging levels\n");
 105.247 +                        /* need to take a clean path */
 105.248 +                        domain_crash_synchronous();
 105.249 +                    }
 105.250 +                }
 105.251 +                else
 105.252 +                {
 105.253 +                    if ( !shadow_set_guest_paging_levels(v->domain,
 105.254 +                                                            PAGING_L4) )
 105.255 +                    {
 105.256 +                        printk("Unsupported guest paging levels\n");
 105.257 +                        domain_crash_synchronous();
 105.258 +                    }
 105.259                  }
 105.260  #endif
 105.261              }
 105.262 @@ -1827,6 +1915,7 @@ static inline void vmx_vmexit_do_extint(
 105.263  
 105.264      vector &= 0xff;
 105.265      local_irq_disable();
 105.266 +    TRACE_VMEXIT(1,vector);
 105.267  
 105.268      switch(vector) {
 105.269      case LOCAL_TIMER_VECTOR:
 105.270 @@ -1956,7 +2045,6 @@ asmlinkage void vmx_vmexit_handler(struc
 105.271  
 105.272      {
 105.273          __vmread(GUEST_RIP, &eip);
 105.274 -        TRACE_3D(TRC_VMX_VMEXIT, v->domain->domain_id, eip, exit_reason);
 105.275          TRACE_VMEXIT(0,exit_reason);
 105.276      }
 105.277  
 105.278 @@ -1980,7 +2068,6 @@ asmlinkage void vmx_vmexit_handler(struc
 105.279          TRACE_VMEXIT(1,vector);
 105.280          perfc_incra(cause_vector, vector);
 105.281